Quick Search:

Mode

Context

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

Other Diffs

Ignore

Blank Lines Whitespace: Expand:

Diff

1.21
 
1.22
 
MAIN:ragge:20100919135727
 
local.c
_>7676                  */
 7777                 if (p->n_type == PTR+VOID)
 7878                         isptrvoid = 1;
<>79 -                r = tempnode(0, p->n_type, p->n_df, p->n_sue);
  79+                r = tempnode(0, p->n_type, p->n_df, p->n_ap);
8080                 tmpnr = regno(r);
<>81 -                r = block(ASSIGN, r, p, p->n_type, p->n_df, p->n_sue);
  81+                r = block(ASSIGN, r, p, p->n_type, p->n_df, p->n_ap);
8282 
<>83 -                p = tempnode(tmpnr, r->n_type, r->n_df, r->n_sue);
  83+                p = tempnode(tmpnr, r->n_type, r->n_df, r->n_ap);
8484                 if (isptrvoid) {
 8585                         p = block(PCONV, p, NIL, PTR+VOID,
<>86 -                            p->n_df, MKSUE(PTR+VOID));
  86+                            p->n_df, MKAP(PTR+VOID));
8787                 }
 8888                 p = buildtree(COMOP, r, p);
 8989                 break;
     
 !
124124                 if (p->n_type != CHAR && p->n_type != UCHAR &&
 125125                     p->n_type != SHORT && p->n_type != USHORT)
 126126                         break;
<>127 -                p->n_left = block(SCONV, p->n_left, NIL, INT, 0, MKSUE(INT));
  127+                p->n_left = block(SCONV, p->n_left, NIL, INT, 0, MKAP(INT));
128128                 p->n_type = INT;
<>129 -                p->n_sue = MKSUE(INT);
  129+                p->n_ap = MKAP(INT);
130130                 p->n_rval = SZINT;
 131131                 break;
 132132 
     
 !
174174                 if (l->n_type < INT || DEUNSIGN(l->n_type) == LONGLONG) {
 175175                         /* float etc? */
 176176                         p->n_left = block(SCONV, l, NIL,
<>177 -                            UNSIGNED, 0, MKSUE(UNSIGNED));
  177+                            UNSIGNED, 0, MKAP(UNSIGNED));
178178                         break;
 179179                 }
 180180                 /* if left is SCONV, cannot remove */
     
 !
193193         delp:   l->n_type = p->n_type;
 194194                 l->n_qual = p->n_qual;
 195195                 l->n_df = p->n_df;
<>196 -                l->n_sue = p->n_sue;
  196+                l->n_ap = p->n_ap;
197197                 nfree(p);
 198198                 p = l;
 199199                 break;
     
 !
208208                 }
 209209 
 210210                 if ((p->n_type & TMASK) == 0 && (l->n_type & TMASK) == 0 &&
<>211 -                    btdims[p->n_type].suesize == btdims[l->n_type].suesize) {
  211+                    btattr[p->n_type].atypsz == btattr[l->n_type].atypsz) {
212212                         if (p->n_type != FLOAT && p->n_type != DOUBLE &&
 213213                             l->n_type != FLOAT && l->n_type != DOUBLE &&
 214214                             l->n_type != LDOUBLE && p->n_type != LDOUBLE) {
     
 !
240240                     DEUNSIGN(p->n_type) == SHORT) &&
 241241                     (l->n_type == FLOAT || l->n_type == DOUBLE ||
 242242                     l->n_type == LDOUBLE)) {
<>243 -                        p = block(SCONV, p, NIL, p->n_type, p->n_df, p->n_sue);
  243+                        p = block(SCONV, p, NIL, p->n_type, p->n_df, p->n_ap);
244244                         p->n_left->n_type = INT;
 245245                         break;
 246246                 }
     
 !
249249                 if  ((p->n_type == FLOAT || p->n_type == DOUBLE ||
 250250                     p->n_type == LDOUBLE) && (DEUNSIGN(l->n_type) == CHAR ||
 251251                     DEUNSIGN(l->n_type) == SHORT)) {
<>252 -                        p = block(SCONV, p, NIL, p->n_type, p->n_df, p->n_sue);
  252+                        p = block(SCONV, p, NIL, p->n_type, p->n_df, p->n_ap);
253253                         p->n_left->n_type = INT;
 254254                         break;
 255255                 }
     
 !
310310                         l->n_sp = NULL;
 311311                         l->n_op = ICON;
 312312                         l->n_type = m;
<>313 -                        l->n_sue = MKSUE(m);
  313+                        l->n_ap = MKAP(m);
314314                         nfree(p);
 315315                         p = clocal(l);
 316316                 }
     
 !
323323                 if (o == MOD && p->n_type != CHAR && p->n_type != SHORT)
 324324                         break;
 325325                 /* make it an int division by inserting conversions */
<>326 -                p->n_left = block(SCONV, p->n_left, NIL, INT, 0, MKSUE(INT));
 327 -                p->n_right = block(SCONV, p->n_right, NIL, INT, 0, MKSUE(INT));
 328 -                p = block(SCONV, p, NIL, p->n_type, 0, MKSUE(p->n_type));
  326+                p->n_left = block(SCONV, p->n_left, NIL, INT, 0, MKAP(INT));
  327+                p->n_right = block(SCONV, p->n_right, NIL, INT, 0, MKAP(INT));
  328+                p = block(SCONV, p, NIL, p->n_type, 0, MKAP(p->n_type));
329329                 p->n_left->n_type = INT;
 330330                 break;
 331331 
     
 !
340340                 /* put return value in return reg */
 341341                 p->n_op = ASSIGN;
 342342                 p->n_right = p->n_left;
<>343 -                p->n_left = block(REG, NIL, NIL, p->n_type, 0, MKSUE(INT));
  343+                p->n_left = block(REG, NIL, NIL, p->n_type, 0, MKAP(INT));
344344                 p->n_left->n_rval = RETREG(p->n_type);
 345345                 break;
 346346         }
     
 !
367367  
 368368         sp = IALLOC(sizeof(struct symtab));
 369369         sp->sclass = STATIC;
<>370 -        sp->ssue = MKSUE(p->n_type);
  370+        sp->sap = MKAP(p->n_type);
371371         sp->slevel = 1; /* fake numeric label */
 372372         sp->soffset = getlab();
 373373         sp->sflags = 0;
 374374         sp->stype = p->n_type;
 375375         sp->squal = (CON >> TSHIFT);
 376376 
 377377         defloc(sp);
<>378 -        ninval(0, sp->ssue->suesize, p);
  378+        ninval(0, sp->sap->atypsz, p);
379379 
 380380         p->n_op = NAME;
 381381         p->n_lval = 0;
     
 !
419419  * indirections must be fullword.
 420420  */
 421421 NODE *
<>422 -offcon(OFFSZ off, TWORD t, union dimfun *d, struct suedef *sue)
  422+offcon(OFFSZ off, TWORD t, union dimfun *d, struct attr *sue)
423423 {
 424424         NODE *p;
 425425 
 426426         if (xdebug)
 427427                 printf("offcon: OFFSZ %lld type %x dim %p siz %d\n",
<>428 -                    off, t, d, sue->suesize);
  428+                    off, t, d, 0);
429429 
 430430         p = bcon(off/SZCHAR);
 431431         return p;
     
 !
453453         ecomp(buildtree(MINUSEQ, sp, p));
 454454 
 455455         /* save the address of sp */
<>456 -        sp = block(REG, NIL, NIL, PTR+INT, t->n_df, t->n_sue);
  456+        sp = block(REG, NIL, NIL, PTR+INT, t->n_df, t->n_ap);
457457         sp->n_rval = SP;
 458458         t->n_type = sp->n_type;
 459459         ecomp(buildtree(ASSIGN, t, sp)); /* Emit! */
     
 !
581581  * This routine returns the storage class for an uninitialized declaration
 582582  */
 583583 int
<>584 -noinit()
  584+noinit(void)
585585 {
 586586         return(EXTERN);
 587587 }
     
 !
631631 {
 632632         int off;
 633633 
<>634 -        off = tsize(sp->stype, sp->sdf, sp->ssue);
  634+        off = tsize(sp->stype, sp->sdf, sp->sap);
635635         off = (off+(SZCHAR-1))/SZCHAR;
 636636         printf("        .%scomm ", sp->sclass == STATIC ? "l" : "");
 637637         if (sp->slevel == 0)
     
 !
779779         p = a->n_right;
 780780         if (p->n_type < INT) {
 781781                 /* round up to word */
<>782 -                sz = SZINT / tsize(p->n_type, p->n_df, p->n_sue);
  782+                sz = SZINT / tsize(p->n_type, p->n_df, p->n_ap);
783783         }
 784784 
 785785         p = buildtree(ADDROF, p, NIL);  /* address of last arg */
     
 !
814814         r = a->n_right;
 815815 
 816816         /* get type size */
<>817 -        sz = tsize(r->n_type, r->n_df, r->n_sue) / SZCHAR;
  817+        sz = tsize(r->n_type, r->n_df, r->n_ap) / SZCHAR;
818818         if (sz < SZINT/SZCHAR) {
 819819                 werror("%s%s promoted to int when passed through ...",
 820820                         r->n_type & 1 ? "unsigned " : "",
     
 !
826826         p = tcopy(a->n_left);
 827827         if (sz > SZINT/SZCHAR && r->n_type != UNIONTY && r->n_type != STRTY) {
 828828                 p = buildtree(PLUS, p, bcon(7));
<>829 -                p = block(AND, p, bcon(-8), p->n_type, p->n_df, p->n_sue);
  829+                p = block(AND, p, bcon(-8), p->n_type, p->n_df, p->n_ap);
830830         }
 831831 
 832832         /* create a copy to a temp node */
<>833 -        q = tempnode(0, p->n_type, p->n_df, p->n_sue);
  833+        q = tempnode(0, p->n_type, p->n_df, p->n_ap);
834834         tmpnr = regno(q);
 835835         p = buildtree(ASSIGN, q, p);
 836836 
<>837 -        q = tempnode(tmpnr, p->n_type, p->n_df,p->n_sue);
  837+        q = tempnode(tmpnr, p->n_type, p->n_df,p->n_ap);
838838         q = buildtree(PLUS, q, bcon(sz));
 839839         q = buildtree(ASSIGN, a->n_left, q);
 840840 
     
 !
844844         nfree(a);
 845845         nfree(f);
 846846 
<>847 -        p = tempnode(tmpnr, INCREF(r->n_type), r->n_df, r->n_sue);
  847+        p = tempnode(tmpnr, INCREF(r->n_type), r->n_df, r->n_ap);
<_848848         p = buildtree(UMUL, p, NIL);
 849849         p = buildtree(COMOP, q, p);
 850850 
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-10-31 05:07 +0100