Пример #1
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);
        }
Пример #2
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;
        }
Пример #3
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);
        }
Пример #4
0
        public override int Compile(FunctionContext context)
        {
            context.Position(Token);

            var stack      = 0;
            var caseLabels = new List <LabelOperand>(Branches.Count);

            var             caseEnd      = context.MakeLabel("caseEnd");
            LabelOperand    caseDefault  = null;
            BlockExpression defaultBlock = null;

            for (var i = 0; i < Branches.Count; i++)
            {
                var label = context.MakeLabel("caseBranch_" + i);
                caseLabels.Add(label);

                var conditions = Branches[i].Conditions;
                if (conditions.Any(c => c == null))
                {
                    caseDefault = label;

                    if (conditions.Count == 1)
                    {
                        defaultBlock = Branches[i].Block;
                    }
                }
            }

            var emptyDefault = caseDefault == null;

            if (emptyDefault)
            {
                caseDefault = context.MakeLabel("caseDefault");
            }

            context.PushScope();

            context.Statement(Expression);
            stack += Expression.Compile(context);

            var flattenedBranches = FlattenBranches(Branches, caseLabels, caseDefault);

            BuildTables(flattenedBranches, caseDefault, out var tables, out var rest);

            foreach (var table in tables)
            {
                var start  = table.Entries[0].Value;
                var labels = table.Entries.Select(e => e.Label).ToList();

                stack += context.Dup();
                stack += context.JumpTable(start, labels);
            }

            foreach (var entry in rest)
            {
                stack += context.Dup();
                stack += entry.Condition.Compile(context);
                stack += context.BinaryOperation(TokenType.EqualTo);
                stack += context.JumpTrue(entry.Label);
            }

            stack += context.Jump(caseDefault);

            context.PushLoop(null, caseEnd);

            for (var i = 0; i < Branches.Count; i++)
            {
                var branchStack = stack;
                var branch      = Branches[i];

                branchStack += context.Bind(caseLabels[i]);
                branchStack += context.Drop();
                branchStack += branch.Block.Compile(context);
                branchStack += context.Jump(caseEnd);

                CheckStack(branchStack, 0);
            }

            // only bind if we need a default block
            if (emptyDefault || defaultBlock != null)
            {
                stack += context.Bind(caseDefault);
            }

            // always drop the switch value
            stack += context.Drop();

            if (defaultBlock != null)
            {
                stack += defaultBlock.Compile(context);
            }

            context.PopLoop();

            stack += context.Bind(caseEnd);

            context.PopScope();

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

            TokenType assignOperation;

            var hasAssignOperation = _assignMap.TryGetValue(Operation, out assignOperation);
            var isAssign = Operation == TokenType.Assign || hasAssignOperation;

            if (isAssign)
            {
                var storable = Left as IStorableExpression;
                if (storable == null)
                    throw new MondCompilerException(FileName, Line, "The left-hand side of an assignment must be storable");

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

                CompileCheck(context, Right, 1);

                if (hasAssignOperation)
                {
                    CompileCheck(context, Left, 1);
                    context.BinaryOperation(assignOperation);
                }

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

                storable.CompileStore(context);
                return stack;
            }

            if (Operation == TokenType.LogicalOr)
            {
                var endOr = context.MakeLabel("endOr");
                CompileCheck(context, Left, 1);
                context.JumpTruePeek(endOr);
                CompileCheck(context, Right, 1);
                context.Bind(endOr);
                return 1;
            }

            if (Operation == TokenType.LogicalAnd)
            {
                var endAnd = context.MakeLabel("endAnd");
                CompileCheck(context, Left, 1);
                context.JumpFalsePeek(endAnd);
                CompileCheck(context, Right, 1);
                context.Bind(endAnd);
                return 1;
            }

            CompileCheck(context, Right, 1);
            CompileCheck(context, Left, 1);
            context.BinaryOperation(Operation);
            return 1;
        }
Пример #6
0
        public override int Compile(FunctionContext context)
        {
            context.Line(FileName, Line);

            var stack = 0;

            TokenType assignOperation;
            var       hasAssignOperation = _assignMap.TryGetValue(Operation, out assignOperation);
            var       isAssign           = Operation == TokenType.Assign || hasAssignOperation;

            if (isAssign)
            {
                var storable = Left as IStorableExpression;
                if (storable == null)
                {
                    throw new MondCompilerException(FileName, Line, CompilerError.LeftSideMustBeStorable);
                }

                var needResult = !(Parent is IBlockExpression);

                stack += Right.Compile(context);

                if (hasAssignOperation)
                {
                    stack += Left.Compile(context);
                    stack += context.BinaryOperation(assignOperation);
                }

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

                stack += storable.CompileStore(context);

                CheckStack(stack, needResult ? 1 : 0);
                return(stack);
            }

            if (Operation == TokenType.ConditionalOr)
            {
                var endOr = context.MakeLabel("endOr");
                stack += Left.Compile(context);
                stack += context.JumpTruePeek(endOr);
                stack += context.Drop();
                stack += Right.Compile(context);
                stack += context.Bind(endOr);

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

            if (Operation == TokenType.ConditionalAnd)
            {
                var endAnd = context.MakeLabel("endAnd");
                stack += Left.Compile(context);
                stack += context.JumpFalsePeek(endAnd);
                stack += context.Drop();
                stack += Right.Compile(context);
                stack += context.Bind(endAnd);

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

            stack += Right.Compile(context);
            stack += Left.Compile(context);
            stack += context.BinaryOperation(Operation);

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

            var stack      = 0;
            var caseLabels = new List <LabelOperand>(Branches.Count);

            for (var i = 0; i < Branches.Count; i++)
            {
                caseLabels.Add(context.MakeLabel("caseBranch_" + i));
            }

            var caseDefault = context.MakeLabel("caseDefault");
            var caseEnd     = context.MakeLabel("caseEnd");

            stack += Expression.Compile(context);

            List <JumpTable> tables;
            List <JumpEntry> rest;
            var flattenedBranches = FlattenBranches(Branches, caseLabels);

            BuildTables(flattenedBranches, caseDefault, out tables, out rest);

            foreach (var table in tables)
            {
                var start  = table.Entries[0].Value;
                var labels = table.Entries.Select(e => e.Label).ToList();

                stack += context.Dup();
                stack += context.JumpTable(start, labels);
            }

            foreach (var entry in rest)
            {
                stack += context.Dup();
                stack += entry.Condition.Compile(context);
                stack += context.BinaryOperation(TokenType.EqualTo);
                stack += context.JumpTrue(entry.Label);
            }

            stack += context.Jump(caseDefault);

            context.PushLoop(null, caseEnd);

            for (var i = 0; i < Branches.Count; i++)
            {
                var branchStack = stack;
                var branch      = Branches[i];

                branchStack += context.Bind(caseLabels[i]);
                branchStack += context.Drop();
                branchStack += branch.Block.Compile(context);
                branchStack += context.Jump(caseEnd);

                CheckStack(branchStack, 0);
            }

            stack += context.Bind(caseDefault);
            stack += context.Drop();

            if (DefaultBlock != null)
            {
                stack += DefaultBlock.Compile(context);
            }

            context.PopLoop();

            stack += context.Bind(caseEnd);

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

            var isAssignOperation = _assignMap.TryGetValue(Operation, out var assignOperation);

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

                var needResult = !(Parent is IBlockExpression);

                if (isAssignOperation)
                {
                    int preTotal;
                    var preTimes = needResult ? 3 : 2;

                    stack += preTotal = storable.CompilePreLoadStore(context, preTimes);

                    stack += storable.CompileLoad(context);
                    stack += Right.Compile(context);
                    stack += context.BinaryOperation(assignOperation);

                    switch (preTotal / preTimes)
                    {
                    case 0:
                        break;

                    case 1:
                        stack += context.Swap();
                        break;

                    case 2:
                        stack += context.Swap1For2();
                        break;

                    default:
                        throw new NotSupportedException();
                    }

                    stack += storable.CompileStore(context);

                    if (needResult)
                    {
                        stack += storable.CompileLoad(context);
                    }
                }
                else
                {
                    stack += Right.Compile(context);

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

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

                CheckStack(stack, needResult ? 1 : 0);
                return(stack);
            }

            if (Operation == TokenType.ConditionalOr)
            {
                var endOr = context.MakeLabel("endOr");
                stack += Left.Compile(context);
                stack += context.JumpTruePeek(endOr);
                stack += context.Drop();
                stack += Right.Compile(context);
                stack += context.Bind(endOr);

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

            if (Operation == TokenType.ConditionalAnd)
            {
                var endAnd = context.MakeLabel("endAnd");
                stack += Left.Compile(context);
                stack += context.JumpFalsePeek(endAnd);
                stack += context.Drop();
                stack += Right.Compile(context);
                stack += context.Bind(endAnd);

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

            stack += Left.Compile(context);
            stack += Right.Compile(context);

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

            CheckStack(stack, 1);
            return(stack);
        }
Пример #9
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);
        }