public Code Neg(Code opd)
{
Node expr = (Node)opd;
if (expr.type == NodeType.tpInt)
{
if (expr.tag == NodeTag.opIntConst)
{
IntLiteralNode ic = (IntLiteralNode)expr;
ic.val = -ic.val;
}
else
{
expr = new UnaryOpNode(NodeType.tpInt, NodeTag.opIntNeg, expr);
}
}
else if (expr.type == NodeType.tpReal)
{
if (expr.tag == NodeTag.opRealConst)
{
RealLiteralNode fc = (RealLiteralNode)expr;
fc.val = -fc.val;
}
else
{
expr = new UnaryOpNode(NodeType.tpReal, NodeTag.opRealNeg, expr);
}
}
else
{
throw new CodeGeneratorException("Invalid argument types");
}
return(expr);
}
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();
}
public object Visit(RealLiteralNode n, object o)
{
return(null);
}
public RealExpressionNode(RealLiteralNode realLiteral, SourceCodePosition pos) : base(pos)
{
RealLiteral = realLiteral;
}
protected override CrawlSyntaxNode VisitRealLiteral(RealLiteralNode realLiteral)
{
return(realLiteral.WithResultType(CrawlSimpleType.Kommatal));
}
public object Visit(RealLiteralNode n, object o)
{
Append(n.Value);
return(null);
}
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 VisitRealLiteral(RealLiteralNode node)
{
SupressParens();
base.VisitRealLiteral(node);
}
