コード例 #1
0
ファイル: Parser.cs プロジェクト: borota/JTVS
 //not_test: 'not' not_test | comparison
 private Expression ParseNotTest()
 {
     if (MaybeEat(TokenKind.KeywordNot)) {
         string proceeding = _tokenWhiteSpace;
         var start = GetStart();
         Expression ret = new UnaryExpression(JOperator.Not, ParseNotTest());
         if (_verbatim) {
             AddPreceedingWhiteSpace(ret, proceeding);
         }
         ret.SetLoc(start, GetEnd());
         return ret;
     } else {
         return ParseComparison();
     }
 }
コード例 #2
0
ファイル: Parser.cs プロジェクト: borota/JTVS
 // factor: ('+'|'-'|'~') factor | power
 private Expression ParseFactor()
 {
     var start = _lookahead.Span.Start;
     Expression ret;
     switch (PeekToken().Kind) {
         case TokenKind.Add:
             NextToken();
             string posWhiteSpace = _tokenWhiteSpace;
             ret = new UnaryExpression(JOperator.Pos, ParseFactor());
             if (_verbatim) {
                 AddPreceedingWhiteSpace(ret, posWhiteSpace);
             }
             break;
         case TokenKind.Subtract:
             NextToken();
             ret = FinishUnaryNegate();
             break;
         case TokenKind.Twiddle:
             NextToken();
             string twiddleWhiteSpace = _tokenWhiteSpace;
             ret = new UnaryExpression(JOperator.Invert, ParseFactor());
             if (_verbatim) {
                 AddPreceedingWhiteSpace(ret, twiddleWhiteSpace);
             }
             break;
         default:
             return ParsePower();
     }
     ret.SetLoc(start, GetEnd());
     return ret;
 }
コード例 #3
0
ファイル: EnclosingNodeWalker.cs プロジェクト: borota/JTVS
 // UnaryExpression
 public override bool Walk(UnaryExpression node)
 {
     return ShouldWalkWorker(node);
 }
コード例 #4
0
ファイル: Parser.cs プロジェクト: borota/JTVS
        private Expression FinishUnaryNegate()
        {
            // Special case to ensure that System.Int32.MinValue is an int and not a BigInteger
            if (PeekToken().Kind == TokenKind.Constant) {
                Token t = PeekToken();

                if (t.Value is BigInteger) {
                    BigInteger bi = (BigInteger)t.Value;
                    if (bi == 0x80000000) {
                        string tokenString = _tokenizer.GetTokenString(); ;
                        Debug.Assert(tokenString.Length > 0);

                        if (tokenString[tokenString.Length - 1] != 'L' &&
                            tokenString[tokenString.Length - 1] != 'l') {
                            string minusWhiteSpace = _tokenWhiteSpace;

                            NextToken();
                            // TODO Fix the white space here
                            var ret = new ConstantExpression(-2147483648);

                            if (_verbatim) {
                                AddExtraVerbatimText(ret, minusWhiteSpace + "-" + _tokenWhiteSpace + t.VerbatimImage);
                            }
                            return ret;
                        }
                    }
                }
            }

            string whitespace = _tokenWhiteSpace;
            var res = new UnaryExpression(JOperator.Negate, ParseFactor());
            if (_verbatim) {
                AddPreceedingWhiteSpace(res, whitespace);
            }
            return res;
        }
コード例 #5
0
ファイル: EnclosingNodeWalker.cs プロジェクト: borota/JTVS
 public override void PostWalk(UnaryExpression node)
 {
     PostWalkWorker(node);
 }