Пример #1
0
        public override int Compile(FunctionContext context)
        {
            context.Line(FileName, Line);

            var sequenceContext = context as SequenceBodyContext;

            if (sequenceContext == null)
            {
                throw new MondCompilerException(FileName, Line, CompilerError.YieldInFun);
            }

            var state      = sequenceContext.SequenceBody.State;
            var enumerable = sequenceContext.SequenceBody.Enumerable;

            var stack          = 0;
            var nextState      = sequenceContext.SequenceBody.NextState;
            var nextStateLabel = sequenceContext.SequenceBody.MakeStateLabel(context);

            stack += context.Load(context.Number(nextState));
            stack += context.Store(state);

            stack += Value.Compile(context);
            stack += context.Load(enumerable);
            stack += context.StoreField(context.String("current"));

            stack += context.LoadTrue();
            stack += context.Return();

            stack += context.Bind(nextStateLabel);

            CheckStack(stack, 0);
            return(stack);
        }
Пример #2
0
        public override int Compile(FunctionContext context)
        {
            var stack        = 0;
            var isAssignment = false;
            var needResult   = !(Parent is IBlockExpression);

            switch (Operation)
            {
            case TokenType.Increment:
                stack += Right.Compile(context);
                stack += context.Load(context.Number(1));

                context.Position(Token);     // debug info
                stack       += context.BinaryOperation(TokenType.Add);
                isAssignment = true;
                break;

            case TokenType.Decrement:
                stack += Right.Compile(context);
                stack += context.Load(context.Number(1));

                context.Position(Token);     // debug info
                stack       += context.BinaryOperation(TokenType.Subtract);
                isAssignment = true;
                break;

            case TokenType.Subtract:
            case TokenType.Not:
            case TokenType.BitNot:
                stack += Right.Compile(context);

                context.Position(Token);     // debug info
                stack += context.UnaryOperation(Operation);
                break;

            default:
                throw new NotSupportedException();
            }

            if (isAssignment)
            {
                var storable = Right as IStorableExpression;
                if (storable == null)
                {
                    throw new MondCompilerException(this, CompilerError.LeftSideMustBeStorable);
                }

                if (needResult)
                {
                    stack += context.Dup();
                }

                stack += storable.CompilePreLoadStore(context, 1);
                stack += storable.CompileStore(context);
            }

            CheckStack(stack, needResult ? 1 : 0);
            return(stack);
        }
Пример #3
0
        public override int Compile(FunctionContext context)
        {
            context.Line(FileName, Line);

            var enumerator = context.DefineInternal("enumerator", true);

            var stack = 0;
            var start = context.MakeLabel("foreachStart");
            var end   = context.MakeLabel("foreachEnd");

            // set enumerator
            stack += Expression.Compile(context);
            stack += context.LoadField(context.String("getEnumerator"));
            stack += context.Call(0);
            stack += context.Store(enumerator);

            // loop while moveNext returns true
            stack += context.Bind(start);
            stack += context.Load(enumerator);
            stack += context.LoadField(context.String("moveNext"));
            stack += context.Call(0);
            stack += context.JumpFalse(end);

            // loop body
            context.PushScope();
            context.PushLoop(start, end);

            if (!context.DefineIdentifier(Identifier))
            {
                throw new MondCompilerException(FileName, Line, CompilerError.IdentifierAlreadyDefined, Identifier);
            }

            var identifier = context.Identifier(Identifier);

            stack += context.Load(enumerator);
            stack += context.LoadField(context.String("current"));
            stack += context.Store(identifier);

            stack += Block.Compile(context);
            stack += context.Jump(start);

            context.PopLoop();
            context.PopScope();

            // after loop
            stack += context.Bind(end);
            stack += context.Load(enumerator);
            stack += context.LoadField(context.String("dispose"));
            stack += context.Call(0);
            stack += context.Drop();

            CheckStack(stack, 0);
            return(stack);
        }
Пример #4
0
        public override int Compile(FunctionContext context)
        {
            context.Line(FileName, Line);

            var isAssignment = false;
            var stack = 0;

            switch (Operation)
            {
                case TokenType.Increment:
                    context.Load(context.Number(1));
                    CompileCheck(context, Right, 1);
                    context.BinaryOperation(TokenType.Add);
                    isAssignment = true;
                    break;

                case TokenType.Decrement:
                    context.Load(context.Number(1));
                    CompileCheck(context, Right, 1);
                    context.BinaryOperation(TokenType.Subtract);
                    isAssignment = true;
                    break;

                case TokenType.Subtract:
                case TokenType.LogicalNot:
                    CompileCheck(context, Right, 1);
                    context.UnaryOperation(Operation);
                    stack++;
                    break;

                default:
                    throw new NotSupportedException();
            }

            if (isAssignment)
            {
                var storable = Right as IStorableExpression;
                if (storable == null)
                    throw new MondCompilerException(FileName, Line, "The left-hand side of an assignment must be storable"); // TODO: better message

                var needResult = !(Parent is BlockExpression);

                if (needResult)
                {
                    context.Dup();
                    stack++;
                }

                storable.CompileStore(context);
            }

            return stack;
        }
Пример #5
0
        public override int Compile(FunctionContext context)
        {
            context.Line(FileName, Line);

            var stack      = 0;
            var identifier = context.Identifier(Name);

            if (!context.Compiler.Options.UseImplicitGlobals && identifier == null)
            {
                throw new MondCompilerException(FileName, Line, CompilerError.UndefinedIdentifier, Name);
            }

            if (identifier == null)
            {
                stack += context.LoadGlobal();
                stack += context.LoadField(context.String(Name));
            }
            else
            {
                stack += context.Load(identifier);
            }

            CheckStack(stack, 1);
            return(stack);
        }
Пример #6
0
        public override int Compile(FunctionContext context)
        {
            var stack      = 0;
            var identifier = context.Identifier(Name);

            // anything that starts with 'op_' is always an implicit global
            if (!context.Compiler.Options.UseImplicitGlobals && identifier == null && !Name.StartsWith("op_"))
            {
                throw new MondCompilerException(this, CompilerError.UndefinedIdentifier, Name);
            }

            context.Position(Token); // debug info

            if (identifier == null)
            {
                stack += context.LoadGlobal();
                stack += context.LoadField(context.String(Name));
            }
            else
            {
                stack += context.Load(identifier);
            }

            CheckStack(stack, 1);
            return(stack);
        }
Пример #7
0
        public override int Compile(FunctionContext context)
        {
            context.Line(FileName, Line);

            var storable = Left as IStorableExpression;

            if (storable == null)
            {
                throw new MondCompilerException(FileName, Line, CompilerError.LeftSideMustBeStorable);
            }

            var stack      = 0;
            var needResult = !(Parent is IBlockExpression);

            if (needResult)
            {
                stack += Left.Compile(context);
            }

            switch (Operation)
            {
            case TokenType.Increment:
                stack += context.Load(context.Number(1));
                stack += Left.Compile(context);
                stack += context.BinaryOperation(TokenType.Add);
                break;

            case TokenType.Decrement:
                stack += context.Load(context.Number(1));
                stack += Left.Compile(context);
                stack += context.BinaryOperation(TokenType.Subtract);
                break;

            default:
                throw new NotSupportedException();
            }

            stack += storable.CompileStore(context);

            CheckStack(stack, needResult ? 1 : 0);
            return(stack);
        }
Пример #8
0
        public override int Compile(FunctionContext context)
        {
            context.Position(Token);

            var sequenceContext = context.Root as SequenceBodyContext;

            if (sequenceContext == null)
            {
                throw new MondCompilerException(this, CompilerError.YieldInFun);
            }

            var state      = sequenceContext.SequenceBody.State;
            var enumerable = sequenceContext.SequenceBody.Enumerable;

            var stack          = 0;
            var nextState      = sequenceContext.SequenceBody.NextState;
            var nextStateLabel = sequenceContext.SequenceBody.MakeStateLabel(context);

            stack += Value.Compile(context);
            stack += context.Load(enumerable);
            stack += context.StoreField(context.String("current"));

            stack += context.Load(context.Number(nextState)); // set resume point
            stack += context.Store(state);

            stack += context.StoreState(sequenceContext.LocalIndex - 1); // save locals
            stack += context.LoadTrue();
            stack += context.Return();

            stack += context.Bind(nextStateLabel);
            stack += context.LoadState(sequenceContext.LocalIndex - 1); // load locals

            if (!(Parent is IBlockExpression))
            {
                stack += context.Load(context.Identifier("#input"));
                CheckStack(stack, 1);
                return(stack);
            }

            CheckStack(stack, 0);
            return(stack);
        }
Пример #9
0
        public override void CompileBody(FunctionContext context)
        {
            var stack = 0;

            EndLabel = context.MakeLabel("state_end");

            stack += context.Bind(context.Label);
            stack += context.Enter();

            // jump to state label
            stack += context.Load(State);
            stack += context.JumpTable(0, _stateLabels);
            stack += context.Jump(EndLabel);

            // first state
            stack += context.Bind(MakeStateLabel(context));

            // compile body
            stack += Block.Compile(context);

            // set enumerator.current to undefined
            // do this before EndLabel so we dont overwrite return values
            stack += context.LoadUndefined();
            stack += context.Load(Enumerable);
            stack += context.StoreField(context.String("current"));

            stack += context.Bind(EndLabel);

            // set state to end
            stack += context.Load(context.Number(-1));
            stack += context.Store(State);

            stack += context.LoadFalse();
            stack += context.Return();

            CheckStack(stack, 0);
        }
Пример #10
0
        public override int Compile(FunctionContext context)
        {
            var stack = 0;

            context.Position(Token);
            stack += context.NewArray(Values.Count);

            for (var i = 0; i < Values.Count; ++i)
            {
                stack += context.Dup();
                stack += Values[i].Compile(context);
                stack += context.Swap();
                stack += context.Load(context.Number(i));
                stack += context.StoreArray();
            }

            CheckStack(stack, 1);
            return(stack);
        }
Пример #11
0
        public override int Compile(FunctionContext context)
        {
            context.Line(FileName, Line);

            var identifier = context.Identifier(Name);

            /*if (identifier == null)
                throw new MondCompilerException(FileName, Line, "Undefined identifier '{0}'", Name);*/

            if (identifier == null)
            {
                context.LoadGlobal();
                context.LoadField(context.String(Name));
            }
            else
            {
                context.Load(identifier);
            }

            return 1;
        }
Пример #12
0
        public override int Compile(FunctionContext context)
        {
            context.Line(FileName, Line);

            return(context.Load(context.Number(Value)));
        }
Пример #13
0
 public override int Compile(FunctionContext context)
 {
     context.Position(Token);
     return(context.Load(context.Number(Value)));
 }
Пример #14
0
        public override void CompileBody(FunctionContext context)
        {
            var state      = context.DefineInternal("state");
            var enumerable = context.DefineInternal("enumerable");

            var stack      = 0;
            var bodyToken  = new Token(Token, TokenType.Fun, null);
            var body       = new SequenceBodyExpression(bodyToken, null, Block, "moveNext", state, enumerable);
            var seqContext = new SequenceContext(context.Compiler, "moveNext", body, context);

            var getEnumerator = context.MakeFunction("getEnumerator");

            getEnumerator.Function(getEnumerator.FullName);
            getEnumerator.Bind(getEnumerator.Label);
            getEnumerator.Enter();
            getEnumerator.Load(enumerable);
            getEnumerator.Return();

            var dispose = context.MakeFunction("dispose");

            dispose.Function(dispose.FullName);
            dispose.Bind(dispose.Label);
            dispose.Enter();
            dispose.LoadUndefined();
            dispose.Return();

            stack += context.Bind(context.Label);
            stack += context.Enter();

            if (OtherArguments != null)
            {
                stack += context.VarArgs(Arguments.Count);
            }

            stack += context.Load(context.Number(0));
            stack += context.Store(state);

            stack += context.NewObject();

            stack += context.Dup();
            stack += context.LoadUndefined();
            stack += context.Swap();
            stack += context.StoreField(context.String("current"));

            stack += context.Dup();
            stack += body.Compile(seqContext);
            stack += context.Swap();
            stack += context.StoreField(context.String("moveNext"));

            stack += context.Dup();
            stack += context.Closure(getEnumerator.Label);
            stack += context.Swap();
            stack += context.StoreField(context.String("getEnumerator"));

            stack += context.Dup();
            stack += context.Closure(dispose.Label);
            stack += context.Swap();
            stack += context.StoreField(context.String("dispose"));

            stack += context.Store(enumerable);

            stack += context.Load(enumerable);
            stack += context.Return();

            CheckStack(stack, 0);
        }
Пример #15
0
        public override int Compile(FunctionContext context)
        {
            context.Position(Token);

            var stack = 0;
            var start = context.MakeLabel("foreachStart");
            var cont  = context.MakeLabel("foreachContinue");
            var brk   = context.MakeLabel("foreachBreak");
            var end   = context.MakeLabel("foreachEnd");

            var containsFunction = new LoopContainsFunctionVisitor();

            Block.Accept(containsFunction);

            var enumerator = context.DefineInternal("enumerator", true);

            // set enumerator
            context.Statement(Expression);
            stack += Expression.Compile(context);
            stack += context.LoadField(context.String("getEnumerator"));
            stack += context.Call(0, new List <ImmediateOperand>());
            stack += context.Store(enumerator);

            var loopContext = containsFunction.Value ? new LoopContext(context) : context;

            // loop body
            loopContext.PushScope();
            loopContext.PushLoop(containsFunction.Value ? cont : start, containsFunction.Value ? brk : end);

            IdentifierOperand identifier;

            if (DestructureExpression != null)
            {
                identifier = context.DefineInternal(Identifier, true);
            }
            else
            {
                // create the loop variable outside of the loop context (but inside of its scope!)
                if (!context.DefineIdentifier(Identifier))
                {
                    throw new MondCompilerException(this, CompilerError.IdentifierAlreadyDefined, Identifier);
                }

                identifier = context.Identifier(Identifier);
            }
            stack += loopContext.Bind(start); // continue (without function)

            if (containsFunction.Value)
            {
                stack += loopContext.Enter();
            }

            // loop while moveNext returns true
            context.Statement(InToken, InToken);
            stack += loopContext.Load(enumerator);
            stack += loopContext.LoadField(context.String("moveNext"));
            stack += loopContext.Call(0, new List <ImmediateOperand>());
            stack += loopContext.JumpFalse(containsFunction.Value ? brk : end);

            stack += loopContext.Load(enumerator);
            stack += loopContext.LoadField(context.String("current"));
            stack += loopContext.Store(identifier);

            if (DestructureExpression != null)
            {
                stack += loopContext.Load(identifier);
                stack += DestructureExpression.Compile(loopContext);
            }

            stack += Block.Compile(loopContext);

            if (containsFunction.Value)
            {
                stack += loopContext.Bind(cont); // continue (with function)
                stack += loopContext.Leave();
            }

            stack += loopContext.Jump(start);

            if (containsFunction.Value)
            {
                stack += loopContext.Bind(brk); // break (with function)
                stack += loopContext.Leave();
            }

            loopContext.PopLoop();
            loopContext.PopScope();

            // after loop
            stack += context.Bind(end); // break (without function)
            stack += context.Load(enumerator);
            stack += context.LoadField(context.String("dispose"));
            stack += context.Call(0, new List <ImmediateOperand>());
            stack += context.Drop();

            CheckStack(stack, 0);
            return(stack);
        }
Пример #16
0
        public override int Compile(FunctionContext context)
        {
            context.Position(Token);

            var stack  = Initializer?.Compile(context) ?? 1;
            var global = context.ArgIndex == 0 && context.Compiler.Options.MakeRootDeclarationsGlobal;

            var hasSlice = false;
            var headSize = 0;
            var tailSize = 0;

            foreach (var index in Indices)
            {
                if (index.IsSlice)
                {
                    if (hasSlice)
                    {
                        throw new InvalidOperationException($"Multiple slices in {nameof(DestructuredArrayExpression)}");
                    }

                    hasSlice = true;
                }
                else if (hasSlice)
                {
                    tailSize++;
                }
                else
                {
                    headSize++;
                }
            }

            var fixedSize = headSize + tailSize;

            stack += context.Dup();
            stack += context.LoadField(context.String("length"));
            stack += context.Call(0, new List <ImmediateOperand>());

            var inTail = false;
            var fixedI = 0;

            for (var i = 0; i < Indices.Count; i++)
            {
                var index    = Indices[i];
                var assign   = context.MakeLabel("arrayDestructureAssign");
                var destruct = context.MakeLabel("arrayDestructureIndex");

                if (index.IsSlice)
                {
                    inTail = true;
                }

                if (i < Indices.Count - 1)
                {
                    stack += context.Dup2(); // -> init.length(), init
                }
                stack += context.Load(context.Number(index.IsSlice ? fixedSize : fixedI));
                stack += context.BinaryOperation(TokenType.GreaterThan);
                stack += context.JumpTrue(destruct);
                stack += context.Drop(); // drops initializer
                stack += index.IsSlice ? context.NewArray(0) : context.LoadUndefined();
                stack += context.Jump(assign);

                stack += context.Bind(destruct);

                if (index.IsSlice)
                {
                    stack += context.Load(context.Number(fixedI));
                    stack += context.Load(context.Number(-tailSize - 1));
                    stack += context.LoadUndefined();
                    stack += context.Slice();
                }
                else
                {
                    stack += context.Load(context.Number(inTail ? fixedI - fixedSize : fixedI));
                    stack += context.LoadArray();
                }

                stack += context.Bind(assign);

                if (global)
                {
                    stack += context.LoadGlobal();
                    stack += context.StoreField(context.String(index.Name));
                }
                else
                {
                    if (!context.DefineIdentifier(index.Name, IsReadOnly))
                    {
                        throw new MondCompilerException(this, CompilerError.IdentifierAlreadyDefined, index.Name);
                    }

                    stack += context.Store(context.Identifier(index.Name));
                }

                if (!index.IsSlice)
                {
                    fixedI++;
                }
            }

            CheckStack(stack, 0);
            return(-1);
        }