public Code Not(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.opIntNot, expr);
}
return(expr);
}
else if (expr.type == NodeType.tpBool)
{
return(new UnaryOpNode(NodeType.tpBool, NodeTag.opBoolNot, expr));
}
else
{
throw new CodeGeneratorException("Invalid argument types");
}
}
private Ast Assignment()
{
Func <Ast> op = () => {
if (TokenStream.current is Keyword)
{
if (((Keyword)TokenStream.current).KeywordType == KeywordType.Int)
{
TokenStream.Consume();
if (TokenStream.current is Statement)
{
string name = TokenStream.current.Value;
TokenStream.Consume();
if (((Keyword)TokenStream.current).KeywordType == KeywordType.Assignment)
{
TokenStream.Consume();
IntLiteralNode val = (IntLiteralNode)TokenStream.Capture(IntLiteral);
TokenStream.Consume();
return(new AssignmentNode(TypeValue.Integer, name, val.Value));
}
}
}
}
return(null);
};
return(TokenStream.Capture(op));
}
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);
}
public void CanCreatePublicInstanceWithNonPublicConstructor()
{
ConstructorNode ctorNode = new ConstructorNode();
ctorNode.Text=typeof(PublicTestClass).FullName;
StringLiteralNode sNode = new StringLiteralNode();
sNode.Text = "theValue2";
ctorNode.addChild(sNode);
IntLiteralNode iNode = new IntLiteralNode();
iNode.Text="2";
ctorNode.addChild(iNode);
PublicTestClass instance = (PublicTestClass) ((IExpression)ctorNode).GetValue();
Assert.AreEqual( sNode.Text, instance._s );
Assert.AreEqual( 2, instance._i );
}
public Type Visit(IntLiteralNode node)
{
var intStr = node.AnchorToken.Lexeme;
try
{
Convert.ToInt32(intStr);
}
catch (OverflowException)
{
throw new SemanticError(
$"Integer literal too large: {intStr}",
node.AnchorToken);
}
return(Type.INT);
}
public void Visit(IntLiteralNode node)
{
var intStr = node.AnchorToken.Lexeme;
if (intStr.Equals("false"))
{
//Equivale a cero (único valor falso de Wyvern) 7u7
}
else
{
try {
Convert.ToInt32(intStr);
}
catch (OverflowException) {
throw new SemanticError("Integer overflow, this integer is too big: " + intStr, node.AnchorToken);
}
}
}
public void CanCreateNonPublicInstanceWithNonPublicConstructor()
{
ConstructorNode ctorNode = new ConstructorNode();
ctorNode.Text = typeof(PrivateTestClass).FullName;
StringLiteralNode sNode = new StringLiteralNode();
sNode.Text = "theValue3";
ctorNode.addChild(sNode);
IntLiteralNode iNode = new IntLiteralNode();
iNode.Text = "3";
ctorNode.addChild(iNode);
PublicTestClass instance = (PublicTestClass)((IExpression)ctorNode).GetValue();
Assert.AreEqual(sNode.Text, instance._s);
Assert.AreEqual(3, instance._i);
}
public Node SimpleLiteral()
{
switch (CurrentToken)
{
case TokenCategory.INT_LITERAL:
var intLiteral = new IntLiteralNode()
{
AnchorToken = Expect(TokenCategory.INT_LITERAL)
};
return(intLiteral);
case TokenCategory.STR_LITERAL:
var str_literal = Expect(TokenCategory.STR_LITERAL);
var strLiteral = new StrLiteralNode()
{
};
strLiteral.AnchorToken = str_literal;
return(strLiteral);
case TokenCategory.TRUE:
var trueLiteral = new TrueNode()
{
AnchorToken = Expect(TokenCategory.TRUE)
};
return(trueLiteral);
case TokenCategory.FALSE:
var falseLiteral = new FalseNode()
{
AnchorToken = Expect(TokenCategory.FALSE)
};
return(falseLiteral);
default:
throw new SyntaxError(firstOfDeclaration,
tokenStream.Current);
}
}
public object Visit(IntLiteralNode n, object o)
{
return(null);
}
public void Visit(IntLiteralNode node)
{
builder.AppendLine($"\t\tldc.i4 {node.AnchorToken.Lexeme}");
}
public object Visit(IntLiteralNode 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);
}
public IntExpressionNode(IntLiteralNode intLiteral, SourceCodePosition pos) : base(pos)
{
IntLiteral = intLiteral;
}
