Quick Search:

Mode

Context

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

Other Diffs

Ignore

Blank Lines Whitespace: Expand:

Diff

1.92
 
1.93
 
MAIN:ragge:20030912143253
 
trees.c
_>358358                         break;
 359359 
 360360                 case UNARY MUL:
<>361 -                        if (l->n_op == UNARY AND) {
  361+                        if (l->n_op == ADDROF) {
362362                                 nfree(p);
 363363                                 p = l->n_left;
 364364                                 nfree(l);
     
 !
370370                         p->n_sue = l->n_sue;
 371371                         break;
 372372 
<>373 -                case UNARY AND:
  373+                case ADDROF:
374374                         switch( l->n_op ){
 375375 
 376376                         case UNARY MUL:
     
 !
386386 
 387387                         case COMOP:
 388388                                 nfree(p);
<>389 -                                lr = buildtree(UNARY AND, l->n_right, NIL);
  389+                                lr = buildtree(ADDROF, l->n_right, NIL);
390390                                 p = buildtree( COMOP, l->n_left, lr );
 391391                                 nfree(l);
 392392                                 break;
 393393 
 394394                         case QUEST:
<>395 -                                lr = buildtree( UNARY AND, l->n_right->n_right, NIL );
 396 -                                ll = buildtree( UNARY AND, l->n_right->n_left, NIL );
  395+                                lr = buildtree( ADDROF, l->n_right->n_right, NIL );
  396+                                ll = buildtree( ADDROF, l->n_right->n_left, NIL );
397397                                 nfree(p); nfree(l->n_right);
 398398                                 p = buildtree( QUEST, l->n_left, buildtree( COLON, ll, lr ) );
 399399                                 nfree(l);
     
 !
429429                                 if (l->n_sue != r->n_sue)
 430430                                         uerror("assignment of different structures");
 431431 
<>432 -                                r = buildtree(UNARY AND, r, NIL);
  432+                                r = buildtree(ADDROF, r, NIL);
433433                                 t = r->n_type;
 434434                                 d = r->n_df;
 435435                                 sue = r->n_sue;
     
 !
465465                         p->n_type = DECREF(p->n_type);
 466466                         p->n_df = l->n_df;
 467467                         p->n_sue = l->n_sue;
<>468 -                        if (l->n_op == UNARY AND && l->n_left->n_op == NAME &&
  468+                        if (l->n_op == ADDROF && l->n_left->n_op == NAME &&
469469                             l->n_left->n_sp != NULL && l->n_left->n_sp != NULL &&
 470470                             (l->n_left->n_sp->sclass == FORTRAN ||
 471471                             l->n_left->n_sp->sclass == UFORTRAN)) {
     
 !
523523 
 524524         if( p->n_type == STRTY || p->n_type == UNIONTY ){
 525525                 p = block(STARG, p, NIL, p->n_type, p->n_df, p->n_sue);
<>526 -                p->n_left = buildtree( UNARY AND, p->n_left, NIL );
  526+                p->n_left = buildtree( ADDROF, p->n_left, NIL );
527527                 p = clocal(p);
 528528                 }
 529529         return( p );
     
 !
957957         if( ISARY( p->n_type) ){
 958958                 p->n_type = DECREF( p->n_type );
 959959                 ++p->n_df;
<>960 -                return( buildtree( UNARY AND, p, NIL ) );
  960+                return( buildtree( ADDROF, p, NIL ) );
961961         }
 962962         if( ISFTN( p->n_type) )
<>963 -                return( buildtree( UNARY AND, p, NIL ) );
  963+                return( buildtree( ADDROF, p, NIL ) );
964964 
 965965         return( p );
 966966         }
     
 !
13121312                 if( mt1 & MINT ) return( TYPL );
 13131313                 break;
 13141314 
<>1315 -        case UNARY AND:
  1315+        case ADDROF:
13161316                 return( NCVT+OTHER );
 13171317         case NOT:
 13181318         case INIT:
     
 !
21402140         SNAM(NOT,!)
 21412141         SNAM(CAST,CAST)
 21422142         SNAM(STRING,STRING)
<> 2143+        SNAM(ADDROF,U&)
21432144         default:
 21442145                 cerror("bad copst %d", op);
 21452146         }
     
 !
21722173                 return UTYPE|LOGFLG;
 21732174         case CAST:
 21742175                 return BITYPE|ASGFLG|ASGOPFLG;
<> 2176+        case ADDROF:
  2177+                return UTYPE;
<_21752178         }
 21762179         return 0; /* XXX gcc */
 21772180 }
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-21 18:18 +0100