Home My Page Projects Code Snippets Project Openings SML/NJ
Summary Activity Forums Tracker Lists Tasks Docs Surveys News SCM Files

SCM Repository

[smlnj] Annotation of /sml/trunk/compiler/MAP
ViewVC logotype

Annotation of /sml/trunk/compiler/MAP

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2603 - (view) (download)

1 : macqueen 1481 Front End Map
2 :     -------------
3 : macqueen 1344
4 : macqueen 1481 A color-coded map of the directory structure is available as
5 :     a pdf file, or Omnigraffle source file.
6 :    
7 : macqueen 1344 1. Lexing and Parsing
8 : macqueen 1473 ----------------------
9 : macqueen 1344
10 : macqueen 1473 * syntax trees (AST) produced by parser
11 :     * lexical analysis (via ML-Lex spec)
12 :     * parsing (via ML-Yacc spec)
13 :    
14 : macqueen 1344 Parse/
15 :     lexing and parsing, producing ast (concrete syntax trees)
16 :    
17 : macqueen 1473 Parse/ast/
18 :     "syntax trees" (really concrete, in contrast to absyn, which is
19 :     the true abstract syntax)
20 :     ast.sig/sml
21 :     the syntax tree types
22 :     defs: AST, Ast: AST
23 :     astutil.sig/sml
24 :     some utility functions
25 :     defs: ASTUTIL, AstUtil: ASTUTIL
26 : macqueen 1344
27 : macqueen 1473 Parse/lex/
28 :     lexical analysis (via ML-Lex)
29 :     ml.lex
30 :     the lexer spec (ML-Lex source)
31 :     tokentable.sml
32 :     hash table for token recognition
33 :     defs: TokenTable
34 : macqueen 1344
35 : macqueen 1473 Parse/parse/
36 :     parsing (via ML-Yacc)
37 :     ml.grm
38 :     grammar spec (ML-Yacc source)
39 : macqueen 1344
40 : macqueen 1473 Parse/main/
41 :     control flags and parser driver functions.
42 :     lexer/parser combination translates input stream into ast trees
43 :     parser.sig/sml
44 :     parser modules initialization, driver function
45 :     defs: MLPARSER, MLParser: MLPARSER
46 :     parsercontrol.sml
47 :     flags controlling various syntax features
48 :     defs: PARSER_CONTROL, ParserControl
49 :     smlfile.sml
50 :     top level parsing functions
51 :     defs: SMLFILE, SmlFile
52 : macqueen 1344
53 :    
54 :     2. Elaboration
55 : macqueen 1473 --------------
56 : macqueen 1344
57 : macqueen 1473 * abstract syntax (absyn)
58 :     * static environments
59 :     * translation from ast to abstract syntax and static environment (elaboration)
60 :     * core type checking and inference, overloading resolution
61 :     * modules and signatures, signature matching, functor application
62 :     * code found in directories Semant, ElabData, Elaborator
63 : macqueen 1466
64 : macqueen 1473 Basics/
65 : macqueen 1466
66 : macqueen 1473 Basics/mlcomp/
67 :     some basic types involved in absyn and statenv and elaboration process
68 :     symbol.sig/sml
69 :     symbols (should be in ElabData)
70 :     defs: SYMBOL, Symbol
71 :     fastsymbol.sig/sml
72 :     fast symbols (should be in ElabData)
73 :     defs: FASTSYMBOL, FastSymbol
74 :     fixity.sml
75 :     fixity properties (should be in ElabData)
76 :     defs: FIXITY, Fixity
77 :     persstamps.sig/sml
78 :     persistant stamps, or globally unique identifiers (16 byte vectors),
79 :     aka "pids"
80 :     defs: PERSSTAMPS, PersStamps : PERSSTAMPS
81 :     persmap.sml
82 :     finite maps over pids (persistent stamps)
83 :     defs: PersMap
84 :     pidenv.sig/sml
85 :     environments using pids (persistant stamps) as keys
86 :     defs: PIDENV, PidEnvFn
87 :     compileexn.sml
88 :     Compile exception (where used?)
89 :     defs: CompileExn
90 : macqueen 1466
91 : macqueen 1473 Basics/miscutil/ (why not in MiscUtil?)
92 :     intstrmap.sig/sml
93 :     int/string maps for use in environments;
94 :     appears redundant with IntStrMapV defined in
95 :     Env (ElabData/basics/env.sml)
96 :     used in Tuples, ElabCore, Parse/lex/tokentable.sml.
97 :     see: ElabData/basics/env.sml
98 :     defs: INTSTRMAP, IntStrMap
99 : macqueen 1466
100 : macqueen 1473 Basics/errormsg/
101 :     errormsg.sig/sml
102 :     error messages
103 :     defs: ERRORMSG, ErrorMsg
104 : macqueen 1466
105 : macqueen 1473 Basics/source/
106 :     managing ML source files or streams
107 :     pathnames.sig/sml
108 :     file path names
109 :     defs: PATHNAMES, Pathnames
110 :     source.sig/sml
111 :     input source datastructure
112 :     defs: SOURCE, Source
113 :     sourcemap.sig/sml
114 :     map character positions in source to line no/column supporting #line "declaration"
115 :     defs: SOURCE_MAP, SourcMap
116 : macqueen 1466
117 : macqueen 1473 Basics/print/
118 :     utilities for prettyprinting
119 :     [pp-wrapper.sml -- obsolete for mcz, where new pp is used directly]
120 :     implements old PP interface using new SML/NJ Lib PP
121 :     pp-init.sml
122 :     extend standard prettyprinter interface to match old one
123 :     defs: PRETTYPRINT, PrettyPrint
124 :     printutil.sig/sml
125 :     some print utilities (uses Symbol)
126 :     defs: PRINTUTIL, PrintUtil
127 :     printcontrol.sml
128 :     print control flags, out, say
129 :     defs: PRINTCONTROL, Control_Print
130 : macqueen 1466
131 : macqueen 1473 Basics/stats/
132 :     stats.sml
133 :     facilities for defining timed phases
134 :     defs: STATS, Stats
135 : macqueen 1466
136 : macqueen 1473 Basics/main/
137 :     basiccontrol.sml
138 :     printWarning control flag, topregistry
139 :     uses: ControlRegistry, Controls
140 :     defs: BASIC_CONTROL, BasicControl
141 : macqueen 1466
142 : macqueen 1473 Semant/
143 :     Modules related to elaboration and pickling (external representation
144 :     of static environments)
145 : macqueen 1344
146 : dbm 2603 [#Deleted: replaced by ElabData/basics/primopid.sig,sml
147 : macqueen 1473 Semant/basics/
148 :     inlinfo.sig/sml
149 :     inlining info [FLINT]
150 :     defs: INL_INFO, InlInfo: INL_INFO
151 : dbm 2603 ]
152 : macqueen 1344
153 : macqueen 1473 Semant/elaborate/
154 :     apply functors defined in corresponding Elaborate/elaborate modules
155 :     [these could be in Elaborator]
156 :     elabmod.sml
157 : macqueen 1481 module level elaboration: defines ElabMod by calling ElabModFn defined
158 :     in Elaborate/elaborate/elabmod.sml (should go to Elaborator)
159 : macqueen 1473 see: Elaborator/elaborate/elabmod.sml
160 :     defs: ElabMod
161 :     elabtop.sml
162 : macqueen 1481 top-level elaboration: defined ElabTop by calling ElabTopFn defined
163 :     in Elaborator/elaborate/elabtop.sml (should go to Elaborator)
164 :     see: Elaborator/elaborate/elabtop.sml
165 : macqueen 1473 defs: ElabTop
166 : macqueen 1344
167 : macqueen 1473 Semant/modules/
168 :     support for module elaboration
169 :     evalent.sml
170 :     entity expression evaluation;
171 :     applies functor EvalEntityFn from Elaborator/modules/evalent.sml
172 :     see: Elaborator/modules/evalent.sml
173 :     defs: EvalEntity
174 :     instantiate.sml
175 :     apply InstantitateFn defined in Elaborator/modules/instantiate.sml
176 :     see: Elaborator/modules/instantiate.sml
177 :     defs: Instantiate
178 :     instantiate-param.sml
179 :     defines parameter passed to InstantiateFn in ./instantiate.sml
180 :     see: Semant/modules/instantiate.sml (previous file)
181 :     defs: InstantiateParam
182 :     module-plists.sml [FLINT]
183 :     defines PropList properties for attaching FLINT Lambda types to
184 :     various semantic entities
185 :     see: smlnj-lib/Util/plist{-sig}.sml
186 :     defs: ModulePropLists
187 :     sigmatch.sml
188 :     apply SigmatchFn defined in Elaborator/modules/sigmatch.sml
189 :     see: Elaborator/modules/sigmatch.sml
190 :     defs: SigMatch
191 : macqueen 1344
192 : macqueen 1473 Semant/pickle/
193 :     pickling static environments
194 :     pickle-sym-pid.sml
195 : dbm 2603 pickling symbols and pids (persistant stamps)
196 :     uses: PickleUtil
197 :     defs: PickleSymPid (inline sig)
198 : macqueen 1473 unpickle-sym-pid.sml
199 : dbm 2603 unpickling symbols and pids (persistant stamps)
200 :     defs: UnpickleSymPid (inline sig)
201 :     pickmod.sml
202 :     pickling functions for each type involved in staticEnv
203 :     defs: PICKMOD, PickMod :> PICKMOD
204 :     unpickmod.sml
205 :     unpickling functions for each type involved in staticEnv
206 :     defs: UNPICKMOD, UnpickMod : UNPICKMOD
207 : macqueen 1473 rehash.sml
208 : dbm 2603 recompute hash of an environment resulting from filtering
209 :     a larger invironment
210 :     defs: Rehash (inline sig)
211 : macqueen 1344
212 : macqueen 1473 Semant/statenv/
213 : dbm 2603 construction of base static environment for environment bootstrap
214 :     and table mapping primop names to intrinsic primop types
215 : macqueen 1473 prim.sml
216 :     define static env primEnv, containing primitive types (PrimTypes),
217 :     primops (InLine), and unrolled lists (UnrolledList)
218 :     defs: PRIM_ENV, PrimEnv: PRIM_ENV
219 : dbm 2603 primoptypemap.sml
220 :     defines mapping from primop names (strings) to their "intrinsic" types
221 :     defs: PRIMOP_TYPE_MAP, PrimOpTypeMap
222 : macqueen 1344
223 : macqueen 1473 Semant/types/
224 :     some types-related stuff
225 :     cproto.sml
226 :     relating ML types and C types (CTypes.c_proto from MLRISC) for C call mechanism
227 :     defs: CProto
228 :     tp-var-info.sml [FLINT]
229 :     packaging some FLINT info as an exception
230 :     defs: TVI
231 :     types-reformat.sml [FLINT]
232 :     FLINT-related "reformatting" of types, used to be in typesutil.sml
233 :     defs: TypesReformat
234 : dbm 2603 [#Deleted: type checker is no longer functorized
235 : macqueen 1473 typecheck.sml [FLINT]
236 :     apply TypecheckFn defined in Elaborator/types/typecheck.sml (should eliminate)
237 :     see: Elaborator/types/typecheck.sml
238 :     defs: TypeCheck
239 : dbm 2603 ]
240 : macqueen 1344
241 :    
242 : macqueen 1473 ElabData/
243 :     Basic datastructures used in elaboration (including type checking)
244 : macqueen 1344
245 : macqueen 1473 ElabData/basics/
246 :     basic representation types used in elaboration, plus coresym
247 :     lambdavar.sig/sml
248 :     lambda variables, the abstract representation of variables, used
249 :     as roots of dynamic access chains
250 :     defs: LAMBDA_VAR, LambdaVar
251 :     access.sig/sml
252 :     dynamic access paths
253 :     defs: ACCESS, Access : ACCESS
254 :     env.sig/sml
255 :     generic environments, mapping symbols to unspecified binding type
256 :     defs: ENV, Env: ENV, INTSTRMAPV
257 :     stamps.sig/sml
258 :     static identifiers, used for nominal type equivalence
259 :     defs: STAMPS, Stamps:> STAMPS
260 :     stampmap.sml
261 :     generic finite mappings over stamps
262 :     defs: StampMap
263 :     sympaths.sig/sml
264 :     SymPath and InvPath: direct and inverse symbolic paths (selecting
265 :     module components)
266 :     defs: SYMPATH, INVPATH, CONVERTPATHS, SymPath, InvPath, ConvertPaths
267 : dbm 2603 [#Deleted
268 : macqueen 1473 ii.sml [FLINT]
269 :     FLINT related information for inlining (why is this in elaborator?)
270 :     defs: II
271 : dbm 2603 #]
272 : macqueen 1473 core-ptnum.sml
273 :     core prim-type numbers (essentially the same as Elaborator/basics/ptnum.sml
274 :     except only language-standard types are included)
275 :     see: Elaborator/basics/ptnum.sml
276 :     defs: CORE_PRIM_TYC_NUM, CorePrimTycNum
277 :     coresym.sml
278 :     defines the special structure symbol "_Core" used to access certain
279 :     special bindings (e.g Match and Bind exceptions)
280 :     defs: CoreSym
281 : dbm 2603 primopid.sig/sml
282 :     defines front-end representation of primops, where a primop is identified
283 :     with a string name
284 :     defs: PRIMOPID, PrimopId
285 : macqueen 1344
286 : macqueen 1473 ElabData/syntax/
287 :     (typed) abstract syntax
288 :     absyn.sig/sml
289 :     the abstract syntax types
290 :     defs: ABSYN, Absyn: ABSYN
291 :     varcon.sig/sml
292 :     variable and data constructor representations
293 :     defs: VARCON, VarCon: VARCON
294 :     absynutil.sml
295 :     utility functions for building tuple patterns and expressions
296 :     defs: AbsynUtil
297 : macqueen 1344
298 : macqueen 1473 ElabData/types/
299 :     representing, constructing and manipulating types
300 :     types.sig/sml
301 :     the representation of SML types
302 :     defs: TYPES, Types: TYPES
303 :     typesutil.sig/sml
304 :     large collection of utility functions for working with types
305 :     defs: TYPESUTIL, TypesUtil: TYPESUTIL
306 :     tuples.sml
307 :     fns for constructing tuple and record types
308 :     defs: TUPLES, Tuples: TUPLES
309 :     core-basictypes.sml
310 :     building the primitive types and associated values (containing only
311 :     implementation independent, language-standard basic types?)
312 :     see: Elaborator/types/basictypes.sml
313 :     defs: CoreBasicTypes
314 : macqueen 1344
315 : macqueen 1473 ElabData/statenv/
316 :     static environments
317 :     bindings.sig/sml
318 :     the basic binding forms (values, types, signatures, etc.)
319 :     defs: BINDINGS, Bindings: BINDINGS
320 :     statenv.sig/sml
321 :     instantiate generic environments with ML bindings
322 :     defs: STATICENV, StaticEnv: STATICENV
323 :     lookup.sig/sml
324 :     accessing symbols in environments
325 :     defs: LOOKUP, Lookup : LOOKUP
326 :     genmap.sml
327 :     rapid modmap generation based on modtrees
328 :     defs: GenModIdMap
329 :     coreacc.sml
330 :     access components of the _Core structure
331 :     defs: CoreAccess
332 :     browse.sml
333 :     "browsing" the static environment (not used???)
334 :     defs: BrowseStatEnv
335 : macqueen 1344
336 : macqueen 1473 ElabData/modules/
337 :     representation of modules
338 :     modules.sig/sml
339 :     representation of modules and signatures
340 :     defs: MODULES, Modules: MODULES
341 :     moduleutil.sig/sml
342 :     lots of utility functions for modules
343 :     defs: MODULEUTIL, ModuleUtil: MODULEUTIL
344 :     moduleid.sml
345 :     module identities used in Modmaps ???
346 :     defs: MODULE_ID, ModuleId: MODULE_ID
347 :     entpath.sml
348 :     access paths for navigating entities
349 :     defs: ENT_PATH, EntPath:> ENT_PATH
350 :     entityenv.sig/sml
351 :     enity environments mapping entity variables
352 :     defs: ENTITY_ENV, EntityEnv : ENTITY_ENV
353 :     epcontext.sml
354 :     hairy context info used during module elaboration,
355 :     related to nesting of modules (ep stands for
356 :     "entity path"?)
357 :     defs: ENT_PATH_CONTEXT, EntPathContext :> ENT_PATH_CONTEXT
358 : macqueen 1344
359 : macqueen 1473 ElabData/main/
360 :     compinfo.sml
361 :     elaboration context parameter
362 :     defs: CompInfo
363 :     edcontrol.sig/sml
364 :     control flags for ElabData
365 :     defs: ELABDATA_CONTROL, ElabDataControl : ELABDATA_CONTROL
366 : macqueen 1344
367 :    
368 : macqueen 1473 Elaborator/
369 :     The main elaborator code, plus some representation stuff in basics/,
370 :     plus printing modules in print/.
371 : macqueen 1344
372 : macqueen 1473 Elaborator/basics/
373 :     some control flags, some representation types, some FLINT stuff
374 :     elabcontrol.sml
375 :     Elaborator control flags
376 :     defs: ElabControl
377 :     conrep.sml
378 :     inferring conreps for data constructors
379 :     defs: CONREP, ConRep: CONREP
380 :     debindex.sig/sml [FLINT]
381 :     FLINT book-keeping (move back to FLINT)
382 :     defs: DEB_INDEX, DebIndex : DEB_INDEX
383 :     ptnum.sml
384 :     prim type numbers, augmenting ElabData/basics/core-ptnum.sml with
385 :     implementation dependent types
386 :     see: ElabData/basics/core-ptnum.sml
387 :     defs: PRIM_TYC_NUM, PrimTycNum: PRIM_TYC_NUM
388 : macqueen 1344
389 : macqueen 1473 Elaborator/print/ [should be in ElabData?]
390 :     print utilities and print modules for elaboration data structures
391 :     pputil.sig/sml
392 :     prettyprint utilities (generic) [**MOVE**]
393 :     pptype.sml
394 :     prettyprint types
395 :     ppval.sml
396 :     prettyprint variables and dcons
397 :     ppmod.sml
398 :     prettyprint modules and signatures
399 :     ppabsyn.sml
400 :     prettyprint absyn (uses PPUtil(pputil.s??),
401 :     PPVal(ppval.sml), PPType(pptype.sml))
402 : macqueen 1344
403 : macqueen 1473 Elaborator/types/
404 :     building basic types + typechecking modules
405 :     basictypes.sig/sml
406 :     define basic (built-in) types; most are just defined in terms of
407 :     types from CoreBasicTypes [MOVE to ElabData?]
408 :     see: ElabData/types/core-basictypes.sml
409 :     defs: BasicTypes
410 :     eqtypes.sml
411 :     equivalence of types
412 :     defs: EQTYPES, EqTypes: EQTYPES
413 :     unify.sml
414 :     type unification
415 :     defs: UNIFY, Unify: UNIFY
416 :     overloadlit.sml
417 :     overloaded numeric literals
418 :     defs: OVERLOADLIT, OverloadLit: OVERLOADLIT
419 :     overload.sml
420 :     overloading resolution
421 :     defs: OVERLOAD, Overload
422 :     typecheck.sml [FLINT]
423 :     defines typechecking _functor_ TypecheckFn, taking some FLINT-related
424 :     inlining info as parameters [should make into a structure]
425 :     defs: TYPECHECK, TypecheckFn: _ => TYPECHECK
426 : macqueen 1344
427 : macqueen 1473 Elaborator/modules/
428 :     support modules for elaborating modules
429 :     evalent.sml
430 :     evaluate "entities" (module and type realizations). Defines EvalEntityFn
431 :     which is called to define EvalEntity structure in Semant/modules/evalent.sml
432 :     see: Semant/modules/evalent.sml
433 :     defs: EVALENTITY, EvalEntityFn : INSTANTIATE => EVALENTITY
434 :     expandtycon.sml
435 :     interpret PATHtycs in entity environments
436 :     defs: EXPAND_TYCON, ExpandTycon : EXPAND_TYCON
437 :     instantiate.sml
438 :     free instantiation of signatures. defines InstantiateFn which is applied
439 :     to define structure Instantiate in Semant/modules/instantiate.sml
440 :     see: Semant/modules/instantiate.sml
441 :     defs: INSTANTIATE_PARAM, INSTANTIATE,
442 :     InstantiateFn: INSTANTIATE_PARAM => INSTANTIATE
443 :     sigmatch.sml
444 :     signature matching. defines SigMatchFn, which is applied to define
445 :     SigMatch structure in Semant/modules/sigmatch.sml
446 :     see: Semant/modules/sigmatch.sml
447 :     defs: SIGMATCH, SigMatchFn: EVALENTITY => SIGMATCH
448 : macqueen 1344
449 : macqueen 1473 Elaborator/elaborate/
450 :     main elaboration modules, plus some supporting modules
451 :     tyvarset.sml
452 :     type var sets for keeping track of implicit scopes of user type vars
453 :     defs: TYVARSET, TyvarSet :> TYVARSET
454 :     specialsyms.sml
455 :     definition of special symbols for internal use
456 :     defs: SpecialSymbols
457 :     elabutil.sig/sml
458 :     general utilities for elaboration
459 :     defs: ELABUTIL, ElabUtil : ELABUTIL
460 :     elabdebug.sml
461 :     debugging facilities for elaboration
462 :     defs: ELABDEBUG, ElabDebug : ELABDEBUG
463 :     precedence.sml
464 :     precedence parser for core expressions, dealing with infix operators
465 :     defs: PRECEDENCE, Precedence : PRECEDENCE
466 :     elabtype.sig/sml
467 :     elaboration of type expressions and declarations
468 :     defs: ELABTYPE, ElabType : ELABTYPE
469 :     elabcore.sml
470 :     elaborating core ML (expressions, declarations)
471 :     defs: ELABCORE, ElabCore: ELABCORE
472 :     elabmod.sml
473 :     main module elaboration. defines ElabModFn, which is called to
474 :     define ElabMod structure in Semant/elaborate/elabmod.sml
475 :     see: Semant/elaborate/elabmod.sml
476 :     defs: ELABMOD, ElabModFn: SIGMATCH # TYPECHECK => ELABMOD
477 :     include.sml
478 :     elaborate include specs in signatures (supports elabsig)
479 :     defs: INCLUDE, Include: INCLUDE
480 :     elabsig.sml
481 :     elaborate signatures
482 :     defs: ELABSIG, ElabSig : ELABSIG
483 :     elabtop.sml
484 :     top-level elaboration driver. defines ElabTopFn, which is called
485 :     to define ElabTop structure in Semant/elaborate/elabtop.sml
486 :     see: Semant/elaborate/elabtop.sml
487 :     defs: ELABTOP, ElabTopFn : ELABMOD => ELABTOP
488 : macqueen 1344
489 :    
490 :     3. Miscellaneous utilities
491 :    
492 :     MiscUtil/
493 :     Contains various kinds of utility programs
494 :    
495 :     bignums/
496 : macqueen 1473 supporting real constants (using bignums?)
497 :     ieeereal.sml
498 :     Support for IEEE floating-point constants. calls RealConst functor
499 :     see: MiscUtil/bignums/realconst.sml
500 :     defs: IEEERealConst
501 :     realconst.sml
502 :     generate ML real (i.e. ieee floating point?) constants
503 :     defs: PRIMREAL, REALCONST, RealConst: PRIMREAL => REALCONST
504 : macqueen 1344
505 :     library/
506 : macqueen 1473 Utility modules that are candidates for eventual
507 :     promotion to general libraries (crc and pickling)
508 :     crc.sml
509 :     crc codes
510 :     defs: CRC, CRC :> CRC
511 :     pickle-lib.cm
512 :     CM description for basic pickling/unpickling library
513 :     pickle-util.sml
514 :     supporting pickling
515 :     defs: PICKLE_UTIL, PickleUtil :> PICKLE_UTIL
516 :     unpickle-util.sml
517 :     supporting unpickling
518 :     defs: UNPICKLE_UTIL, UnpickleUtil :> UNPICKLE_UTIL
519 : macqueen 1344
520 :     print/
521 : macqueen 1473 Pretty printing for absyn declarations, values
522 :     ppdec.sml
523 :     printing results of top-level declarations, including values and types
524 :     defs: PPDEC, PPDec : PPDEC
525 :     ppobj.sml
526 :     print top-level values
527 :     defs: PPOBJ, PPObj : PPOBJ
528 :     pptable.sml
529 :     register for user-defined prettyprinters for datatypes
530 :     defs: PPTABLE, PPTable : PPTABLE
531 : macqueen 1344
532 :     util/
533 : macqueen 1473 A couple of miscellaneous leftovers.
534 :     feedback.sml
535 :     Compute minimum feedback vertex set of a given directed graph.
536 :     should be part of a graph library (move to ../library?)
537 :     defs: Feedback
538 :     literal-to-num.sml
539 :     Conversions from integer/word literals (which are represented as
540 :     arbitrary precision ints) to fixed size. a hack that should be
541 :     replaced by a parameterized numeric types.
542 :     size numbers
543 :     defs: LITERAL_TO_NUM, LiteralToNum : LITERAL_TO_NUM
544 : macqueen 1344
545 :    
546 : macqueen 1473 3. Middle End
547 :     -------------
548 : macqueen 1344
549 : macqueen 1473 FLINT/
550 :     intermediate representation (a form of typed lambda calculus)
551 : macqueen 1344
552 : macqueen 1473 [see FLINT/MAP]
553 : macqueen 1344
554 :    
555 : macqueen 1473 4. Back End
556 :     -----------
557 : macqueen 1344
558 : macqueen 1473 MLRISC/
559 :     MLRISC based code generators
560 : macqueen 1344
561 :    
562 : macqueen 1473 5. Execution Model
563 :     -----------------
564 : macqueen 1344
565 : macqueen 1473 Execution/
566 : macqueen 1344
567 : macqueen 1473 dynenv/
568 :     dynenv.sig,sml
569 :     dynamic environments, and instance of PidEnvFn
570 :     see: Basics/mlcomp/pidenv.sml
571 :     defs: DYNAMICENV, DynamicEnv : DYNAMICENV
572 :     codeobj/
573 :     code-obj.sig,sml
574 :     an interface for manipulating code objects
575 :     defs: CODE_OBJ, CodeObj :> CODE_OBJ
576 :     binfile/
577 :     binfile.sig,sml
578 :     file format for bin files (machine-independent)
579 :     defs: BINFILE, Binfile :> BINFILE
580 :     main/
581 :     importtree.sml
582 :     defs: ImportTree
583 :     isolate.sml
584 :     isolate the continuation context to the top-level (a prompt?)
585 :     defs: Isolate
586 :     execute.sml
587 :     execution of top-level executables in a dynamic environment
588 :     defs: Execute
589 : macqueen 1344
590 :    
591 : macqueen 1473 6. Interactive Top Level
592 :     ------------------------
593 : macqueen 1344
594 : macqueen 1473 TopLevel/
595 :    
596 :     environ/
597 :     combined static and dynamic environments
598 :     environ.sig,sml
599 :     defs: ENVIRONMENT, Environment: ENVIRONMENT
600 :     symenv.sig,sml
601 :     defines SYMENV as a specialization of PIDENV, and SymbolicEnv as
602 :     an instance of PidEnvFn.
603 :     see: Basics/mlcomp/pidenv.sig, Basics/mlcomp/pidenv.sml
604 :     defs: SYMENV, SymbolicEnv: SYMENV
605 :    
606 :     backend/
607 :     backend.sig
608 :     defs: BACKEND
609 :     backend-fn.sml
610 :     defs: BackendFn : CODEGENERATOR # {val cproto_conv : string} => BACKEND
611 :     alpha32.sml
612 :     defs: Alpha32Backend
613 :     hppa.sml
614 :     defs: HppaBackend
615 :     ppc.sml
616 :     defs: PPCBackend
617 :     sparc.sml
618 :     defs: SparcBackend
619 :     x86-ccall.sml
620 :     defs: X86CCallBackend
621 :     x86-stdcall.sml
622 :     defs: X86StdCallBackend
623 :    
624 :     interact/
625 :     envref.sml
626 :     supports top-level environment management
627 :     defs: ENVREF, EnvRef : ENVREF
628 :     evalloop.sig,sml
629 :     top-level read-eval-print loop
630 :     defs: EVALLOOP, EvalLoopF: TOP_COMPILE => EVALLOOP
631 :     interact.sig,sml
632 :     creating top-level loops
633 :     defs: INTERACT, Interact: EVALLOOP => INTERACT
634 :    
635 :     main/
636 :     control.sig
637 :     defs: MCCONTROL, FLINTCONTROL, CGCONTROL, CONTROL
638 :     control.sml
639 :     defs: Control_MC, Control_CG, Control
640 :     version.sml
641 : macqueen 1481 records the compiler version and version date
642 : macqueen 1473 defs: CompilerVersion
643 :     printhooks.sml
644 :     defs: PrintHooks
645 :     pptable.sml
646 :     defs: CompilerPPTable
647 :     code-generator.sig
648 :     defs: CODEGENERATOR
649 :     compile.sig
650 : macqueen 1481 defs: COMPILE0, COMPILE, TOP_COMPILE
651 : macqueen 1473 compile.sml
652 :     defs: CompileF: CODEGENERATOR # CCONFIG # {cproto_conv : string} => COMPILE0
653 :    
654 :    
655 :    
656 :     ============================================================================
657 :    
658 :     Catalog of basic structures (Front End)
659 :     ---------------------------------------
660 :    
661 : macqueen 1344 symbols
662 : macqueen 1473 Symbol (Basics/mlcomp/symbol.sig,sml)
663 :     FastSymbol (Basics/mlcomp/fastsymbol.sig,sml)
664 : macqueen 1344
665 : macqueen 1473 symbolic paths
666 :     SymPath (ElabData/basics/sympaths.sml)
667 :     InvPath (ElabData/basics/sympaths.sml)
668 :     ConvertPaths (ElabData/basics/sympaths.sml)
669 : macqueen 1344
670 :     ast (syntax trees)
671 : macqueen 1473 Ast (Parse/ast/ast.sig,sml)
672 :     AstUtil (Parse/ast/astutil.sig,sml)
673 : macqueen 1344
674 :     absyn (abstract syntax)
675 : macqueen 1473 Absyn (ElabData/syntax/absyn.sig,sml)
676 :     abstract syntax datatypes for expressions, declarations, etc.
677 :     VarCon (ElabData/syntax/varcon.sig,sml)
678 :     variables and constructors
679 :     AbsynUtil (ElabData/syntax/absynutil.sml)
680 :     utility module for working with absyn
681 :     PPAbsyn (Elaborator/print/ppabsyn.sml)
682 :     prettyprinting absyn
683 : macqueen 1344
684 : macqueen 1473 types (internal representation of types)
685 :     representations
686 :     Types (ElabData/types/types.sig,sml)
687 :     ConRep (Elaborator/basics/conrep.sml)
688 : macqueen 1344
689 : macqueen 1473 utilities, manipulating and comparing types
690 :     TypesUtil (ElabData/types/typesutil.sig,sml)
691 :     Tuples (ElabData/types/tuples.sml)
692 :     EqTypes (Elaborator/types/eqtypes.sml)
693 :     Unify (Elaborator/types/unify.sml)
694 : macqueen 1344
695 : macqueen 1473 primitive types
696 :     CorePrimTycNum (ElabData/basics/core-ptnum.sml)
697 :     PrimTycNum (Elaborator/basics/ptnum.sml)
698 :     CoreBasicTypes (ElabData/types/core-basictypes.sml)
699 :     BasicTypes (Elaborator/types/basictypes.sig,sml)
700 :     PrimEnv (Semant/statenv/prim.sml)
701 :    
702 :     printing types
703 :     PPType (Elaborator/print/pptype.sml)
704 :    
705 :     dynamic access info
706 :     LambdaVar (ElabData/basics/lambdavar.sig,sml)
707 :     lambda variables (dynamic access roots for variables)
708 :     Access (ElabData/basics/access.sml)
709 :     dynamic access modes
710 :    
711 : macqueen 1344 environment (generic environment: 'b env)
712 : macqueen 1473 Env (ElabData/basics/env.sml)
713 : macqueen 1344
714 :     static environment
715 : macqueen 1473 Bindings (ElabData/statenv/bindings.sig,sml)
716 :     StaticEnv (ElabData/statenv/statenv.sml)
717 :     Lookup (ElabData/statenv/lookup.sml)
718 :     BrowseStatEnv (ElabData/statenv/browse.sml)
719 : macqueen 1344
720 :     modules (signatures, structures, functors)
721 : macqueen 1473 Modules (ElabData/modules/modules.sig,sml)
722 :     ModuleUtil (ElabData/modules/moduleutil.sig,sml)
723 :     ModuleId (ElabData/modules/moduleid.sml)
724 :     EntPath (ElabData/modules/entpath.sml)
725 :     EntityEnv (ElabData/modules/entityenv.sml)
726 :     ModulePropLists (Semant/modules/module-plists.sml) [FLINT]
727 : macqueen 1344
728 : macqueen 1473 primop
729 :     PrimOp (FLINT/kernel/primop.sml)
730 : dbm 2603 PrimOpMap (FLINT/trans/primopmap.sml)
731 :     PrimOpId (ElabData/basics/primopid.sml)
732 :     PrimOpTypeMap (Semant/statenv/primoptypemap.sml)
733 : macqueen 1473 PrimEnv (Semant/statenv/prim.sml)
734 : macqueen 1344
735 :     control
736 : macqueen 1473 BasicControl (Basics/main/basiccontrol.sml)
737 :     ParserControl (Parse/main/parsercontrol.sml)
738 :     ElabDataControl (ElabData/main/edcontrol.sml)
739 :     ElabControl (Elaborator/basics/elabcontrol.sml)
740 :     Control_Print (Basics/print/printcontrol.sml)
741 :    
742 :     Control (TopLevel/main/control.sml)
743 :     Control_CG (TopLevel/main/control.sml)
744 :     Control_MC (TopLevel/main/control.sml)
745 :    
746 :    
747 :     ==========================================================================
748 :    
749 :     Notes
750 :     =====
751 :    
752 :     1. CoreBasicTypes/BasicTypes and CorePrimTycNum/PrimTycNum splits are
753 :     part of an attempt to have a subset of the front end modules that
754 :     can be used as a generic, implementation dependent SML front-end. That
755 :     is, CoreBasicTypes defines only those types that must be provided in
756 :     any SML implementation. BasicTypes adds those types that are specific
757 :     to SML/NJ.
758 :    
759 :    
760 :     2. What is the distinction between Basics and Semant? Should these be
761 :     merged? How about ElabData? Some of these files (Semant/types) might
762 :     also fit there.
763 :    
764 :     We have Basics/*, Semant/basics, ElabData/basics, and Elaborator/basics.
765 :     What is the rationale telling us what goes in each of these places?
766 :    
767 :     This complex organization seems to be partially motivated by the goal
768 :     of separating out any features that are SML/NJ-specific from the generic
769 :     SML stuff.

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0