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