开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 编译器/解释器 > 查看源码
pexpr.c.3
资源名称：pascal2c.tar.Z　[点击查看]
上传用户：upcnvip
上传日期：2007-01-06
资源大小：474k
文件大小：8k
源码类别：

编译器/解释器

开发平台：

C/C++

pexpr.c.3：源码内容
  1.             setprec2(10);
  2.     checkbreak(breakbeforerel);
  3.             wrexpr(ex->args[0], incompat(ex, 0, subprec));
  4.             outop(">");
  5.             wrexpr(ex->args[1], incompat(ex, 0, subprec));
  6.             break;
  8.         case EK_LE:
  9.             setprec2(10);
  10.     checkbreak(breakbeforerel);
  11.             wrexpr(ex->args[0], incompat(ex, 0, subprec));
  12.             outop("<=");
  13.             wrexpr(ex->args[1], incompat(ex, 0, subprec));
  14.             break;
  16.         case EK_GE:
  17.             setprec2(10);
  18.     checkbreak(breakbeforerel);
  19.             wrexpr(ex->args[0], incompat(ex, 0, subprec));
  20.             outop(">=");
  21.             wrexpr(ex->args[1], incompat(ex, 0, subprec));
  22.             break;
  24.         case EK_EQ:
  25.             setprec2(9);
  26.     checkbreak(breakbeforerel);
  27.             wrexpr(ex->args[0], incompat(ex, 0, subprec));
  28.             outop("==");
  29.             wrexpr(ex->args[1], incompat(ex, 0, subprec));
  30.             break;
  32.         case EK_NE:
  33.             setprec2(9);
  34.     checkbreak(breakbeforerel);
  35.             wrexpr(ex->args[0], incompat(ex, 0, subprec));
  36.             outop("!=");
  37.             wrexpr(ex->args[1], incompat(ex, 0, subprec));
  38.             break;
  40.         case EK_BAND:
  41.             setprec3(8);
  42.     if (ex->val.type == tp_boolean)
  43. checkbreak(breakbeforelog);
  44.     else
  45. checkbreak(breakbeforearith);
  46.             wrexpr(ex->args[0], incompat(ex, 0, subprec-1));
  47.     outop("&");
  48.             wrexpr(ex->args[1], incompat(ex, 1, subprec-1));
  49.             break;
  51.         case EK_BXOR:
  52.             setprec3(7);
  53.     checkbreak(breakbeforearith);
  54.             wrexpr(ex->args[0], incompat(ex, 0, subprec-1));
  55.             outop("^");
  56.             wrexpr(ex->args[1], incompat(ex, 1, subprec-1));
  57.             break;
  59.         case EK_BOR:
  60.             setprec3(6);
  61.     if (ex->val.type == tp_boolean)
  62. checkbreak(breakbeforelog);
  63.     else
  64. checkbreak(breakbeforearith);
  65.             wrexpr(ex->args[0], incompat(ex, 0, subprec-1));
  66.     outop("|");
  67.             wrexpr(ex->args[1], incompat(ex, 1, subprec-1));
  68.             break;
  70.         case EK_AND:
  71.             setprec3(5);
  72.     checkbreak(breakbeforelog);
  73.     wrexpr(ex->args[0], incompat(ex, 0, subprec-1));
  74.             outop("&&");
  75.     wrexpr(ex->args[1], incompat(ex, 1, subprec-1));
  76.             break;
  78.         case EK_OR:
  79.             setprec3(4);
  80.     checkbreak(breakbeforelog);
  81.     wrexpr(ex->args[0], incompat(ex, 0, subprec-1));
  82.             outop("||");
  83.     wrexpr(ex->args[1], incompat(ex, 1, subprec-1));
  84.             break;
  86.         case EK_COND:
  87.             setprec3(3);
  88.     i = 0;
  89.     for (;;) {
  90. i++;
  91. if (extraparens != 0)
  92.     wrexpr(ex->args[0], 15);
  93. else
  94.     wrexpr(ex->args[0], subprec);
  95. NICESPACE();
  96. output("02?");
  97. NICESPACE();
  98. out_expr(ex->args[1]);
  99. if (ex->args[2]->kind == EK_COND) {
  100.     NICESPACE();
  101.     output("02:");
  102.     NICESPACE();
  103.     ex = ex->args[2];
  104. } else {
  105.     NICESPACE();
  106.     output((i == 1) ? "17:" : "02:");
  107.     NICESPACE();
  108.     wrexpr(ex->args[2], subprec-1);
  109.     break;
  110. }
  111.     }
  112.             break;
  114.         case EK_ASSIGN:
  115.             if (ex->args[1]->kind == EK_PLUS &&
  116.                 exprsame(ex->args[1]->args[0], ex->args[0], 2) &&
  117.                 ex->args[1]->args[1]->kind == EK_CONST &&
  118.                 ex->args[1]->args[1]->val.type->kind == TK_INTEGER &&
  119.                 abs(ex->args[1]->args[1]->val.i) == 1) {
  120. if (prec == 0 && postincrement) {
  121.     setprec(15);
  122.     wrexpr(ex->args[0], subprec);
  123.     EXTRASPACE();
  124.     if (ex->args[1]->args[1]->val.i == 1)
  125. output("++");
  126.     else
  127. output("--");
  128. } else {
  129.     setprec(14);
  130.     if (ex->args[1]->args[1]->val.i == 1)
  131. output("++");
  132.     else
  133. output("--");
  134.     EXTRASPACE();
  135.     wrexpr(ex->args[0], subprec-1);
  136. }
  137.             } else {
  138.                 setprec2(2);
  139. checkbreak(breakbeforeassign);
  140.                 wrexpr(ex->args[0], subprec);
  141.                 ex2 = copyexpr(ex->args[1]);
  142.                 j = -1;
  143.                 switch (ex2->kind) {
  145.                     case EK_PLUS:
  146.                     case EK_TIMES:
  147.                     case EK_BAND:
  148.                     case EK_BOR:
  149.                     case EK_BXOR:
  150.                         for (i = 0; i < ex2->nargs; i++) {
  151.                             if (exprsame(ex->args[0], ex2->args[i], 2)) {
  152.                                 j = i;
  153.                                 break;
  154.                             }
  155.                             if (ex2->val.type->kind == TK_REAL)
  156.                                 break;   /* non-commutative */
  157.                         }
  158.                         break;
  160.                     case EK_DIVIDE:
  161.                     case EK_DIV:
  162.                     case EK_MOD:
  163.                     case EK_LSH:
  164.                     case EK_RSH:
  165.                         if (exprsame(ex->args[0], ex2->args[0], 2))
  166.                             j = 0;
  167.                         break;
  169.     default:
  170. break;
  171.                 }
  172.                 if (j >= 0) {
  173.                     if (ex2->nargs == 2)
  174.                         ex2 = grabarg(ex2, 1-j);
  175.                     else
  176.                         delfreearg(&ex2, j);
  177.                     switch (ex->args[1]->kind) {
  179.                         case EK_PLUS:
  180.                             if (expr_looks_neg(ex2)) {
  181.                                 outop("-=");
  182.                                 ex2 = makeexpr_neg(ex2);
  183.                             } else
  184.                                 outop("+=");
  185.                             break;
  187.                         case EK_TIMES:
  188.                             outop("*=");
  189.                             break;
  191.                         case EK_DIVIDE:
  192.                         case EK_DIV:
  193.                             outop("/=");
  194.                             break;
  196.                         case EK_MOD:
  197.                             outop("%=");
  198.                             break;
  200.                         case EK_LSH:
  201.                             outop("<<=");
  202.                             break;
  204.                         case EK_RSH:
  205.                             outop(">>=");
  206.                             break;
  208.                         case EK_BAND:
  209.                             outop("&=");
  210.                             break;
  212.                         case EK_BOR:
  213.                             outop("|=");
  214.                             break;
  216.                         case EK_BXOR:
  217.                             outop("^=");
  218.                             break;
  220. default:
  221.     break;
  222.                     }
  223.                 } else {
  224.     output(" ");
  225.     outop3(breakbeforeassign, "=");
  226.     output(" ");
  227.                 }
  228.                 if (extraparens != 0 &&
  229.                     (ex2->kind == EK_EQ || ex2->kind == EK_NE ||
  230.                      ex2->kind == EK_GT || ex2->kind == EK_LT ||
  231.                      ex2->kind == EK_GE || ex2->kind == EK_LE ||
  232.                      ex2->kind == EK_AND || ex2->kind == EK_OR))
  233.                     wrexpr(ex2, 16);
  234.                 else
  235.                     wrexpr(ex2, subprec-1);
  236.                 freeexpr(ex2);
  237.             }
  238.             break;
  240.         case EK_COMMA:
  241.             setprec3(1);
  242.             for (i = 0; i < ex->nargs-1; i++) {
  243.                 wrexpr(ex->args[i], subprec);
  244.                 output(",02");
  245.                 NICESPACE();
  246.             }
  247.             wrexpr(ex->args[ex->nargs-1], subprec);
  248.             break;
  250.         default:
  251.             intwarning("wrexpr", "bad ex->kind [311]");
  252.     }
  253.     switch (parens) {
  254.       case 1:
  255.         output(")");
  256. break;
  257.       case 2:
  258. output("04");
  259. break;
  260.     }
  261. }
  265. /* will parenthesize assignments and "," operators */
  267. void out_expr(ex)
  268. Expr *ex;
  269. {
  270.     wrexpr(ex, 2);
  271. }
  275. /* will not parenthesize anything at top level */
  277. void out_expr_top(ex)
  278. Expr *ex;
  279. {
  280.     wrexpr(ex, 0);
  281. }
  285. /* will parenthesize unless only writing a factor */
  287. void out_expr_factor(ex)
  288. Expr *ex;
  289. {
  290.     wrexpr(ex, 15);
  291. }
  295. /* will parenthesize always */
  297. void out_expr_parens(ex)
  298. Expr *ex;
  299. {
  300.     output("(");
  301.     wrexpr(ex, 1);
  302.     output(")");
  303. }
  307. /* evaluate expression for side effects only */
  308. /* no top-level parentheses */
  310. void out_expr_stmt(ex)
  311. Expr *ex;
  312. {
  313.     wrexpr(ex, 0);
  314. }
  318. /* evaluate expression for boolean (zero/non-zero) result only */
  319. /* parenthesizes like out_expr() */
  321. void out_expr_bool(ex)
  322. Expr *ex;
  323. {
  324.     wrexpr(ex, 2);
  325. }
  330. /* End. */