Quick Search:

Mode

Context

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

Other Diffs

Ignore

Blank Lines Whitespace: Expand:

Diff

1.18
 
1.19
 
MAIN:ragge:20030703135351
 
reader.c
_>3838         if (lflag)
 3939                 lineid(lineno, ftitle);
 4040 
<>41 -        if (p->n_op == LABEL)
 42 -                cerror("p2compile");
 43 -
4441         tmpoff = baseoff/* expression at top level reuses temps */
 4542         /* generate code for the tree p */
 4643 # ifndef BUG4
     
 !
174171                 { register NODE *q;
 175172                         q = p->n_right;
 176173                         ncopy( p, p->n_right );
<>177 -                        q->n_op = FREE;
 178 -                        }
  174+                        nfree(q);
  175+                }
179176                 return( 1 );
 180177         }
 181178 
     
 !
222219                                 register NODE *q;
 223220                                 deltrees[deli++] = tcopy(p);
 224221                                 q = p->n_left;
<>225 -                                p->n_right->n_op = FREE/* zap constant */
  222+                                nfree(p->n_right)/* zap constant */
226223                                 ncopy( p, q );
<>227 -                                q->n_op = FREE;
  224+                                nfree(q);
228225                                 return;
 229226                                 }
 230227                         }
     
 !
346343         again:
 347344 
 348345         if (p->n_op == FREE)
<>349 -                return;         /* whole tree was done */
  346+                cerror("order");        /* whole tree was done */
350347         cookie = cook;
 351348         rcount();
 352349         canon(p);
     
 !
442439                 p2->n_rall = p->n_rall;
 443440                 codgen( p2, cookie );
 444441                 ncopy( p, p2 );
<>445 -                p2->n_op = FREE;
  442+                nfree(p2);
446443                 goto cleanup;
 447444 
 448445         case FORCE:
 449446                 /* recurse, letting the work be done by rallo */
<>450 -                p = p->n_left;
451447                 cook = INTAREG|INTBREG;
<> 448+                order(p->n_left, cook);
  449+                reclaim(p, RLEFT, cook);
452450                 goto again;
 453451 
 454452         case CBRANCH:
 455453                 o = p2->n_lval;
 456454                 cbranch( p1, -1, o );
<>457 -                p2->n_op = FREE;
 458 -                p->n_op = FREE;
  455+                nfree(p2);
  456+                nfree(p);
459457                 return;
 460458 
 461459         case QUEST:
     
 !
474472                 p->n_rval = p2->n_right->n_rval;
 475473                 p->n_type = p2->n_right->n_type;
 476474                 tfree( p2->n_right );
<>477 -                p2->n_op = FREE;
  475+                nfree(p2);
478476                 goto cleanup;
 479477 
 480478         case ANDAND:
     
 !
535533                 if( cook == FOREFF ){
 536534                         /* do nothing */
 537535                         order( p->n_left, FOREFF );
<>538 -                        p->n_op = FREE;
  536+                        nfree(p);
539537                         return;
<>540 -                        }
  538+                }
541539 #ifdef R2REGS
 542540                 /* try to coax a tree into a doubly indexed OREG */
 543541                 p1 = p->n_left;
     
 !
880878                 cbranch( p->n_left, -1, lab );
 881879                 cbranch( p->n_right, true, false );
 882880                 if( false < 0 ) deflab( lab );
<>883 -                p->n_op = FREE;
  881+                nfree(p);
884882                 return;
 885883 
 886884         case OROR:
 887885                 lab = true<0 ? getlab() : true;
 888886                 cbranch( p->n_left, lab, -1 );
 889887                 cbranch( p->n_right, true, false );
 890888                 if( true < 0 ) deflab( lab );
<>891 -                p->n_op = FREE;
  889+                nfree(p);
892890                 return;
 893891 
 894892         case NOT:
 895893                 cbranch( p->n_left, false, true );
<>896 -                p->n_op = FREE;
  894+                nfree(p);
897895                 break;
 898896 
 899897         case COMOP:
 900898                 codgen( p->n_left, FOREFF );
<>901 -                p->n_op = FREE;
  899+                nfree(p);
902900                 cbranch( p->n_right, true, false );
 903901                 return;
 904902 
     
 !
911909                 cbranch( p->n_right->n_right, true, false );
 912910                 if( true < 0 ) deflab( tlab);
 913911                 if( false < 0 ) deflab( flab );
<>914 -                p->n_right->n_op = FREE;
 915 -                p->n_op = FREE;
  912+                nfree(p->n_right);
  913+                nfree(p);
916914                 return;
 917915 
 918916         case ICON:
     
 !
923921                                 if( true>=0 ) cbgen( 0, true, 'I' );
 924922                                 }
 925923                         else if( false>=0 ) cbgen( 0, false, 'I' );
<>926 -                        p->n_op = FREE;
  924+                        nfree(p);
927925                         return;
<>928 -                        }
  926+                }
<_929927                 /* fall through to default with other strange constants */
 930928 
 931929         default:
FishEye: Open Source License registered to PCC.
Your maintenance has expired. You can renew your license at http://www.atlassian.com/fisheye/renew
Atlassian FishEye, CVS analysis. (Version:1.6.3 Build:build-336 2008-11-04) - Administration - Page generated 2014-07-10 15:02 +0200