MLCompiler/ParseTree/CODEGEN_PARSETREE.sml

111     (* Try this pipeline function *)
230                     (* If it is referred to by a referenced function it is referenced. *)
273        function entry and exit. *)
277     (* Create an entry in the static environment for the function. *)
341            function calls.  *)
345             This is used to decide whether to use a function for certain
370             let (* Put in a call to the expression as a function. *)
428                 val functionLevel = newLevel level (* For the function. *)
494                function not afterwards. *)
520     |   codeGenerate(Applic {f = Ident {value = ref function, expType=ref expType, ...}, arg, location, ...}, context as { level, typeVarMap, lex, ...}) =
524             val polyVars = getPolymorphism (function, expType, typeVarMap)
526             val code = applyFunction (function, argCode, level, typeVarMap, polyVars, lex, location)
612                 val code =(* Make an inline function. *)
677                                or a function call.  We want to pass that along. *)
787     (* Old codegen function which discards the debug context. *)
801         (* This function comprises a new declaration level *)
825                Currently, we don't apply this optimisation if the function is
975                            copy of it. It contains a function to print values
1119     (* Code generate a set of fun bindings.  This is used for other function creation as
1124             (* Get the function variables. *)
1135             (* Each function may result in either one or two functions
1136                actually being generated. If a function is not curried
1137                it will generate a single function of one argument, but
1139                generate two mutually recursive functions. A function
1142                with the second function (f) being inline. This allows
1160             (* Get the polymorphic variables for each function. *)
1168             (* Now we can process the function bindings. *)
1174                     (* Make up the function, and if there are several mutually
1213                         (* If we're debugging we want the result of the function so we don't do this optimisation. *)
1215                            That works for local functions but doesn't work if the function is exported e.g.
1253                     (* We arrange for the inner function to be called with
1270                    Just to add to this, if the function is polymorphic we
1292                         (* This function comprises a new declaration level *)
1347                            for this function.  If another function uses different variables it
1350                            of this function.
1354                            function with more polymorphism. *)
1373                                         (* Set the address to this so if we use this function we pick
1389                             (* Function body.  The debug state has a "start of function" entry that
1392                                break within the function. *)
1404                                    an extra argument to the inline function and setting this to
1409                                     (* The function sets the extra argument to the result
1410                                        of the body of the function.  We use the last
1415                                        pushed onto the stack within the function than an
1435                     (* We now have a function which can be applied to the
1436                        arguments once we have them. If the function is curried
1448                             (* Load a reference to the inner function. *)
1459                                     it in the function, then create a tuple from it.
1473                         let (* Make a function. *)
1498                           the inner function first to see if the optimiser
1594                    We build the code as a function and then apply it one or more times.
1648                         (* Construct a function that, when applied, returns all the variables. *)
1657                         (* Apply the general function to the set of type variables using either the
1672                         (* For each variable construct either a new function if it is polymorphic
1702                         (* Return the declaration of the function, a dummy application that will