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 1481 - (view) (download)
Original Path: sml/trunk/src/compiler/MAP

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 : macqueen 1473 Semant/basics/
147 :     inlinfo.sig/sml
148 :     inlining info [FLINT]
149 :     defs: INL_INFO, InlInfo: INL_INFO
150 : macqueen 1344
151 : macqueen 1473 Semant/elaborate/
152 :     apply functors defined in corresponding Elaborate/elaborate modules
153 :     [these could be in Elaborator]
154 :     elabmod.sml
155 : macqueen 1481 module level elaboration: defines ElabMod by calling ElabModFn defined
156 :     in Elaborate/elaborate/elabmod.sml (should go to Elaborator)
157 : macqueen 1473 see: Elaborator/elaborate/elabmod.sml
158 :     defs: ElabMod
159 :     elabtop.sml
160 : macqueen 1481 top-level elaboration: defined ElabTop by calling ElabTopFn defined
161 :     in Elaborator/elaborate/elabtop.sml (should go to Elaborator)
162 :     see: Elaborator/elaborate/elabtop.sml
163 : macqueen 1473 defs: ElabTop
164 : macqueen 1344
165 : macqueen 1473 Semant/modules/
166 :     support for module elaboration
167 :     evalent.sml
168 :     entity expression evaluation;
169 :     applies functor EvalEntityFn from Elaborator/modules/evalent.sml
170 :     see: Elaborator/modules/evalent.sml
171 :     defs: EvalEntity
172 :     instantiate.sml
173 :     apply InstantitateFn defined in Elaborator/modules/instantiate.sml
174 :     see: Elaborator/modules/instantiate.sml
175 :     defs: Instantiate
176 :     instantiate-param.sml
177 :     defines parameter passed to InstantiateFn in ./instantiate.sml
178 :     see: Semant/modules/instantiate.sml (previous file)
179 :     defs: InstantiateParam
180 :     module-plists.sml [FLINT]
181 :     defines PropList properties for attaching FLINT Lambda types to
182 :     various semantic entities
183 :     see: smlnj-lib/Util/plist{-sig}.sml
184 :     defs: ModulePropLists
185 :     sigmatch.sml
186 :     apply SigmatchFn defined in Elaborator/modules/sigmatch.sml
187 :     see: Elaborator/modules/sigmatch.sml
188 :     defs: SigMatch
189 : macqueen 1344
190 : macqueen 1473 Semant/pickle/
191 :     pickling static environments
192 :     pickle-sym-pid.sml
193 :     unpickle-sym-pid.sml
194 :     pickmod-new.sml
195 :     unpickmod-new-sml
196 :     rehash.sml
197 : macqueen 1344
198 : macqueen 1473 Semant/statenv/
199 :     prim.sml
200 :     define static env primEnv, containing primitive types (PrimTypes),
201 :     primops (InLine), and unrolled lists (UnrolledList)
202 :     defs: PRIM_ENV, PrimEnv: PRIM_ENV
203 : macqueen 1344
204 : macqueen 1473 Semant/types/
205 :     some types-related stuff
206 :     cproto.sml
207 :     relating ML types and C types (CTypes.c_proto from MLRISC) for C call mechanism
208 :     defs: CProto
209 :     tp-var-info.sml [FLINT]
210 :     packaging some FLINT info as an exception
211 :     defs: TVI
212 :     types-reformat.sml [FLINT]
213 :     FLINT-related "reformatting" of types, used to be in typesutil.sml
214 :     defs: TypesReformat
215 :     typecheck.sml [FLINT]
216 :     apply TypecheckFn defined in Elaborator/types/typecheck.sml (should eliminate)
217 :     see: Elaborator/types/typecheck.sml
218 :     defs: TypeCheck
219 : macqueen 1344
220 :    
221 : macqueen 1473 ElabData/
222 :     Basic datastructures used in elaboration (including type checking)
223 : macqueen 1344
224 : macqueen 1473 ElabData/basics/
225 :     basic representation types used in elaboration, plus coresym
226 :     lambdavar.sig/sml
227 :     lambda variables, the abstract representation of variables, used
228 :     as roots of dynamic access chains
229 :     defs: LAMBDA_VAR, LambdaVar
230 :     access.sig/sml
231 :     dynamic access paths
232 :     defs: ACCESS, Access : ACCESS
233 :     env.sig/sml
234 :     generic environments, mapping symbols to unspecified binding type
235 :     defs: ENV, Env: ENV, INTSTRMAPV
236 :     stamps.sig/sml
237 :     static identifiers, used for nominal type equivalence
238 :     defs: STAMPS, Stamps:> STAMPS
239 :     stampmap.sml
240 :     generic finite mappings over stamps
241 :     defs: StampMap
242 :     sympaths.sig/sml
243 :     SymPath and InvPath: direct and inverse symbolic paths (selecting
244 :     module components)
245 :     defs: SYMPATH, INVPATH, CONVERTPATHS, SymPath, InvPath, ConvertPaths
246 :     ii.sml [FLINT]
247 :     FLINT related information for inlining (why is this in elaborator?)
248 :     defs: II
249 :     core-ptnum.sml
250 :     core prim-type numbers (essentially the same as Elaborator/basics/ptnum.sml
251 :     except only language-standard types are included)
252 :     see: Elaborator/basics/ptnum.sml
253 :     defs: CORE_PRIM_TYC_NUM, CorePrimTycNum
254 :     coresym.sml
255 :     defines the special structure symbol "_Core" used to access certain
256 :     special bindings (e.g Match and Bind exceptions)
257 :     defs: CoreSym
258 : macqueen 1344
259 : macqueen 1473 ElabData/syntax/
260 :     (typed) abstract syntax
261 :     absyn.sig/sml
262 :     the abstract syntax types
263 :     defs: ABSYN, Absyn: ABSYN
264 :     varcon.sig/sml
265 :     variable and data constructor representations
266 :     defs: VARCON, VarCon: VARCON
267 :     absynutil.sml
268 :     utility functions for building tuple patterns and expressions
269 :     defs: AbsynUtil
270 : macqueen 1344
271 : macqueen 1473 ElabData/types/
272 :     representing, constructing and manipulating types
273 :     types.sig/sml
274 :     the representation of SML types
275 :     defs: TYPES, Types: TYPES
276 :     typesutil.sig/sml
277 :     large collection of utility functions for working with types
278 :     defs: TYPESUTIL, TypesUtil: TYPESUTIL
279 :     tuples.sml
280 :     fns for constructing tuple and record types
281 :     defs: TUPLES, Tuples: TUPLES
282 :     core-basictypes.sml
283 :     building the primitive types and associated values (containing only
284 :     implementation independent, language-standard basic types?)
285 :     see: Elaborator/types/basictypes.sml
286 :     defs: CoreBasicTypes
287 : macqueen 1344
288 : macqueen 1473 ElabData/statenv/
289 :     static environments
290 :     bindings.sig/sml
291 :     the basic binding forms (values, types, signatures, etc.)
292 :     defs: BINDINGS, Bindings: BINDINGS
293 :     statenv.sig/sml
294 :     instantiate generic environments with ML bindings
295 :     defs: STATICENV, StaticEnv: STATICENV
296 :     lookup.sig/sml
297 :     accessing symbols in environments
298 :     defs: LOOKUP, Lookup : LOOKUP
299 :     genmap.sml
300 :     rapid modmap generation based on modtrees
301 :     defs: GenModIdMap
302 :     coreacc.sml
303 :     access components of the _Core structure
304 :     defs: CoreAccess
305 :     browse.sml
306 :     "browsing" the static environment (not used???)
307 :     defs: BrowseStatEnv
308 : macqueen 1344
309 : macqueen 1473 ElabData/modules/
310 :     representation of modules
311 :     modules.sig/sml
312 :     representation of modules and signatures
313 :     defs: MODULES, Modules: MODULES
314 :     moduleutil.sig/sml
315 :     lots of utility functions for modules
316 :     defs: MODULEUTIL, ModuleUtil: MODULEUTIL
317 :     moduleid.sml
318 :     module identities used in Modmaps ???
319 :     defs: MODULE_ID, ModuleId: MODULE_ID
320 :     entpath.sml
321 :     access paths for navigating entities
322 :     defs: ENT_PATH, EntPath:> ENT_PATH
323 :     entityenv.sig/sml
324 :     enity environments mapping entity variables
325 :     defs: ENTITY_ENV, EntityEnv : ENTITY_ENV
326 :     epcontext.sml
327 :     hairy context info used during module elaboration,
328 :     related to nesting of modules (ep stands for
329 :     "entity path"?)
330 :     defs: ENT_PATH_CONTEXT, EntPathContext :> ENT_PATH_CONTEXT
331 : macqueen 1344
332 : macqueen 1473 ElabData/main/
333 :     compinfo.sml
334 :     elaboration context parameter
335 :     defs: CompInfo
336 :     edcontrol.sig/sml
337 :     control flags for ElabData
338 :     defs: ELABDATA_CONTROL, ElabDataControl : ELABDATA_CONTROL
339 : macqueen 1344
340 :    
341 : macqueen 1473 Elaborator/
342 :     The main elaborator code, plus some representation stuff in basics/,
343 :     plus printing modules in print/.
344 : macqueen 1344
345 : macqueen 1473 Elaborator/basics/
346 :     some control flags, some representation types, some FLINT stuff
347 :     elabcontrol.sml
348 :     Elaborator control flags
349 :     defs: ElabControl
350 :     conrep.sml
351 :     inferring conreps for data constructors
352 :     defs: CONREP, ConRep: CONREP
353 :     debindex.sig/sml [FLINT]
354 :     FLINT book-keeping (move back to FLINT)
355 :     defs: DEB_INDEX, DebIndex : DEB_INDEX
356 :     ptnum.sml
357 :     prim type numbers, augmenting ElabData/basics/core-ptnum.sml with
358 :     implementation dependent types
359 :     see: ElabData/basics/core-ptnum.sml
360 :     defs: PRIM_TYC_NUM, PrimTycNum: PRIM_TYC_NUM
361 : macqueen 1344
362 : macqueen 1473 Elaborator/print/ [should be in ElabData?]
363 :     print utilities and print modules for elaboration data structures
364 :     pputil.sig/sml
365 :     prettyprint utilities (generic) [**MOVE**]
366 :     pptype.sml
367 :     prettyprint types
368 :     ppval.sml
369 :     prettyprint variables and dcons
370 :     ppmod.sml
371 :     prettyprint modules and signatures
372 :     ppabsyn.sml
373 :     prettyprint absyn (uses PPUtil(pputil.s??),
374 :     PPVal(ppval.sml), PPType(pptype.sml))
375 : macqueen 1344
376 : macqueen 1473 Elaborator/types/
377 :     building basic types + typechecking modules
378 :     basictypes.sig/sml
379 :     define basic (built-in) types; most are just defined in terms of
380 :     types from CoreBasicTypes [MOVE to ElabData?]
381 :     see: ElabData/types/core-basictypes.sml
382 :     defs: BasicTypes
383 :     eqtypes.sml
384 :     equivalence of types
385 :     defs: EQTYPES, EqTypes: EQTYPES
386 :     unify.sml
387 :     type unification
388 :     defs: UNIFY, Unify: UNIFY
389 :     overloadlit.sml
390 :     overloaded numeric literals
391 :     defs: OVERLOADLIT, OverloadLit: OVERLOADLIT
392 :     overload.sml
393 :     overloading resolution
394 :     defs: OVERLOAD, Overload
395 :     typecheck.sml [FLINT]
396 :     defines typechecking _functor_ TypecheckFn, taking some FLINT-related
397 :     inlining info as parameters [should make into a structure]
398 :     defs: TYPECHECK, TypecheckFn: _ => TYPECHECK
399 : macqueen 1344
400 : macqueen 1473 Elaborator/modules/
401 :     support modules for elaborating modules
402 :     evalent.sml
403 :     evaluate "entities" (module and type realizations). Defines EvalEntityFn
404 :     which is called to define EvalEntity structure in Semant/modules/evalent.sml
405 :     see: Semant/modules/evalent.sml
406 :     defs: EVALENTITY, EvalEntityFn : INSTANTIATE => EVALENTITY
407 :     expandtycon.sml
408 :     interpret PATHtycs in entity environments
409 :     defs: EXPAND_TYCON, ExpandTycon : EXPAND_TYCON
410 :     instantiate.sml
411 :     free instantiation of signatures. defines InstantiateFn which is applied
412 :     to define structure Instantiate in Semant/modules/instantiate.sml
413 :     see: Semant/modules/instantiate.sml
414 :     defs: INSTANTIATE_PARAM, INSTANTIATE,
415 :     InstantiateFn: INSTANTIATE_PARAM => INSTANTIATE
416 :     sigmatch.sml
417 :     signature matching. defines SigMatchFn, which is applied to define
418 :     SigMatch structure in Semant/modules/sigmatch.sml
419 :     see: Semant/modules/sigmatch.sml
420 :     defs: SIGMATCH, SigMatchFn: EVALENTITY => SIGMATCH
421 : macqueen 1344
422 : macqueen 1473 Elaborator/elaborate/
423 :     main elaboration modules, plus some supporting modules
424 :     tyvarset.sml
425 :     type var sets for keeping track of implicit scopes of user type vars
426 :     defs: TYVARSET, TyvarSet :> TYVARSET
427 :     specialsyms.sml
428 :     definition of special symbols for internal use
429 :     defs: SpecialSymbols
430 :     elabutil.sig/sml
431 :     general utilities for elaboration
432 :     defs: ELABUTIL, ElabUtil : ELABUTIL
433 :     elabdebug.sml
434 :     debugging facilities for elaboration
435 :     defs: ELABDEBUG, ElabDebug : ELABDEBUG
436 :     precedence.sml
437 :     precedence parser for core expressions, dealing with infix operators
438 :     defs: PRECEDENCE, Precedence : PRECEDENCE
439 :     elabtype.sig/sml
440 :     elaboration of type expressions and declarations
441 :     defs: ELABTYPE, ElabType : ELABTYPE
442 :     elabcore.sml
443 :     elaborating core ML (expressions, declarations)
444 :     defs: ELABCORE, ElabCore: ELABCORE
445 :     elabmod.sml
446 :     main module elaboration. defines ElabModFn, which is called to
447 :     define ElabMod structure in Semant/elaborate/elabmod.sml
448 :     see: Semant/elaborate/elabmod.sml
449 :     defs: ELABMOD, ElabModFn: SIGMATCH # TYPECHECK => ELABMOD
450 :     include.sml
451 :     elaborate include specs in signatures (supports elabsig)
452 :     defs: INCLUDE, Include: INCLUDE
453 :     elabsig.sml
454 :     elaborate signatures
455 :     defs: ELABSIG, ElabSig : ELABSIG
456 :     elabtop.sml
457 :     top-level elaboration driver. defines ElabTopFn, which is called
458 :     to define ElabTop structure in Semant/elaborate/elabtop.sml
459 :     see: Semant/elaborate/elabtop.sml
460 :     defs: ELABTOP, ElabTopFn : ELABMOD => ELABTOP
461 : macqueen 1344
462 :    
463 :     3. Miscellaneous utilities
464 :    
465 :     MiscUtil/
466 :     Contains various kinds of utility programs
467 :    
468 :     bignums/
469 : macqueen 1473 supporting real constants (using bignums?)
470 :     ieeereal.sml
471 :     Support for IEEE floating-point constants. calls RealConst functor
472 :     see: MiscUtil/bignums/realconst.sml
473 :     defs: IEEERealConst
474 :     realconst.sml
475 :     generate ML real (i.e. ieee floating point?) constants
476 :     defs: PRIMREAL, REALCONST, RealConst: PRIMREAL => REALCONST
477 : macqueen 1344
478 :     library/
479 : macqueen 1473 Utility modules that are candidates for eventual
480 :     promotion to general libraries (crc and pickling)
481 :     crc.sml
482 :     crc codes
483 :     defs: CRC, CRC :> CRC
484 :     pickle-lib.cm
485 :     CM description for basic pickling/unpickling library
486 :     pickle-util.sml
487 :     supporting pickling
488 :     defs: PICKLE_UTIL, PickleUtil :> PICKLE_UTIL
489 :     unpickle-util.sml
490 :     supporting unpickling
491 :     defs: UNPICKLE_UTIL, UnpickleUtil :> UNPICKLE_UTIL
492 : macqueen 1344
493 :     print/
494 : macqueen 1473 Pretty printing for absyn declarations, values
495 :     ppdec.sml
496 :     printing results of top-level declarations, including values and types
497 :     defs: PPDEC, PPDec : PPDEC
498 :     ppobj.sml
499 :     print top-level values
500 :     defs: PPOBJ, PPObj : PPOBJ
501 :     pptable.sml
502 :     register for user-defined prettyprinters for datatypes
503 :     defs: PPTABLE, PPTable : PPTABLE
504 : macqueen 1344
505 :     util/
506 : macqueen 1473 A couple of miscellaneous leftovers.
507 :     feedback.sml
508 :     Compute minimum feedback vertex set of a given directed graph.
509 :     should be part of a graph library (move to ../library?)
510 :     defs: Feedback
511 :     literal-to-num.sml
512 :     Conversions from integer/word literals (which are represented as
513 :     arbitrary precision ints) to fixed size. a hack that should be
514 :     replaced by a parameterized numeric types.
515 :     size numbers
516 :     defs: LITERAL_TO_NUM, LiteralToNum : LITERAL_TO_NUM
517 : macqueen 1344
518 :    
519 : macqueen 1473 3. Middle End
520 :     -------------
521 : macqueen 1344
522 : macqueen 1473 FLINT/
523 :     intermediate representation (a form of typed lambda calculus)
524 : macqueen 1344
525 : macqueen 1473 [see FLINT/MAP]
526 : macqueen 1344
527 :    
528 : macqueen 1473 4. Back End
529 :     -----------
530 : macqueen 1344
531 : macqueen 1473 MLRISC/
532 :     MLRISC based code generators
533 : macqueen 1344
534 :    
535 : macqueen 1473 5. Execution Model
536 :     -----------------
537 : macqueen 1344
538 : macqueen 1473 Execution/
539 : macqueen 1344
540 : macqueen 1473 dynenv/
541 :     dynenv.sig,sml
542 :     dynamic environments, and instance of PidEnvFn
543 :     see: Basics/mlcomp/pidenv.sml
544 :     defs: DYNAMICENV, DynamicEnv : DYNAMICENV
545 :     codeobj/
546 :     code-obj.sig,sml
547 :     an interface for manipulating code objects
548 :     defs: CODE_OBJ, CodeObj :> CODE_OBJ
549 :     binfile/
550 :     binfile.sig,sml
551 :     file format for bin files (machine-independent)
552 :     defs: BINFILE, Binfile :> BINFILE
553 :     main/
554 :     importtree.sml
555 :     defs: ImportTree
556 :     isolate.sml
557 :     isolate the continuation context to the top-level (a prompt?)
558 :     defs: Isolate
559 :     execute.sml
560 :     execution of top-level executables in a dynamic environment
561 :     defs: Execute
562 : macqueen 1344
563 :    
564 : macqueen 1473 6. Interactive Top Level
565 :     ------------------------
566 : macqueen 1344
567 : macqueen 1473 TopLevel/
568 :    
569 :     environ/
570 :     combined static and dynamic environments
571 :     environ.sig,sml
572 :     defs: ENVIRONMENT, Environment: ENVIRONMENT
573 :     symenv.sig,sml
574 :     defines SYMENV as a specialization of PIDENV, and SymbolicEnv as
575 :     an instance of PidEnvFn.
576 :     see: Basics/mlcomp/pidenv.sig, Basics/mlcomp/pidenv.sml
577 :     defs: SYMENV, SymbolicEnv: SYMENV
578 :    
579 :     backend/
580 :     backend.sig
581 :     defs: BACKEND
582 :     backend-fn.sml
583 :     defs: BackendFn : CODEGENERATOR # {val cproto_conv : string} => BACKEND
584 :     alpha32.sml
585 :     defs: Alpha32Backend
586 :     hppa.sml
587 :     defs: HppaBackend
588 :     ppc.sml
589 :     defs: PPCBackend
590 :     sparc.sml
591 :     defs: SparcBackend
592 :     x86-ccall.sml
593 :     defs: X86CCallBackend
594 :     x86-stdcall.sml
595 :     defs: X86StdCallBackend
596 :    
597 :     interact/
598 :     envref.sml
599 :     supports top-level environment management
600 :     defs: ENVREF, EnvRef : ENVREF
601 :     evalloop.sig,sml
602 :     top-level read-eval-print loop
603 :     defs: EVALLOOP, EvalLoopF: TOP_COMPILE => EVALLOOP
604 :     interact.sig,sml
605 :     creating top-level loops
606 :     defs: INTERACT, Interact: EVALLOOP => INTERACT
607 :    
608 :     main/
609 :     control.sig
610 :     defs: MCCONTROL, FLINTCONTROL, CGCONTROL, CONTROL
611 :     control.sml
612 :     defs: Control_MC, Control_CG, Control
613 :     version.sml
614 : macqueen 1481 records the compiler version and version date
615 : macqueen 1473 defs: CompilerVersion
616 :     printhooks.sml
617 :     defs: PrintHooks
618 :     pptable.sml
619 :     defs: CompilerPPTable
620 :     code-generator.sig
621 :     defs: CODEGENERATOR
622 :     compile.sig
623 : macqueen 1481 defs: COMPILE0, COMPILE, TOP_COMPILE
624 : macqueen 1473 compile.sml
625 :     defs: CompileF: CODEGENERATOR # CCONFIG # {cproto_conv : string} => COMPILE0
626 :    
627 :    
628 :    
629 :     ============================================================================
630 :    
631 :     Catalog of basic structures (Front End)
632 :     ---------------------------------------
633 :    
634 : macqueen 1344 symbols
635 : macqueen 1473 Symbol (Basics/mlcomp/symbol.sig,sml)
636 :     FastSymbol (Basics/mlcomp/fastsymbol.sig,sml)
637 : macqueen 1344
638 : macqueen 1473 symbolic paths
639 :     SymPath (ElabData/basics/sympaths.sml)
640 :     InvPath (ElabData/basics/sympaths.sml)
641 :     ConvertPaths (ElabData/basics/sympaths.sml)
642 : macqueen 1344
643 :     ast (syntax trees)
644 : macqueen 1473 Ast (Parse/ast/ast.sig,sml)
645 :     AstUtil (Parse/ast/astutil.sig,sml)
646 : macqueen 1344
647 :     absyn (abstract syntax)
648 : macqueen 1473 Absyn (ElabData/syntax/absyn.sig,sml)
649 :     abstract syntax datatypes for expressions, declarations, etc.
650 :     VarCon (ElabData/syntax/varcon.sig,sml)
651 :     variables and constructors
652 :     AbsynUtil (ElabData/syntax/absynutil.sml)
653 :     utility module for working with absyn
654 :     PPAbsyn (Elaborator/print/ppabsyn.sml)
655 :     prettyprinting absyn
656 : macqueen 1344
657 : macqueen 1473 types (internal representation of types)
658 :     representations
659 :     Types (ElabData/types/types.sig,sml)
660 :     ConRep (Elaborator/basics/conrep.sml)
661 : macqueen 1344
662 : macqueen 1473 utilities, manipulating and comparing types
663 :     TypesUtil (ElabData/types/typesutil.sig,sml)
664 :     Tuples (ElabData/types/tuples.sml)
665 :     EqTypes (Elaborator/types/eqtypes.sml)
666 :     Unify (Elaborator/types/unify.sml)
667 : macqueen 1344
668 : macqueen 1473 primitive types
669 :     CorePrimTycNum (ElabData/basics/core-ptnum.sml)
670 :     PrimTycNum (Elaborator/basics/ptnum.sml)
671 :     CoreBasicTypes (ElabData/types/core-basictypes.sml)
672 :     BasicTypes (Elaborator/types/basictypes.sig,sml)
673 :     PrimEnv (Semant/statenv/prim.sml)
674 :    
675 :     printing types
676 :     PPType (Elaborator/print/pptype.sml)
677 :    
678 :     dynamic access info
679 :     LambdaVar (ElabData/basics/lambdavar.sig,sml)
680 :     lambda variables (dynamic access roots for variables)
681 :     Access (ElabData/basics/access.sml)
682 :     dynamic access modes
683 :    
684 : macqueen 1344 environment (generic environment: 'b env)
685 : macqueen 1473 Env (ElabData/basics/env.sml)
686 : macqueen 1344
687 :     static environment
688 : macqueen 1473 Bindings (ElabData/statenv/bindings.sig,sml)
689 :     StaticEnv (ElabData/statenv/statenv.sml)
690 :     Lookup (ElabData/statenv/lookup.sml)
691 :     BrowseStatEnv (ElabData/statenv/browse.sml)
692 : macqueen 1344
693 :     modules (signatures, structures, functors)
694 : macqueen 1473 Modules (ElabData/modules/modules.sig,sml)
695 :     ModuleUtil (ElabData/modules/moduleutil.sig,sml)
696 :     ModuleId (ElabData/modules/moduleid.sml)
697 :     EntPath (ElabData/modules/entpath.sml)
698 :     EntityEnv (ElabData/modules/entityenv.sml)
699 :     ModulePropLists (Semant/modules/module-plists.sml) [FLINT]
700 : macqueen 1344
701 : macqueen 1473 primop
702 :     PrimOp (FLINT/kernel/primop.sml)
703 :     PrimEnv (Semant/statenv/prim.sml)
704 : macqueen 1344
705 :     control
706 : macqueen 1473 BasicControl (Basics/main/basiccontrol.sml)
707 :     ParserControl (Parse/main/parsercontrol.sml)
708 :     ElabDataControl (ElabData/main/edcontrol.sml)
709 :     ElabControl (Elaborator/basics/elabcontrol.sml)
710 :     Control_Print (Basics/print/printcontrol.sml)
711 :    
712 :     Control (TopLevel/main/control.sml)
713 :     Control_CG (TopLevel/main/control.sml)
714 :     Control_MC (TopLevel/main/control.sml)
715 :    
716 :    
717 :     ==========================================================================
718 :    
719 :     Notes
720 :     =====
721 :    
722 :     1. CoreBasicTypes/BasicTypes and CorePrimTycNum/PrimTycNum splits are
723 :     part of an attempt to have a subset of the front end modules that
724 :     can be used as a generic, implementation dependent SML front-end. That
725 :     is, CoreBasicTypes defines only those types that must be provided in
726 :     any SML implementation. BasicTypes adds those types that are specific
727 :     to SML/NJ.
728 :    
729 :    
730 :     2. What is the distinction between Basics and Semant? Should these be
731 :     merged? How about ElabData? Some of these files (Semant/types) might
732 :     also fit there.
733 :    
734 :     We have Basics/*, Semant/basics, ElabData/basics, and Elaborator/basics.
735 :     What is the rationale telling us what goes in each of these places?
736 :    
737 :     This complex organization seems to be partially motivated by the goal
738 :     of separating out any features that are SML/NJ-specific from the generic
739 :     SML stuff.

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