Quick Search:

Mode

Context

Displaying 3 lines of context. None | Less | More | Full

Other Diffs

Ignore

Blank Lines Whitespace: Expand:

Diff

1.66
 
1.67
 
MAIN:ragge:20030912145329
 
reader.c
_>137137                  * inside of a call */
 138138                 return;
 139139 
<>140 -        case UNARY MUL:
  140+        case UMUL:
141141                 /* if *p++, do not rewrite */
 142142                 if( autoincr( p ) ) return;
 143143                 break;
     
 !
345345 //printf("foo\n");
 346346 //fwalk(p, e2print, 0);
 347347                 if (!canaddr(p->n_left)) {
<>348 -                        if (p->n_left->n_op == UNARY MUL) {
  348+                        if (p->n_left->n_op == UMUL) {
349349                                 offstar(p->n_left->n_left);
 350350                                 goto again;
 351351                         }
     
 !
354354 //printf("foo1\n");
 355355 //fwalk(p, e2print, 0);
 356356                 if (!canaddr(p->n_right)) {
<>357 -                        if (p->n_right->n_op == UNARY MUL) {
  357+                        if (p->n_right->n_op == UMUL) {
358358                                 offstar(p->n_right->n_left);
 359359                                 goto again;
 360360                         }
     
 !
396396                  */
 397397 //printf("newstyle node %p\n", p);
 398398                 if (!canaddr(p->n_left)) {
<>399 -                        if (p->n_left->n_op == UNARY MUL) {
  399+                        if (p->n_left->n_op == UMUL) {
400400                                 offstar(p->n_left->n_left);
 401401                                 goto again;
 402402                         }
 403403                         order(p->n_left, INTAREG|INTBREG);
 404404                 }
 405405 //printf("newstyle addrl %p\n", p);
 406406                 if (!canaddr(p->n_right)) {
<>407 -                        if (p->n_right->n_op == UNARY MUL) {
  407+                        if (p->n_right->n_op == UMUL) {
408408                                 offstar(p->n_right->n_left);
 409409                                 goto again;
 410410                         }
     
 !
423423                         goto nomat;
 424424                 }
 425425                 if (rv & LREG) {
<>426 -                        if (p->n_left->n_op == UNARY MUL) {
  426+                        if (p->n_left->n_op == UMUL) {
427427                                 offstar(p->n_left->n_left);
 428428                                 goto again;
 429429                         }
 430430                         order(p->n_left, INTAREG|INTBREG);
 431431                 }
 432432 //printf("newstyle ltmp %p\n", p);
 433433                 if (rv & RREG) {
<>434 -                        if (p->n_right->n_op == UNARY MUL) {
  434+                        if (p->n_right->n_op == UMUL) {
435435                                 offstar(p->n_right->n_left);
 436436                                 goto again;
 437437                         }
     
 !
478478         case UGT:
 479479 
 480480                 if (!canaddr(p->n_left)) {
<>481 -                        if (p->n_left->n_op == UNARY MUL) {
  481+                        if (p->n_left->n_op == UMUL) {
482482                                 offstar(p->n_left->n_left);
 483483                                 goto again;
 484484                         }
 485485                         order(p->n_left, INTAREG|INTBREG|INAREG|INBREG);
 486486                 }
 487487                 if (!canaddr(p->n_right)) {
<>488 -                        if (p->n_right->n_op == UNARY MUL) {
  488+                        if (p->n_right->n_op == UMUL) {
489489                                 offstar(p->n_right->n_left);
 490490                                 goto again;
 491491                         }
     
 !
563563                 return;
 564564 
 565565         case FLD:       /* fields of funny type */
<>566 -                if ( p1->n_op == UNARY MUL ){
  566+                if ( p1->n_op == UMUL ){
567567                         offstar( p1->n_left );
 568568                         goto again;
 569569                         }
 570570 
<>571 -        case UNARY MINUS:
  571+        case UMINUS:
572572                 order( p1, INBREG|INAREG);
 573573                 goto again;
 574574 
     
 !
606606                 /* if arguments are passed in register, care must be taken that reclaim
 607607                  * not throw away the register which now has the result... */
 608608 
<>609 -        case UNARY MUL:
  609+        case UMUL:
610610                 if( cook == FOREFF ){
 611611                         /* do nothing */
 612612                         order( p->n_left, FOREFF );
     
 !
706706                 ++callflag;
 707707                 break;
 708708 
<>709 -        case UNARY MUL:
  709+        case UMUL:
710710                 if (asgop(p->n_left->n_op))
<>711 -                        stoasg(p->n_left, UNARY MUL);
  711+                        stoasg(p->n_left, UMUL);
712712                 break;
 713713 
 714714         case CALL:
     
 !
995995         if (Oflag == 0)
 996996                 deltemp(p);
 997997 
<>998 -        if (p->n_op == UNARY MUL) {
  998+        if (p->n_op == UMUL) {
<_999999                 q = p->n_left;
 10001000                 if (q->n_op == REG) {
 10011001                         temp = q->n_lval;
FishEye: Open Source License registered to PCC.
Atlassian FishEye, CVS analysis. (Version:1.6.3 Build:build-336 2008-11-04) - Administration - Page generated 2014-12-22 08:47 +0100