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);
}
