public virtual object VisitDereferenceExpression(DereferenceExpression dereferenceExpression, object data)
{
stackMap.Push(dereferenceExpression);
dereferenceExpression.Expression.AcceptVisitor(this, data);
stackMap.Pop();
return(null);
}
private ExpressionNode ParseExpressionOrType(bool inStatementContext)
{
// Can the interior be a type? (A.2.2)
switch (curtok.ID)
{
// type-name
case TokenID.Ident:
// simple-type
case TokenID.SByte:
case TokenID.Byte:
case TokenID.Short:
case TokenID.UShort:
case TokenID.Int:
case TokenID.UInt:
case TokenID.Long:
case TokenID.ULong:
case TokenID.Char:
case TokenID.Float:
case TokenID.Double:
case TokenID.Decimal:
case TokenID.Bool:
// class-type
case TokenID.Object:
case TokenID.String:
// yes, it can
break;
default:
// no, it can not
return ParseExpression();
}
ExpressionNode expr = ParseIdentifierOrKeyword(false, false, false, false, false);
if (curtok.ID == TokenID.ColonColon)
{
// id :: id type-parameter-list_opt
QualifiedIdentifierExpression qualID = new QualifiedIdentifierExpression(curtok); // TODO: Replace by QualifiedAliasMember instance
qualID.IsNamespaceAliasQualifier = true;
qualID.Expressions.Add(expr);
Advance(); // over ColonColon
qualID.Expressions.Add(ParseMember(inStatementContext));
expr = qualID;
}
else if (ParsePossibleTypeParameterNode(false, false, false, inStatementContext))
{
expr = new TypeNode(expr);
ApplyTypeParameters((TypeNode)expr);
}
while (curtok.ID == TokenID.Dot)
{
Advance(); // over Dot
if (curtok.ID != TokenID.Ident)
{
RecoverFromError(TokenID.Ident);
return expr;
}
expr = new MemberAccessExpression(expr, ParseMember(inStatementContext), TokenID.Dot);
}
bool hasQuestionMark = false;
int starCount = 0;
bool hasBracket = false;
if (curtok.ID == TokenID.Question)
{
Advance();
hasQuestionMark = true;
}
while (curtok.ID == TokenID.Star)
{
Advance();
starCount++;
}
// return (a * b);
// return (a ? b : c);
// a* b = c;
// a? b = c;
// a b = c;
//if(curtok.ID == TokenID.Ident || (hasQuestionMark || starCount > 0) && curtok.ID == TokenID.RParen) goto foundType;
if (curtok.ID == TokenID.Ident)
{
if (inStatementContext) goto foundType;
else if (!hasQuestionMark && starCount == 0) goto foundType; // it is a parse error
}
else if (curtok.ID == TokenID.RParen)
{
if (hasQuestionMark || starCount > 0) goto foundType;
}
else if (curtok.ID == TokenID.LBracket)
{
Advance();
hasBracket = true;
if (hasQuestionMark || starCount > 0 || curtok.ID == TokenID.Comma || curtok.ID == TokenID.RBracket) goto foundType;
}
//
// treat as expression
//
if (hasQuestionMark)
{
// hasBracket is false
ExpressionNode trueExpr = ParseSubexpression(starCount > 0 ? (int)PRECEDENCE_UNARY : 1);
while (starCount-- > 0)
trueExpr = new DereferenceExpression(trueExpr);
AssertAndAdvance(TokenID.Colon);
return new ConditionalExpression(expr, trueExpr, ParseExpression());
}
else if (starCount > 0)
{
// hasBracket is false
starCount--;
ExpressionNode right = ParseSubexpression(starCount > 0 ? PRECEDENCE_UNARY : PRECEDENCE_MULTIPLICATIVE + ASSOC_LEFT);
while (starCount-- > 0)
right = new DereferenceExpression(right);
expr = new BinaryExpression(TokenID.Star, expr, right);
}
else if (hasBracket)
{
expr = new ElementAccessExpression(expr, ParseExpressionList());
AssertAndAdvance(TokenID.RBracket);
}
return ParseSubexpression(1, expr);
//
// treat as type
//
foundType:
TypeNode typeNode = new TypeNode(expr);
if (hasQuestionMark)
typeNode.IsNullableType = true;
while (starCount-- > 0)
typeNode = new TypePointerNode(typeNode);
if (hasBracket)
{
while (true)
{
int numCommas = 0;
while (curtok.ID == TokenID.Comma)
{
Advance();
numCommas++;
}
AssertAndAdvance(TokenID.RBracket);
typeNode.RankSpecifiers.Add(numCommas);
if (curtok.ID != TokenID.LBracket) break;
Advance();
}
}
return typeNode;
}
public virtual object VisitDereferenceExpression(DereferenceExpression dereferenceExpression, object data)
{
stackMap.Push(dereferenceExpression);
dereferenceExpression.Expression.AcceptVisitor( this, data );
stackMap.Pop();
return null;
}