Exemple #1
0
 //This step compiles instances - this should be done after types (as soon as instances
 //reference types) and after the first step as well (as soon as instances reference type classes
 //and can reference any other local and non-local names). It is important however to compile
 //instances before any user typeId gets executed because they effectively mutate function tables.
 private void ProcessInstances(ElaProgram prog, LabelMap map)
 {
     if (prog.Instances != null)
     {
         CompileInstances(prog.Instances, map);
     }
 }
Exemple #2
0
        public CompilerResult Compile(ElaProgram prog, CompilerOptions options, ExportVars builtins, CodeFrame frame, Scope globalScope)
        {
            Options = options;
            var helper = new Builder(frame, this, builtins, globalScope);

            try
            {
                helper.CompileUnit(prog);
            }
            catch (TerminationException)
            {
                //Nothing should be done here. This was thrown to stop compilation.
            }
#if !DEBUG
            catch (Exception ex)
            {
                if (ex is ElaCompilerException)
                {
                    throw;
                }

                throw new ElaCompilerException(Strings.GetMessage("Ice", ex.Message), ex);
            }
#endif

            frame.Symbols = frame.Symbols == null ? helper.Symbols :
                            helper.Symbols != null?frame.Symbols.Merge(helper.Symbols) : frame.Symbols;

            frame.GlobalScope = globalScope;
            return(new CompilerResult(frame, helper.Success, helper.Errors.ToArray()));
        }
Exemple #3
0
 public HtmGenerator(ElaProgram prog, Doc doc, ElaIncrementalLinker lnk, ElaMachine vm)
 {
     this.prog = prog;
     this.doc  = doc;
     this.vm   = vm;
     this.lnk  = lnk;
 }
Exemple #4
0
        //An entry method for includes compilation
        private void CompileModuleIncludes(ElaProgram prog, LabelMap map)
        {
            var inc = prog.Includes;

            for (var i = 0; i < inc.Count; i++)
            {
                CompileModuleInclude(inc[i], map);
            }
        }
Exemple #5
0
        //Main compilation method that runs compilation in seven steps by rewriting binding order.
        private void CompileProgram(ElaProgram prog, LabelMap map)
        {
            ProcessIncludesClassesTypes(prog, map);
            var list = RunForwardDeclaration(prog.TopLevel.Equations, map);

            list = ProcessFunctions(list, map);
            ProcessInstances(prog, map);
            list = ProcessBindings(list, map);
            ProcessExpressions(list, map);
        }
Exemple #6
0
        //Type class declarations, modules includes and type declarations can be compiled in the first place.
        private void ProcessIncludesClassesTypes(ElaProgram prog, LabelMap map)
        {
            CompileModuleIncludes(prog, map);

            if (prog.Classes != null)
            {
                CompileClass(prog.Classes, map);
            }

            if (prog.Types != null)
            {
                CompileTypes(prog.Types, map);
            }
        }
Exemple #7
0
 //Includes Prelude module
 private void IncludePrelude(ElaProgram prog, bool addVariable)
 {
     IncludeModule(
         options.Prelude, //alias
         options.Prelude, //name
         null,            //dllname
         null,            //path
         0,               //line
         0,               //col
         false,           //qualified
         prog.TopLevel,   //ElaExpression
         addVariable,     //add variable
         true);           //NoPrelude
 }
Exemple #8
0
        public CompilerResult Compile(ElaProgram prog, CompilerOptions options, ExportVars builtins)
        {
            var frame = new CodeFrame();

            return(Compile(prog, options, builtins, frame, new Scope(false, null)));
        }
Exemple #9
0
 internal AstTreeBuilder(ElaProgram root)
 {
     this.root = root;
 }
Exemple #10
0
        //Entry point
        internal void CompileUnit(ElaProgram prog)
        {
            frame.Layouts.Add(new MemoryLayout(0, 0, 1)); //top level layout
            cw.StartFrame(0);

            //Handles and references should be of the same length. This might not
            //be the case, if we are resuming in interactive mode. We should "align" them,
            //so they are of the same length.
            if (refs.Count != frame.HandleMap.Count)
            {
                for (var i = 0; i < frame.HandleMap.Count; i++)
                {
                    refs.Add(null);
                }
            }

            //Determine whether this is fresh session.
            var scratch = cw.Offset == 0;

            //We always include prelude, but a module variable is created just once
            //(We check if we are not resuming in interactive mode (cw.Offset==0) and if yes
            //we don't create a variable 'prelude'.
            if (!String.IsNullOrEmpty(options.Prelude) && scratch)
            {
                IncludePrelude(prog, scratch);
            }

            //Always include arguments module
            if (scratch)
            {
                IncludeArguments();
            }

            //Another workaround that is needed for interactive mode. We need
            //to restore a reference list with correct indices (LogicalHandle).
            //It can be done by working through the reference map and requesting all referenced
            //modules one more time.
            if (cw.Offset != 0)
            {
                var arr = new ModuleReference[frame.References.Count];

                foreach (var kv in frame.References)
                {
                    arr[kv.Value.LogicalHandle] = kv.Value;
                }

                for (var i = 0; i < arr.Length; i++)
                {
                    var e = new ModuleEventArgs(arr[i]);
                    comp.OnModuleInclude(e);
                    refs[i] = e.Frame;
                }
            }

            var map = new LabelMap();

            //Main compilation routine
            CompileProgram(prog, map);

            //Forcing evaluation of a program retval
            cw.Emit(Op.Force);

            //Every Ela module should end with a Stop op typeId
            cw.Emit(Op.Stop);
            cw.CompileOpList();

            frame.Layouts[0].Size      = currentCounter;
            frame.Layouts[0].StackSize = cw.FinishFrame();
        }
Exemple #11
0
 internal ParserResult(ElaProgram prog, bool success, IEnumerable <ElaMessage> messages) : base(success, messages)
 {
     Program = prog;
 }