public DomainId <IBooleanLiteralNode> CreateBooleanLiteral(string booleanString) { var literal = new BooleanLiteralNode(m_ids.Next, booleanString); return(DomainItemRegistration <IBooleanLiteralNode>(literal)); }
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)); }
public object Visit(BooleanLiteralNode n, object o) { return(null); }
private object EvaluateNode(BooleanLiteralNode expression, Context context) { return(expression.value); }
protected override CrawlSyntaxNode VisitBooleanLiteral(BooleanLiteralNode booleanLiteral) { return(booleanLiteral.WithResultType(CrawlSimpleType.Bool)); }
public BooleanExpressionNode(BooleanLiteralNode stringLiteral, SourceCodePosition pos) : base(pos) { BooleanLiteral = stringLiteral; }
public abstract TResult Visit(BooleanLiteralNode node, TContext context);
public object Visit(BooleanLiteralNode n, object o) { Append(n.Value); return(null); }
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 Word Visit(BooleanLiteralNode boolLiteralNode) { return(MyPrimitiveFactory.Create(boolLiteralNode.Value)); }
private ExpressionNode Primary() { ExpressionNode itsAST = null; // in case there is a syntactic error SourceCodePosition itsPos = _currentToken.SourcePosition; if (_currentToken.Type == Token.TokenType.LeftParen) { Accept(Token.TokenType.LeftParen); itsAST = Expression(); Accept(Token.TokenType.RightParen); } else if (Array.Exists(_literalFirstSet, e => e == _currentToken.Type)) { switch (_currentToken.Type) { case Token.TokenType.IntLiteral: IntLiteralNode intLiteral = new IntLiteralNode(_currentToken.Value, _currentToken.SourcePosition); Accept(Token.TokenType.IntLiteral); itsAST = new IntExpressionNode(intLiteral, itsPos); break; case Token.TokenType.RealLiteral: RealLiteralNode realLiteral = new RealLiteralNode(_currentToken.Value, _currentToken.SourcePosition); Accept(Token.TokenType.RealLiteral); itsAST = new RealExpressionNode(realLiteral, itsPos); break; case Token.TokenType.StringLiteral: StringLiteralNode stringLiteral = new StringLiteralNode(_currentToken.Value, _currentToken.SourcePosition); Accept(Token.TokenType.StringLiteral); itsAST = new StringExpressionNode(stringLiteral, itsPos); break; case Token.TokenType.BooleanLiteral: BooleanLiteralNode booleanLiteral = new BooleanLiteralNode(_currentToken.Value, _currentToken.SourcePosition); Accept(Token.TokenType.BooleanLiteral); itsAST = new BooleanExpressionNode(booleanLiteral, itsPos); break; case Token.TokenType.Null: NullLiteralNode nullLiteral = new NullLiteralNode(_currentToken.Value, _currentToken.SourcePosition); Accept(Token.TokenType.Null); itsAST = new NullExpressionNode(nullLiteral, itsPos); break; default: itsAST = null; // should not happen break; } } else if (_currentToken.Type == Token.TokenType.Identifier) { itsAST = MemberReference(); } else if (_currentToken.Type == Token.TokenType.This) { itsAST = ThisReference(); } else if (_currentToken.Type == Token.TokenType.New) { itsAST = Instantiation(); } else { Error("The token is invalid in the current context"); } return(itsAST); }
protected override void VisitBooleanLiteral(BooleanLiteralNode node) { SupressParens(); base.VisitBooleanLiteral(node); }