/// <summary> /// Parses an integer expression /// </summary> private IExpressionNode ParseIntExpression() { Debugger.Write("Parsing Int Expression"); IntegerLiteralNode intLit = ParseIntegerLiteral(); return(new IntegerExpressionNode(intLit)); }
private static LiteralNode FoldTheDreadedAddition(LiteralNode op1, LiteralNode op2) { Interval interval = new Interval(op1.Interval.a, op2.Interval.b); //Aye. IntegerLiteralNode int1 = op1 as IntegerLiteralNode; IntegerLiteralNode int2 = op2 as IntegerLiteralNode; RealLiteralNode rea1 = op1 as RealLiteralNode; RealLiteralNode rea2 = op2 as RealLiteralNode; StringLiteralNode str1 = op1 as StringLiteralNode; StringLiteralNode str2 = op2 as StringLiteralNode; if (int1 != null && int2 != null) { int result = int1.Value + int2.Value; return(CrawlSyntaxNode.IntegerLiteral(interval, CrawlSimpleType.Tal, result)); } if (str1 != null && str2 != null) { string result = str1.Value + str2.Value; return(CrawlSyntaxNode.StringLiteral(interval, CrawlSimpleType.Tekst, result)); } if (rea1 != null && rea2 != null) { double result = rea1.Value + rea2.Value; return(CrawlSyntaxNode.RealLiteral(interval, CrawlSimpleType.Kommatal, result)); } //Hvis de er forskellige, se om a kan tildeles til b, hvis ja, konverter a til b's type //Hvis stadig ikke se om b kan tildeles til a, hvis ja, konverter b til a's type if (str1 != null) { string result = str1.Value + (int2?.Value.ToString() ?? rea2?.Value.ToString(CultureInfo.GetCultureInfo("en-GB"))); return(CrawlSyntaxNode.StringLiteral(interval, CrawlSimpleType.Tekst, result)); } if (str2 != null) { string result = (int1?.Value.ToString() ?? rea1?.Value.ToString(CultureInfo.GetCultureInfo("en-GB"))) + str2.Value; return(CrawlSyntaxNode.StringLiteral(interval, CrawlSimpleType.Tekst, result)); } if (rea1 != null) { double result = rea1.Value + int2.Value; return(CrawlSyntaxNode.RealLiteral(interval, CrawlSimpleType.Kommatal, result)); } if (rea2 != null) { double result = int1.Value + rea2.Value; return(CrawlSyntaxNode.RealLiteral(interval, CrawlSimpleType.Kommatal, result)); } throw new NullReferenceException(); }
protected override List <AssemblyElement> VisitIntegerLiteral(IntegerLiteralNode node) { int intValue = (int)node.Value; if (node.DoCastToFloat) { float floatValue = node.Value; intValue = BitConverter.ToInt32(BitConverter.GetBytes(floatValue), 0); } return(new List <AssemblyElement> { new PushInt(intValue) }); }
/// <summary> /// Generates code for an integer literal node /// </summary> /// <param name="integerLiteral">The node to generate code for</param> private void GenerateCodeForIntegerLiteral(IntegerLiteralNode integerLiteral) { Debugger.Write("Generating code for Integer Literal"); code.AddInstruction(OpCode.LOADL, 0, 0, (short)integerLiteral.Value); }
/// <summary> /// Carries out identification on an integer literal node /// </summary> /// <param name="integerLiteral">The node to perform identification on</param> private void PerformIdentificationOnIntegerLiteral(IntegerLiteralNode integerLiteral) { }
/// <summary> /// Creates a new integer literal expression node /// </summary> /// <param name="intLit">The integer literal</param> public IntegerExpressionNode(IntegerLiteralNode intLit) { IntLit = intLit; }
private static LiteralNode FoldMultuPair(LiteralNode op1, ExpressionType expressionType, LiteralNode op2) { if (expressionType == ExpressionType.Add) { return(FoldTheDreadedAddition(op1, op2)); } Interval interval = new Interval(op1.Interval.a, op2.Interval.b); IntegerLiteralNode int1 = op1 as IntegerLiteralNode; IntegerLiteralNode int2 = op2 as IntegerLiteralNode; if (int1 != null && int2 != null) { int result; switch (expressionType) { case ExpressionType.Divide: result = int1.Value / int2.Value; break; case ExpressionType.Modulous: result = int1.Value % int2.Value; break; case ExpressionType.Multiply: result = int1.Value * int2.Value; break; case ExpressionType.Power: result = (int)Math.Pow(int1.Value, int2.Value); break; default: throw new Exception("Operator and/or type entirely unexpected!"); } return(CrawlSyntaxNode.IntegerLiteral(interval, CrawlSimpleType.Tal, result)); } BooleanLiteralNode boo1 = op1 as BooleanLiteralNode; BooleanLiteralNode boo2 = op2 as BooleanLiteralNode; if (boo1 != null && boo2 != null) { bool result; switch (expressionType) { case ExpressionType.ShortCircuitAnd: result = boo1.Value && boo2.Value; break; case ExpressionType.ShortCircuitOr: result = boo1.Value || boo2.Value; break; default: throw new Exception("Operator and/or type entirely unexpected!"); } return(CrawlSyntaxNode.BooleanLiteral(interval, CrawlSimpleType.Bool, result)); } //Else one or both operands are kommatal, so both are casted to that. double rea1 = GetNumber(op1); double rea2 = GetNumber(op2); double res; switch (expressionType) { case ExpressionType.Divide: res = rea1 / rea2; break; case ExpressionType.Modulous: res = rea1 % rea2; break; case ExpressionType.Multiply: res = rea1 * rea2; break; case ExpressionType.Power: res = Math.Pow(rea1, rea2); break; default: throw new Exception("Operator and/or type entirely unexpected!"); } return(CrawlSyntaxNode.RealLiteral(interval, CrawlSimpleType.Tal, res)); }
protected override CrawlSyntaxNode VisitIntegerLiteral(IntegerLiteralNode integerLiteral) { return(integerLiteral.WithResultType(CrawlSimpleType.Tal)); }
public void visitIntegerLiteral(IntegerLiteralNode node) { this.intType = true; this.intStack.Push(node.getInt()); }
public void visitIntegerLiteral(IntegerLiteralNode node) { this.typeStack.Push(MiniPLTokenType.TYPE_IDENTIFIER_INTEGER); }
/// <summary> /// Initialize the literal value source with a literal node. /// </summary> /// <param name="theNode">Literal literalValue.</param> public LiteralLimitValueSource(IntegerLiteralNode theNode) { this.literalValue = theNode.Value; }
public static BlockNode ProcessTokens(List <ScriptToken> tokens) { List <AstTreeNode> blockNodes = new List <AstTreeNode>(); AstTreeNode node = new BlockNode(null); int count = 0; StripWhiteSpace(tokens); while (tokens.Count > 0) { count++; if (count > 1000) { break; // Limit to 1000 iterations while in development } if (tokens[0].Type == EScriptTokenType.RETURN) { tokens.RemoveAt(0); // Last value in block is returned by default } ScriptToken scriptToken = tokens[0]; if (scriptToken.Type == EScriptTokenType.NAME) { node = new RootScopeMemberNode( new LiteralNode <string>(scriptToken.Value) ); tokens.RemoveAt(0); } else if (scriptToken.Type == EScriptTokenType.ASSIGN) { node = AssignmentNode.Parse(node, scriptToken, tokens); } else if (scriptToken.Type == EScriptTokenType.IF) { node = IfStatementNode.Parse(node, scriptToken, tokens); blockNodes.Add(node); node = null; } else if (scriptToken.Type == EScriptTokenType.FOR) { node = ForStatementNode.Parse(node, scriptToken, tokens); blockNodes.Add(node); node = null; } else if (scriptToken.Type == EScriptTokenType.STRING_LITERAL) { node = new LiteralNode <string>(scriptToken.Value); tokens.RemoveAt(0); } else if (scriptToken.Type == EScriptTokenType.NUMBER_LITERAL) { AstTreeNode _node; if (scriptToken.Value.Contains(".")) { _node = new FloatLiteralNode(scriptToken.Value); } else { _node = new IntegerLiteralNode(scriptToken.Value); } node = _node; tokens.RemoveAt(0); } else if (scriptToken.Type == EScriptTokenType.PERIOD) { if (tokens[1].Type == EScriptTokenType.NAME) { node = new ScopeMemberNode( node, new LiteralNode <string>(tokens[1].Value) ); tokens.RemoveAt(0); tokens.RemoveAt(0); } } else if (scriptToken.Type == EScriptTokenType.L_BRACKET) { if (node.GetType() == typeof(RootScopeMemberNode)) { // indice } else { node = ArrayNode.Parse(node, scriptToken, tokens); } } else if (scriptToken.Type == EScriptTokenType.L_PAREN) { List <List <ScriptToken> > funcArgs = GetBlockTokens(tokens); List <AstTreeNode> nodes = new List <AstTreeNode>(); ; foreach (List <ScriptToken> arg in funcArgs) { nodes.Add(ProcessTokens(arg)); } node = new FunctionCallNode( node, // Previous node should be a NAME new FunctionArgumentNode(nodes) ); } else if (scriptToken.Type == EScriptTokenType.SEMI_COLON) { if (node != null) { blockNodes.Add(node); } node = null; tokens.RemoveAt(0); } else if (ComparisonNode.Matches(tokens)) { node = ComparisonNode.Parse(node, scriptToken, tokens); } else if (ArithmeticNode.Matches(tokens)) { AstTreeNode _node = ArithmeticNode.Parse(node, scriptToken, tokens); node = _node; } else if (ArithmeticAssignmentNode.Matches(tokens)) { node = ArithmeticAssignmentNode.Parse(node, scriptToken, tokens); } else if (scriptToken.Type == EScriptTokenType.WHITESPACE) { tokens.RemoveAt(0); } else if (scriptToken.Type == EScriptTokenType.BOOLEAN_LITERAL) { node = new BooleanLiteralNode(tokens[0].Value); tokens.RemoveAt(0); } else if (scriptToken.Type == EScriptTokenType.NULL_LITERAL) { node = new LiteralNode <object>(null); tokens.RemoveAt(0); } else { string code = ScriptTree.ToCode(tokens, 10); Console.WriteLine($"Syntax Error.Near {code}"); } } if (node != null) { blockNodes.Add(node); } return(new BlockNode(blockNodes)); }
public void visitIntegerLiteral(IntegerLiteralNode node) { }
protected override void VisitIntegerLiteral(IntegerLiteralNode node) { SupressParens(); base.VisitIntegerLiteral(node); }