Exemple #1
0
 public static void PrintPostfixUnaryOperatorExpression(PrintState s, PostfixUnaryOperatorExpression a)
 {
     PrintLine(s, "PostfixUnaryOperatorExpression");
     Indent(s);
     PrintDescWithAny(s, "Op", a.Op);
     PrintDescWithAny(s, "Expr", a.Expr);
     UnIndent(s);
 }
Exemple #2
0
 public static object ParseExpressionTail(ParserState s, object lhs, int minLevel, bool allowStructInitializer)
 {
     while (true)
     {
         if (s.Token.Type == TokenType.OpenParen && minLevel <= 25)
         {
             var result = new CallExpression {
                 Target = lhs, Args = new List <object>()
             };
             ReadToken(s);
             while (s.Token.Type != TokenType.CloseParen)
             {
                 result.Args.Add(ParseExpression(s, 0, true));
                 if (s.Token.Type == TokenType.CloseParen)
                 {
                     break;
                 }
                 ParseTokenWithType(s, TokenType.Comma);
             }
             ParseTokenWithType(s, TokenType.CloseParen);
             lhs = result;
         }
         else if (s.Token.Type == TokenType.OpenBracket && minLevel <= 25)
         {
             var result = new IndexExpression {
                 Target = lhs
             };
             ReadToken(s);
             result.Arg = ParseExpression(s, 0, true);
             ParseTokenWithType(s, TokenType.CloseBracket);
             lhs = result;
         }
         else if (s.Token.Type == TokenType.OpenAngleBracket && (lhs is Token || lhs is DotExpression) && minLevel <= 25)
         {
             if (lhs is Token)
             {
                 var token = (Token)lhs;
                 if (IsProbablyANamespace(token.Value))
                 {
                     lhs = ParseTypeArgsExpressionTail(s, token);
                 }
                 else
                 {
                     s.Token.Type = TokenType.Operator;
                 }
             }
             else
             {
                 var e     = (DotExpression)lhs;
                 var exLhs = e.Lhs;
                 if (exLhs is Token && IsProbablyANamespace(((Token)exLhs).Value))
                 {
                     lhs = ParseTypeArgsExpressionTail(s, e);
                 }
                 else
                 {
                     s.Token.Type = TokenType.Operator;
                 }
             }
         }
         else if (s.Token.Type == TokenType.OpenBrace && minLevel <= 25 && allowStructInitializer)
         {
             if ((lhs is Token && ((Token)lhs).Type == TokenType.Identifier) || lhs is TypeModifierExpression || lhs is TypeArgsExpression)
             {
                 var result = new StructInitializerExpression {
                     Target = lhs, Args = new List <FieldInitializerExpression>()
                 };
                 ReadToken(s);
                 while (s.Token.Type != TokenType.CloseBrace)
                 {
                     var fie = new FieldInitializerExpression {
                         FieldName = ParseTokenWithType(s, TokenType.Identifier)
                     };
                     ReadToken(s);
                     fie.Expr = ParseExpression(s, 0, true);
                     result.Args.Add(fie);
                     if (s.Token.Type == TokenType.CloseBrace)
                     {
                         break;
                     }
                     ParseTokenWithType(s, TokenType.Comma);
                 }
                 ParseTokenWithType(s, TokenType.CloseBrace);
                 lhs = result;
             }
             else
             {
                 return(lhs);
             }
         }
         else if (s.Token.Type == TokenType.CloseAngleBracket)
         {
             s.Token.Type = TokenType.Operator;
         }
         else if (s.Token.Type == TokenType.Operator)
         {
             var level = GetBindingLevel(s.Token.Value);
             if (level < minLevel)
             {
                 return(lhs);
             }
             if (s.Token.Value == "?")
             {
                 var result = new TernaryOperatorExpression {
                     ConditionExpr = lhs
                 };
                 ReadToken(s);
                 result.First = ParseExpression(s, 10, allowStructInitializer);
                 ParseTokenWithType(s, TokenType.Colon);
                 result.Second = ParseExpression(s, 10, allowStructInitializer);
                 lhs           = result;
             }
             else if (s.Token.Value == "^")
             {
                 var result = new PostfixUnaryOperatorExpression {
                     Expr = lhs
                 };
                 result.Op = s.Token;
                 ReadToken(s);
                 lhs = result;
             }
             else if (s.Token.Value == ".")
             {
                 var result = new DotExpression {
                     Lhs = lhs
                 };
                 ReadToken(s);
                 if (s.Token.Type == TokenType.Identifier)
                 {
                     result.Rhs = s.Token;
                     ReadToken(s);
                 }
                 lhs = result;
             }
             else if (level >= 0)
             {
                 var result = new BinaryOperatorExpression {
                     Lhs = lhs
                 };
                 result.Op = s.Token;
                 ReadToken(s);
                 result.Rhs = ParseExpression(s, level + 1, allowStructInitializer);
                 lhs        = result;
             }
             else
             {
                 return(lhs);
             }
         }
         else
         {
             return(lhs);
         }
     }
 }
Exemple #3
0
 public static void CheckPostfixUnaryOperatorExpression(RangeFinderState s, PostfixUnaryOperatorExpression a)
 {
     CheckAny(s, a.Expr);
     CheckToken(s, a.Op);
 }