public EnumerationFieldNode(ParseNodeList attributes, AtomicNameNode name,
ParseNode value)
: base(ParseNodeType.EnumerationFieldDeclaration, name.token)
{
_attributes = GetParentedNodeList(AttributeNode.GetAttributeList(attributes));
_name = (AtomicNameNode)GetParentedNode(name);
if (value is LiteralNode)
{
LiteralNode literalNode = (LiteralNode)value;
_value = ((LiteralToken)literalNode.Token).LiteralValue;
}
else
{
// TODO: Clearly we need something more general...
// C# allows expressions. Likely expressions to be used
// include negative values, binary OR'd values,
// expressions involving other enum members (esp. hard to deal with)
// For now, just adding support for negative numbers, as
// everything else can be worked around in source code.
UnaryExpressionNode expressionNode = value as UnaryExpressionNode;
if ((expressionNode != null) && (expressionNode.Operator == TokenType.Minus) &&
(expressionNode.Child is LiteralNode))
{
try {
LiteralToken literalToken =
(LiteralToken)((LiteralNode)expressionNode.Child).Token;
int numericValue = (int)Convert.ChangeType(literalToken.LiteralValue, typeof(int));
_value = -numericValue;
}
catch {
}
}
}
}
private Expression ProcessLiteralNode(LiteralNode node) {
LiteralToken token = (LiteralToken)node.Token;
string systemTypeName = null;
switch (token.LiteralType) {
case LiteralTokenType.Null:
systemTypeName = "Object";
break;
case LiteralTokenType.Boolean:
systemTypeName = "Boolean";
break;
case LiteralTokenType.Char:
systemTypeName = "Char";
break;
case LiteralTokenType.String:
systemTypeName = "String";
break;
case LiteralTokenType.Int:
systemTypeName = "Int32";
break;
case LiteralTokenType.UInt:
systemTypeName = "UInt32";
break;
case LiteralTokenType.Long:
systemTypeName = "Int64";
break;
case LiteralTokenType.ULong:
systemTypeName = "UInt64";
break;
case LiteralTokenType.Float:
systemTypeName = "Single";
break;
case LiteralTokenType.Double:
systemTypeName = "Double";
break;
case LiteralTokenType.Decimal:
systemTypeName = "Decimal";
break;
default:
Debug.Fail("Unknown Literal Token Type: " + token.LiteralType);
break;
}
if (systemTypeName != null) {
TypeSymbol typeSymbol =
(TypeSymbol)((ISymbolTable)_symbolSet.SystemNamespace).FindSymbol(systemTypeName, null, SymbolFilter.Types);
Debug.Assert(typeSymbol != null);
return new LiteralExpression(typeSymbol, token.LiteralValue);
}
return null;
}
private ParseNode ParsePrimaryExpression() {
ParseNode expr;
switch (PeekType()) {
case TokenType.Null:
case TokenType.True:
case TokenType.False:
case TokenType.Literal:
expr = new LiteralNode(NextToken());
break;
case TokenType.OpenParen:
Eat(TokenType.OpenParen);
expr = ParseExpression();
if (expr is ExpressionNode) {
((ExpressionNode)expr).AddParenthesisHint();
}
Eat(TokenType.CloseParen);
break;
case TokenType.New:
expr = ParseNew();
break;
case TokenType.Typeof: {
Token token = NextToken();
Eat(TokenType.OpenParen);
expr = new TypeofNode(token, ParseReturnType());
Eat(TokenType.CloseParen);
break;
}
case TokenType.Sizeof: {
Token token = NextToken();
Eat(TokenType.OpenParen);
expr = new SizeofNode(token, ParseType());
Eat(TokenType.CloseParen);
break;
}
case TokenType.Checked:
case TokenType.Unchecked: {
Token token = NextToken();
Eat(TokenType.OpenParen);
expr = new UnaryExpressionNode(token, ParseExpression());
Eat(TokenType.CloseParen);
break;
}
case TokenType.This:
expr = new ThisNode(NextToken());
break;
case TokenType.Base:
expr = new BaseNode(NextToken());
if (PeekType() != TokenType.Dot && PeekType() != TokenType.OpenSquare) {
this.ReportError(ParseError.BadBaseExpression);
}
break;
case TokenType.Identifier:
expr = ParseAliasQualifiedName(true);
break;
case TokenType.Delegate:
expr = ParseAnonymousMethod();
break;
default:
if (Token.IsPredefinedType(PeekType()) && PeekType() != TokenType.Void) {
expr = ParsePredefinedType();
CheckType(TokenType.Dot);
}
else {
ReportError(ParseError.ExpressionExpected);
expr = ParseIdentifier();
}
break;
}
// postfix operators
bool foundPostfix = true;
do {
Token token = PeekToken();
switch (PeekType()) {
case TokenType.Dot:
if (PeekType(1) == TokenType.Default) {
expr = new DefaultValueNode(expr);
Eat(TokenType.Dot);
Eat(TokenType.Default);
}
else
expr = new BinaryExpressionNode(expr, NextToken().Type, ParseSimpleName(true));
break;
case TokenType.OpenParen:
expr = new BinaryExpressionNode(expr, token.Type, ParseParenArgumentList());
break;
case TokenType.PlusPlus:
case TokenType.MinusMinus:
expr = new BinaryExpressionNode(expr, NextToken().Type, null);
break;
case TokenType.OpenSquare:
expr = new BinaryExpressionNode(expr, NextToken().Type, ParseExpressionList(TokenType.CloseSquare));
Eat(TokenType.CloseSquare);
break;
case TokenType.Arrow:
expr = new BinaryExpressionNode(expr, NextToken().Type, ParseIdentifier());
break;
default:
foundPostfix = false;
break;
}
} while (foundPostfix);
return expr;
}
