Quick Search:

Mode

Context

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

Other Diffs

Ignore

Blank Lines Whitespace: Expand:

Diff

1.73
 
1.74
 
MAIN:ragge:20030703135351
 
pftn.c
_>3030 #define ISSTR(ty) (ty == STRTY || ty == UNIONTY || ty == ENUMTY)
 3131 #define ISSOU(ty) (ty == STRTY || ty == UNIONTY)
 3232 #define MKTY(p, t, d, s) r = talloc(); *r = *p; \
<>33 -        r = argcast(r, t, d, s); *p = *r; r->n_op = FREE;
  33+        r = argcast(r, t, d, s); *p = *r; nfree(r);
3434 
 3535 /*
 3636  * Info stored for delaying string printouts.
     
 !
582582 
 583583         case UNDEF:
 584584         def:
<>585 -                q = block(FREE, NIL, NIL, 0, 0, 0);
  585+                q = block(NAME, NIL, NIL, 0, 0, 0);
586586                 q->n_sp = p;
 587587                 q->n_type = (soru&INSTRUCT) ? STRTY :
 588588                     ((soru&INUNION) ? UNIONTY : ENUMTY);
 589589                 defid(q, (soru&INSTRUCT) ? STNAME :
 590590                     ((soru&INUNION) ? UNAME : ENAME));
<> 591+                nfree(q);
591592                 break;
 592593 
 593594         case STRTY:
     
 !
616617 {
 617618         NODE *q;
 618619 
<>619 -        q = block(FREE, NIL, NIL, MOETY, 0, 0);
  620+        q = block(NAME, NIL, NIL, MOETY, 0, 0);
620621         q->n_sp = lookup(name, 0);
 621622         defid(q, MOE);
<> 623+        nfree(q);
622624 }
 623625 
 624626 /*
     
 !
643645 
 644646         strucoff = 0;
 645647         instruct = soru;
<>646 -        q = block(FREE, NIL, NIL, 0, 0, 0);
  648+        q = block(NAME, NIL, NIL, 0, 0, 0);
647649         q->n_sp = s;
 648650         if (instruct==INSTRUCT) {
 649651                 strunem = MOS;
     
 !
663665         }
 664666         r->rsym = q->n_sp;
 665667         r->rlparam = lparam;
<> 668+        nfree(q);
666669 
 667670         return r;
 668671 }
     
 !
14161419 
 14171420         u = block(NAME, NIL,NIL, t, d, sue);
 14181421         p = buildtree( ASSIGN, u, p );
<>1419 -        p->n_left->n_op = FREE;
  1422+        nfree(p->n_left);
14201423         p->n_left = p->n_right;
 14211424         p->n_right = NIL;
 14221425         p->n_left = optim( p->n_left );
 14231426         o = p->n_left->n_op;
 14241427         if( o == UNARY AND ){
<>1425 -                o = p->n_left->n_op = FREE;
 1426 -                p->n_left = p->n_left->n_left;
 1427 -                }
  1428+                NODE *l = p->n_left->n_left;
  1429+                nfree(p->n_left);
  1430+                p->n_left = l;
  1431+        }
14281432         p->n_op = INIT;
 14291433 
 14301434         if( sz < SZINT ){ /* special case: bit fields, etc. */
     
 !
18681872 NODE *
 18691873 typenode(NODE *p)
 18701874 {
<> 1875+        NODE *l;
18711876         int class = 0, adj, noun, sign;
 18721877 
 18731878         adj = INT;      /* INT, LONG or SHORT */
     
 !
18761881 
 18771882         /* Remove initial QUALIFIERs */
 18781883         if (p && p->n_op == QUALIFIER) {
<>1879 -                p->n_op = FREE;
 1880 -                p = p->n_left;
  1884+                l = p->n_left;
  1885+                nfree(p);
  1886+                p = l;
18811887         }
 18821888 
 18831889         /* Handle initial classes special */
 18841890         if (p && p->n_op == CLASS) {
 18851891                 class = p->n_type;
<>1886 -                p->n_op = FREE;
 1887 -                p = p->n_left;
  1892+                l = p->n_left;
  1893+                nfree(p);
  1894+                p = l;
18881895         }
 18891896 
 18901897         /* Remove more QUALIFIERs */
 18911898         if (p && p->n_op == QUALIFIER) {
<>1892 -                p->n_op = FREE;
 1893 -                p = p->n_left;
  1899+                l = p->n_left;
  1900+                nfree(p);
  1901+                p = l;
18941902         }
 18951903 
 18961904         if (p && p->n_op == TYPE && p->n_left == NIL) {
     
 !
19421950                         goto bad;
 19431951                 }
 19441952         next:
<>1945 -                p->n_op = FREE;
 1946 -                p = p->n_left;
  1953+                l = p->n_left;
  1954+                nfree(p);
  1955+                p = l;
19471956         }
 19481957 
 19491958 #ifdef CHAR_UNSIGNED
     
 !
19972006 NODE *
 19982007 tymerge(NODE *typ, NODE *idp)
 19992008 {
<> 2009+        NODE *p;
20002010         union dimfun *j;
 20012011         struct tylnk *base, tylnk, *tylkp;
 20022012         unsigned int t;
 20032013         int ntdim, i;
 20042014 
 20052015         if (typ->n_op != TYPE)
 20062016                 cerror("tymerge: arg 1");
<>2007 -        if (idp == NIL)
 2008 -                return(NIL);
20092017 
 20102018 #ifdef PCC_DEBUG
 20112019         if (ddebug > 2) {
     
 !
20452053         if ((t = BTYPE(idp->n_type)) != STRTY && t != UNIONTY && t != ENUMTY)
 20462054                 idp->n_sue = MKSUE(t);
 20472055 
<> 2056+        if (idp->n_op != NAME) {
  2057+                for (p = idp->n_left; p->n_op != NAME; p = p->n_left)
  2058+                        nfree(p);
  2059+                nfree(p);
  2060+                idp->n_op = NAME;
  2061+        }
  2062+
20482063         return(idp);
 20492064 }
 20502065 
     
 !
21362151         unsigned int t;
 21372152 
 21382153         o = p->n_op;
<>2139 -        p->n_op = FREE;
 2140 -
21412154         if (o == NAME)
 21422155                 return;
 21432156 
     
 !
21582171                         o = RB;
 21592172                 } else {
 21602173                         dim.ddim = p->n_right->n_lval;
<>2161 -                        p->n_right->n_op = FREE;
  2174+                        nfree(p->n_right);
21622175                         if (dim.ddim == 0 && p->n_left->n_op == LB)
 21632176                                 uerror("null dimension");
 21642177                 }
     
 !
21912204         r->n_sue = sue;
 21922205 
 21932206         u = buildtree(CAST, r, p);
<>2194 -        u->n_left->n_op = FREE;
 2195 -        u->n_op = FREE;
 2196 -        return u->n_right;
  2207+        nfree(u->n_left);
  2208+        r = u->n_right;
  2209+        nfree(u);
  2210+        return r;
<_21972211 }
 21982212 
 21992213 
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-09-23 10:20 +0200