public override int Compile(FunctionContext context) { var needStatements = context.Compiler.Options.DebugInfo >= MondDebugInfoLevel.Full; foreach (var expression in Statements) { if (needStatements) { var statement = expression as IStatementExpression; if (statement == null || !statement.HasChildren) { context.Statement(expression); } } var stack = expression.Compile(context); while (stack > 0) { context.Drop(); stack--; } } return(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; foreach (var field in Fields) { var name = field.Alias ?? field.Name; stack += context.Dup(); stack += context.LoadField(context.String(field.Name)); if (global) { stack += context.LoadGlobal(); stack += context.StoreField(context.String(name)); } else { if (!context.DefineIdentifier(name, IsReadOnly)) { throw new MondCompilerException(this, CompilerError.IdentifierAlreadyDefined, name); } stack += context.Store(context.Identifier(name)); } } stack += context.Drop(); CheckStack(stack, 0); return(-1); }
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); }
public override int Compile(FunctionContext context) { foreach (var statement in Statements) { var stack = statement.Compile(context); while (stack > 0) { context.Drop(); stack--; } } return(0); }
public override int Compile(FunctionContext context) { foreach (var statement in Statements) { var stack = statement.Compile(context); while (stack > 0) { context.Drop(); stack--; } } return 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); }
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); }
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); }
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); }
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); }
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); }