Advertisement
Guest User

Untitled

a guest
Sep 4th, 2015
60
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 5.70 KB | None | 0 0
  1. private Expression Expression()
  2.         {
  3.             Func<Expression> unaryExpr = () =>
  4.             {
  5.                 switch (TokType)
  6.                 {
  7.                     case TokenType.Complement:
  8.                         NextToken();
  9.                         return new UnariExpression("COM") { Argument = Expression() };
  10.                     case TokenType.LogicalNot:
  11.                         NextToken();
  12.                         return new UnariExpression("NOT") { Argument = Expression() };
  13.                     case TokenType.Plus:
  14.                         NextToken();
  15.                         return new UnariExpression("PLUS") { Argument = Expression() };
  16.                     case TokenType.Minus:
  17.                         NextToken();
  18.                         return new UnariExpression("MINUS") { Argument = Expression() };
  19.                     case TokenType.LParam:
  20.                     {
  21.                         NextToken();
  22.                         var tmp = Expression();
  23.                         if (TokType != TokenType.RParam)
  24.                             throw new ApplicationException("Ожидается )");
  25.                         NextToken();
  26.                         return tmp;
  27.                     }
  28.                     case TokenType.Number:
  29.                     {
  30.                         var tmp = new IntConstExpression(_token.Value) {Type = _token.Modifer};
  31.                         NextToken();
  32.                         return tmp;
  33.                     }
  34.                     case TokenType.CharsString:
  35.                     case TokenType.String:
  36.                     {
  37.                         var tmp = new StringConstExpression(_token.Value);
  38.                         NextToken();
  39.                         return tmp;
  40.                     }
  41.                     case TokenType.Identifer:
  42.                     {
  43.                         var tmp = new IdentConstExpression(_token.Value);
  44.                         NextToken();
  45.                         return tmp;
  46.                     }
  47.                 }
  48.  
  49.                 throw new ApplicationException("Неверное выражение");
  50.             };
  51.  
  52.             var mulExpr = Expr(
  53.                 (t, k) => t == TokenType.Mul || t == TokenType.Div || t == TokenType.Mod,
  54.                 (t, k) =>
  55.                     t == TokenType.Mul
  56.                         ? "MUL"
  57.                         : t == TokenType.Div ? "DIV" : "MOD",
  58.                 unaryExpr);
  59.  
  60.             var addExpr = Expr(
  61.                 (t, k) => TokType == TokenType.Plus || TokType == TokenType.Minus,
  62.                 (t, k) => t == TokenType.Equal ? "PLUS" : "MINUS",
  63.                 mulExpr);
  64.  
  65.             var shiftExpr = Expr(
  66.                 (t, k) =>
  67.                     t == TokenType.ShiftLeft || t == TokenType.ShiftRight ||
  68.                     t == TokenType.UnsignedShiftRight || k == "shl" || k == "shr",
  69.                 (t, k) =>
  70.                     t == TokenType.ShiftLeft
  71.                         ? "SH_LEFT"
  72.                         : t == TokenType.ShiftRight ? "SH_RIGHT" : "USH_RIGHT",
  73.                 addExpr);
  74.  
  75.             var relExpr = Expr(
  76.                 (t, k) =>
  77.                     t == TokenType.Less || t == TokenType.LessOrEqual ||
  78.                     t == TokenType.Greater || t == TokenType.GreaterOrEqual,
  79.                 (t, k) =>
  80.                     t == TokenType.Less
  81.                         ? "LESS"
  82.                         : t == TokenType.LessOrEqual
  83.                             ? "EQ_LESS"
  84.                             : t == TokenType.Greater ? "GREAT" : "GREAT_EQ",
  85.                 shiftExpr);
  86.  
  87.             var eqExpr = Expr(
  88.                 (t, k) => t == TokenType.Equal || t == TokenType.NotEqual,
  89.                 (t, k) => t == TokenType.Equal ? "EQ" : "NOT_EQ",
  90.                 relExpr);
  91.  
  92.             var bitXorExpr = Expr(
  93.                 (t, k) => t == TokenType.BitXor || k == "xor",
  94.                 (t, k) => "B_XOR",
  95.                 eqExpr);
  96.  
  97.             var bitAndExpr = Expr(
  98.                 (t, k) => t == TokenType.BitOr || k == "or",
  99.                 (t, k) => "B_AND",
  100.                 bitXorExpr);
  101.  
  102.             var bitOrExpr = Expr(
  103.                 (t, k) => t == TokenType.BitOr || k == "or",
  104.                 (t, k) => "B_OR",
  105.                 bitAndExpr);
  106.  
  107.             var logAndExpr = Expr(
  108.                 (t, k) => t == TokenType.LogicalAnd,
  109.                 (t, k) => "AND",
  110.                 bitOrExpr);
  111.  
  112.             var logOrExpr = Expr(
  113.                 (t, k) => t == TokenType.LogicalOr,
  114.                 (t, k) => "OR",
  115.                 logAndExpr);
  116.  
  117.             var minMaxExpr = Expr(
  118.                 (t, k) => t == TokenType.Minimum || t == TokenType.Maximum,
  119.                 (t, k) => t == TokenType.Maximum ? "MAX" : "MIX",
  120.                 logOrExpr);
  121.  
  122.             return minMaxExpr();
  123.         }
  124.        
  125.         private Func<Expression> Expr(Func<TokenType, string, bool> condition, Func<TokenType, string, string> op , Func<Expression> nextOp)
  126.         {
  127.             return delegate
  128.             {
  129.                 var left = nextOp();
  130.  
  131.                 while (TokType != TokenType.EndFile)
  132.                 {
  133.                     var tt = TokType;
  134.                     var kw = Keyword;
  135.  
  136.                     if (condition(tt, kw))
  137.                     {
  138.                        
  139.                         NextToken();
  140.                         left = new AST.Exprs.BinaryExpression(op(tt, kw))
  141.                         {
  142.                             Left = left,
  143.                             Right = nextOp()
  144.                         };
  145.                         continue;
  146.                     }
  147.                     break;
  148.                 }
  149.  
  150.                 return left;
  151.             };
  152.         }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement