Quick Search:

Mode

Context

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

Other Diffs

Ignore

Blank Lines Whitespace: Expand:

Diff

1.108
 
1.109
 
MAIN:ragge:20040605082242
 
trees.c
_>14691469 
 14701470         case ENUMTY:
 14711471         case MOETY:
<>1472 -                return( MENU );
  1472+                return( MENU|MINT );
14731473 
 14741474         case STRTY:
 14751475         case UNIONTY:
     
 !
16071607 prtdcon(NODE *p)
 16081608 {
 16091609         int o = p->n_op, i;
<> 1610+        int loc;
16101611 
 16111612         if( o == FCON ){
<> 1613+                loc = lastloc;
16121614                 send_passt(IP_LOCCTR, DATA);
 16131615                 defalign( p->n_type == DOUBLE ? ALDOUBLE : ALFLOAT );
 16141616 
     
 !
16191621                 p->n_sp = tmpalloc(sizeof(struct symtab_hdr));
 16201622                 p->n_sp->sclass = ILABEL;
 16211623                 p->n_sp->soffset = i;
<> 1624+                send_passt(IP_LOCCTR, loc);
16221625         }
 16231626 }
 16241627 
     
 !
20422045                         printf("\n");
 20432046                 break;
 20442047 
<> 2048+        case STARG:
20452049         case STASG:
 20462050         case STCALL:
 20472051         case USTCALL:
     
 !
20562060                 printf("\t%d\t\n", talign(STRTY, p->n_left->n_sue));
 20572061                 break;
 20582062 
<>2059 -        case STARG:
 2060 -                cerror("wrong STARG");
20612063         default:
 20622064                 printf"\n" );
 20632065         }
     
 !
21022104                 break;
 21032105 
 21042106         case STARG:
<>2105 -                cerror("wrong STARG");
 2106 -        case FUNARG:
 2107 -                p->n_name = "";
 2108 -                if (p->n_type != STRTY)
 2109 -                        break;
21102107         case STASG:
 21112108         case STCALL:
 21122109         case USTCALL:
     
 !
21272124 
 21282125 #endif
 21292126 
<>2130 -static int
 2131 -storearg(NODE *p)
 2132 -{
 2133 -        static void storecall(NODE *);
 2134 -        NODE *np;
 2135 -        int al, tsz;
 2136 -
 2137 -        np = (p->n_op == CM ? p->n_right : p);
 2138 -        storecall(np);
 2139 -        al = talign(np->n_type, np->n_sue);
 2140 -        tsz = tsize(np->n_type, np->n_df, np->n_sue);
 2141 -
 2142 -        if (tsz < al)
 2143 -                al = ALINT;
 2144 -        SETOFF(tsz, al);
 2145 -
 2146 -        if (p->n_op == CM) {
 2147 -                np = p->n_left;
 2148 -                if (p->n_right->n_op == STARG) {
 2149 -                        NODE *op = p;
 2150 -                        p = p->n_right;
 2151 -                        nfree(op);
 2152 -                } else {
 2153 -                        p->n_type = p->n_right->n_type;
 2154 -                        p->n_left = p->n_right;
 2155 -                }
 2156 -                p->n_op = FUNARG;
 2157 -                p->n_sue = MKSUE(p->n_type & BTMASK);
 2158 -                p->n_rval = tsz;
 2159 -                p = clocal(p); /* deal with arg types */
 2160 -                tsz = p->n_rval;
 2161 -                p2tree(p);
 2162 -                send_passt(IP_NODE, p);
 2163 -                return storearg(np) + tsz;
 2164 -        } else {
 2165 -                if (p->n_op != STARG)
 2166 -                        p = block(FUNARG, p, NIL, p->n_type, 0,
 2167 -                            MKSUE(p->n_type & BTMASK));
 2168 -                else
 2169 -                        p->n_op = FUNARG;
 2170 -                p->n_rval = tsz;
 2171 -                p = clocal(p); /* deal with arg types */
 2172 -                tsz = p->n_rval;
 2173 -                p2tree(p);
 2174 -                send_passt(IP_NODE, p);
 2175 -                return tsz;
 2176 -        }
 2177 -}
 2178 -
 2179 -static void
 2180 -storecall(NODE *p)
 2181 -{
 2182 -        int o = p->n_op;
 2183 -        int ty = coptype(o);
 2184 -
 2185 -        if (ty == LTYPE)
 2186 -                return;
 2187 -
 2188 -        if (o == CALL || o == FORTCALL || o == STCALL) {
 2189 -                p->n_op++; /* Make unary call XXX */
 2190 -                storecall(p->n_left);
 2191 -                p->n_rval = storearg(p->n_right);
 2192 -                return;
 2193 -        }
 2194 -        if (ty != UTYPE)
 2195 -                storecall(p->n_right);
 2196 -        storecall(p->n_left);
 2197 -}
 2198 -
21992127 void
 22002128 ecode(NODE *p)  
 22012129 {
     
 !
22132141                 fwalk(p, eprint, 0);
 22142142         }
 22152143 #endif
<>2216 -        storecall(p);
<_22172144         p2tree(p);
 22182145 #if !defined(MULTIPASS)
 22192146         send_passt(IP_NODE, p);
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-16 11:29 +0200