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:20030531103446
 
trees.c
_>105105 
 106106         /* check for constants */
 107107 
<>108 -        if( opty == UTYPE && l->in.op == ICON ){
  108+        if( opty == UTYPE && l->n_op == ICON ){
109109 
 110110                 switch( o ){
 111111 
     
 !
118118                         }
 119119                 }
 120120 
<>121 -        else if( opty == UTYPE && (l->in.op == FCON || l->in.op == DCON) ){
  121+        else if( opty == UTYPE && (l->n_op == FCON || l->n_op == DCON) ){
122122 
 123123                 switch( o ){
 124124 
 125125                 case NOT:
<>126 -                        if( l->in.op == FCON )
 127 -                                l->tn.lval = l->fpn.fval == 0.0;
  126+                        if( l->n_op == FCON )
  127+                                l->n_lval = l->n_fcon == 0.0;
128128                         else
<>129 -                                l->tn.lval = l->dpn.dval == 0.0;
 130 -                        l->tn.rval = NONAME;
 131 -                        l->in.op = ICON;
 132 -                        l->fn.csiz = l->in.type = INT;
 133 -                        l->fn.cdim = 0;
  129+                                l->n_lval = l->n_dcon == 0.0;
  130+                        l->n_rval = NONAME;
  131+                        l->n_op = ICON;
  132+                        l->n_csiz = l->n_type = INT;
  133+                        l->n_cdim = 0;
134134                         return(l);
 135135                 case UNARY MINUS:
<>136 -                        if( l->in.op == FCON )
 137 -                                l->fpn.fval = -l->fpn.fval;
  136+                        if( l->n_op == FCON )
  137+                                l->n_fcon = -l->n_fcon;
138138                         else
<>139 -                                l->dpn.dval = -l->dpn.dval;
  139+                                l->n_dcon = -l->n_dcon;
140140                         return(l);
 141141                         }
 142142                 }
 143143 
<>144 -        else if( o==QUEST && l->in.op==ICON ) {
 145 -                l->in.op = FREE;
 146 -                r->in.op = FREE;
 147 -                if( l->tn.lval ){
 148 -                        tfree( r->in.right );
 149 -                        return( r->in.left );
  144+        else if( o==QUEST && l->n_op==ICON ) {
  145+                l->n_op = FREE;
  146+                r->n_op = FREE;
  147+                if( l->n_lval ){
  148+                        tfree( r->n_right );
  149+                        return( r->n_left );
150150                         }
 151151                 else {
<>152 -                        tfree( r->in.left );
 153 -                        return( r->in.right );
  152+                        tfree( r->n_left );
  153+                        return( r->n_right );
154154                         }
 155155                 }
 156156 
<>157 -        else if( (o==ANDAND || o==OROR) && (l->in.op==ICON||r->in.op==ICON) ) goto ccwarn;
  157+        else if( (o==ANDAND || o==OROR) && (l->n_op==ICON||r->n_op==ICON) ) goto ccwarn;
158158 
<>159 -        else if( opty == BITYPE && l->in.op == ICON && r->in.op == ICON ){
  159+        else if( opty == BITYPE && l->n_op == ICON && r->n_op == ICON ){
160160 
 161161                 switch( o ){
 162162 
     
 !
170170                 case GE:
 171171                 case EQ:
 172172                 case NE:
<>173 -                        if( l->in.type == ENUMTY && r->in.type == ENUMTY ){
  173+                        if( l->n_type == ENUMTY && r->n_type == ENUMTY ){
174174                                 p = block( o, l, r, INT, 0, INT );
 175175                                 chkpun( p );
<>176 -                                p->in.op = FREE;
  176+                                p->n_op = FREE;
177177                                 }
 178178 
 179179                 case ANDAND:
     
 !
193193                 case LS:
 194194                 case RS:
 195195                         if( conval( l, o, r ) ) {
<>196 -                                r->in.op = FREE;
  196+                                r->n_op = FREE;
197197                                 return(l);
 198198                                 }
 199199                         break;
 200200                         }
 201201                 }
 202202         else if (opty == BITYPE &&
<>203 -                (l->in.op == FCON || l->in.op == DCON || l->in.op == ICON) &&
 204 -                (r->in.op == FCON || r->in.op == DCON || r->in.op == ICON)) {
  203+                (l->n_op == FCON || l->n_op == DCON || l->n_op == ICON) &&
  204+                (r->n_op == FCON || r->n_op == DCON || r->n_op == ICON)) {
205205                         if (o == PLUS || o == MINUS || o == MUL || o == DIV) {
 206206                                 extern int fpe_count;
 207207                                 extern jmp_buf gotfpe;
 208208 
 209209                                 fpe_count = 0;
 210210                                 if (setjmp(gotfpe))
 211211                                         goto treatfpe;
<>212 -                                if (l->in.op == ICON)
 213 -                                        l->dpn.dval = l->tn.lval;
 214 -                                else if (l->in.op == FCON)
 215 -                                        l->dpn.dval = l->fpn.fval;
 216 -                                if (r->in.op == ICON)
 217 -                                        r->dpn.dval = r->tn.lval;
 218 -                                else if (r->in.op == FCON)
 219 -                                        r->dpn.dval = r->fpn.fval;
  212+                                if (l->n_op == ICON)
  213+                                        l->n_dcon = l->n_lval;
  214+                                else if (l->n_op == FCON)
  215+                                        l->n_dcon = l->n_fcon;
  216+                                if (r->n_op == ICON)
  217+                                        r->n_dcon = r->n_lval;
  218+                                else if (r->n_op == FCON)
  219+                                        r->n_dcon = r->n_fcon;
220220                                 switch (o) {
 221221 
 222222                                 case PLUS:
<>223 -                                        l->dpn.dval += r->dpn.dval;
  223+                                        l->n_dcon += r->n_dcon;
224224                                         break;
 225225 
 226226                                 case MINUS:
<>227 -                                        l->dpn.dval -= r->dpn.dval;
  227+                                        l->n_dcon -= r->n_dcon;
228228                                         break;
 229229 
 230230                                 case MUL:
<>231 -                                        l->dpn.dval *= r->dpn.dval;
  231+                                        l->n_dcon *= r->n_dcon;
232232                                         break;
 233233 
 234234                                 case DIV:
<>235 -                                        if (r->dpn.dval == 0)
  235+                                        if (r->n_dcon == 0)
236236                                                 uerror("division by 0.");
 237237                                         else
<>238 -                                                l->dpn.dval /= r->dpn.dval;
  238+                                                l->n_dcon /= r->n_dcon;
239239                                         break;
 240240                                         }
 241241                         treatfpe:
 242242                                 if (fpe_count > 0) {
 243243                                         uerror("floating point exception in constant expression");
<>244 -                                        l->dpn.dval = 1.0; /* Fairly harmless */
  244+                                        l->n_dcon = 1.0; /* Fairly harmless */
245245                                         }
 246246                                 fpe_count = -1;
<>247 -                                l->in.op = DCON;
 248 -                                l->in.type = l->fn.csiz = DOUBLE;
 249 -                                r->in.op = FREE;
  247+                                l->n_op = DCON;
  248+                                l->n_type = l->n_csiz = DOUBLE;
  249+                                r->n_op = FREE;
250250                                 return (l);
 251251                         }
 252252                 }
     
 !
262262 #endif
 263263 
 264264         if( actions&LVAL ){ /* check left descendent */
<>265 -                if( notlval(p->in.left) ) {
  265+                if( notlval(p->n_left) ) {
266266                         uerror( "illegal lvalue operand of assignment operator" );
 267267                         }
 268268                 }
 269269 
 270270         if( actions & NCVTR ){
<>271 -                p->in.left = pconvert( p->in.left );
  271+                p->n_left = pconvert( p->n_left );
272272                 }
 273273         else if( !(actions & NCVT ) ){
 274274                 switch( opty ){
 275275 
 276276                 case BITYPE:
<>277 -                        p->in.right = pconvert( p->in.right );
  277+                        p->n_right = pconvert( p->n_right );
278278                 case UTYPE:
<>279 -                        p->in.left = pconvert( p->in.left );
  279+                        p->n_left = pconvert( p->n_left );
280280 
 281281                         }
 282282                 }
     
 !
286286 
 287287         if( actions & (TYPL|TYPR) ){
 288288 
<>289 -                q = (actions&TYPL) ? p->in.left : p->in.right;
  289+                q = (actions&TYPL) ? p->n_left : p->n_right;
290290 
<>291 -                p->in.type = q->in.type;
 292 -                p->fn.cdim = q->fn.cdim;
 293 -                p->fn.csiz = q->fn.csiz;
  291+                p->n_type = q->n_type;
  292+                p->n_cdim = q->n_cdim;
  293+                p->n_csiz = q->n_csiz;
294294                 }
 295295 
 296296         if( actions & CVTL ) p = convert( p, CVTL );
     
 !
299299         if( actions & PTMATCH ) p = ptmatch(p);
 300300 
 301301         if( actions & OTHER ){
<>302 -                l = p->in.left;
 303 -                r = p->in.right;
  302+                l = p->n_left;
  303+                r = p->n_right;
304304 
 305305                 switch(o){
 306306 
     
 !
309309                         if( sp->stype == UNDEF ){
 310310                                 uerror( "%s undefined", sp->sname );
 311311                                 /* make p look reasonable */
<>312 -                                p->in.type = p->fn.csiz = INT;
 313 -                                p->fn.cdim = 0;
 314 -                                p->tn.rval = idname;
 315 -                                p->tn.lval = 0;
  312+                                p->n_type = p->n_csiz = INT;
  313+                                p->n_cdim = 0;
  314+                                p->n_rval = idname;
  315+                                p->n_lval = 0;
316316                                 defid( p, SNULL );
 317317                                 break;
 318318                                 }
<>319 -                        p->in.type = sp->stype;
 320 -                        p->fn.cdim = sp->dimoff;
 321 -                        p->fn.csiz = sp->sizoff;
 322 -                        p->tn.lval = 0;
 323 -                        p->tn.rval = idname;
  319+                        p->n_type = sp->stype;
  320+                        p->n_cdim = sp->dimoff;
  321+                        p->n_csiz = sp->sizoff;
  322+                        p->n_lval = 0;
  323+                        p->n_rval = idname;
324324                         /* special case: MOETY is really an ICON... */
<>325 -                        if( p->in.type == MOETY ){
 326 -                                p->tn.rval = NONAME;
 327 -                                p->tn.lval = sp->offset;
 328 -                                p->fn.cdim = 0;
 329 -                                p->in.type = ENUMTY;
 330 -                                p->in.op = ICON;
  325+                        if( p->n_type == MOETY ){
  326+                                p->n_rval = NONAME;
  327+                                p->n_lval = sp->offset;
  328+                                p->n_cdim = 0;
  329+                                p->n_type = ENUMTY;
  330+                                p->n_op = ICON;
331331                                 }
 332332                         break;
 333333 
 334334                 case ICON:
<>335 -                        p->in.type = INT;
 336 -                        p->fn.cdim = 0;
 337 -                        p->fn.csiz = INT;
  335+                        p->n_type = INT;
  336+                        p->n_cdim = 0;
  337+                        p->n_csiz = INT;
338338                         break;
 339339 
 340340                 case STRING:
<>341 -                        p->in.op = NAME;
  341+                        p->n_op = NAME;
342342 #ifdef CHAR_UNSIGNED
<>343 -                        p->in.type = UCHAR+ARY;
 344 -                        p->fn.csiz = UCHAR;
  343+                        p->n_type = UCHAR+ARY;
  344+                        p->n_csiz = UCHAR;
345345 #else
<>346 -                        p->in.type = CHAR+ARY;
 347 -                        p->fn.csiz = CHAR;
  346+                        p->n_type = CHAR+ARY;
  347+                        p->n_csiz = CHAR;
348348 #endif
<>349 -                        p->tn.lval = 0;
 350 -                        p->tn.rval = NOLAB;
 351 -                        p->fn.cdim = curdim;
  349+                        p->n_lval = 0;
  350+                        p->n_rval = NOLAB;
  351+                        p->n_cdim = curdim;
352352                         break;
 353353 
 354354                 case FCON:
<>355 -                        p->tn.lval = 0;
 356 -                        p->tn.rval = 0;
 357 -                        p->in.type = FLOAT;
 358 -                        p->fn.cdim = 0;
 359 -                        p->fn.csiz = FLOAT;
  355+                        p->n_lval = 0;
  356+                        p->n_rval = 0;
  357+                        p->n_type = FLOAT;
  358+                        p->n_cdim = 0;
  359+                        p->n_csiz = FLOAT;
360360                         break;
 361361 
 362362                 case DCON:
<>363 -                        p->tn.lval = 0;
 364 -                        p->tn.rval = 0;
 365 -                        p->in.type = DOUBLE;
 366 -                        p->fn.cdim = 0;
 367 -                        p->fn.csiz = DOUBLE;
  363+                        p->n_lval = 0;
  364+                        p->n_rval = 0;
  365+                        p->n_type = DOUBLE;
  366+                        p->n_cdim = 0;
  367+                        p->n_csiz = DOUBLE;
368368                         break;
 369369 
 370370                 case STREF:
 371371                         /* p->x turned into *(p+offset) */
 372372                         /* rhs must be a name; check correctness */
 373373 
<>374 -                        i = r->tn.rval;
  374+                        i = r->n_rval;
375375                         if( i<0 || ((sp= &stab[i])->sclass != MOS && sp->sclass != MOU && !(sp->sclass&FIELD)) ){
 376376                                 uerror( "member of structure or union required" );
 377377                                 }else
 378378                         /* if this name is non-unique, find right one */
 379379                         if( stab[i].sflags & SNONUNIQ &&
<>380 -                                (l->in.type==PTR+STRTY || l->in.type == PTR+UNIONTY) &&
 381 -                                (l->fn.csiz +1) >= 0 ){
  380+                                (l->n_type==PTR+STRTY || l->n_type == PTR+UNIONTY) &&
  381+                                (l->n_csiz +1) >= 0 ){
382382                                 /* nonunique name && structure defined */
 383383                                 char * memnam, * tabnam;
 384384                                 int j;
 385385                                 int memi;
<>386 -                                j=dimtab[l->fn.csiz+1];
  386+                                j=dimtab[l->n_csiz+1];
387387                                 for( ; (memi=dimtab[j]) >= 0; ++j ){
 388388                                         tabnam = stab[memi].sname;
 389389                                         memnam = stab[i].sname;
     
 !
396396                                         if( stab[memi].sflags & SNONUNIQ ){
 397397                                                 if (memnam != tabnam)
 398398                                                         goto next;
<>399 -                                                r->tn.rval = i = memi;
  399+                                                r->n_rval = i = memi;
400400                                                 break;
 401401                                                 }
 402402                                         next: continue;
     
 !
407407                                 }
 408408                         else {
 409409                                 int j;
<>410 -                                if( l->in.type != PTR+STRTY && l->in.type != PTR+UNIONTY ){
  410+                                if( l->n_type != PTR+STRTY && l->n_type != PTR+UNIONTY ){
411411                                         if( stab[i].sflags & SNONUNIQ ){
 412412                                                 uerror( "nonunique name demands struct/union or struct/union pointer" );
 413413                                                 }
 414414                                         else werror( "struct/union or struct/union pointer required" );
 415415                                         }
<>416 -                                else if( (j=l->fn.csiz+1)<0 ) cerror( "undefined structure or union" );
 417 -                                else if( !chkstr( i, dimtab[j], DECREF(l->in.type) ) ){
  416+                                else if( (j=l->n_csiz+1)<0 ) cerror( "undefined structure or union" );
  417+                                else if( !chkstr( i, dimtab[j], DECREF(l->n_type) ) ){
418418                                         werror( "illegal member use: %s", stab[i].sname );
 419419                                         }
 420420                                 }
     
 !
423423                         break;
 424424 
 425425                 case UNARY MUL:
<>426 -                        if( l->in.op == UNARY AND ){
 427 -                                p->in.op = l->in.op = FREE;
 428 -                                p = l->in.left;
  426+                        if( l->n_op == UNARY AND ){
  427+                                p->n_op = l->n_op = FREE;
  428+                                p = l->n_left;
429429                                 }
<>430 -                        if( !ISPTR(l->in.type))uerror("illegal indirection");
 431 -                        p->in.type = DECREF(l->in.type);
 432 -                        p->fn.cdim = l->fn.cdim;
 433 -                        p->fn.csiz = l->fn.csiz;
  430+                        if( !ISPTR(l->n_type))uerror("illegal indirection");
  431+                        p->n_type = DECREF(l->n_type);
  432+                        p->n_cdim = l->n_cdim;
  433+                        p->n_csiz = l->n_csiz;
434434                         break;
 435435 
 436436                 case UNARY AND:
<>437 -                        switch( l->in.op ){
  437+                        switch( l->n_op ){
438438 
 439439                         case UNARY MUL:
<>440 -                                p->in.op = l->in.op = FREE;
 441 -                                p = l->in.left;
  440+                                p->n_op = l->n_op = FREE;
  441+                                p = l->n_left;
442442                         case NAME:
<>443 -                                p->in.type = INCREF( l->in.type );
 444 -                                p->fn.cdim = l->fn.cdim;
 445 -                                p->fn.csiz = l->fn.csiz;
  443+                                p->n_type = INCREF( l->n_type );
  444+                                p->n_cdim = l->n_cdim;
  445+                                p->n_csiz = l->n_csiz;
446446                                 break;
 447447 
 448448                         case COMOP:
<>449 -                                lr = buildtree( UNARY AND, l->in.right, NIL );
 450 -                                p->in.op = l->in.op = FREE;
 451 -                                p = buildtree( COMOP, l->in.left, lr );
  449+                                lr = buildtree( UNARY AND, l->n_right, NIL );
  450+                                p->n_op = l->n_op = FREE;
  451+                                p = buildtree( COMOP, l->n_left, lr );
452452                                 break;
 453453 
 454454                         case QUEST:
<>455 -                                lr = buildtree( UNARY AND, l->in.right->in.right, NIL );
 456 -                                ll = buildtree( UNARY AND, l->in.right->in.left, NIL );
 457 -                                p->in.op = l->in.op = l->in.right->in.op = FREE;
 458 -                                p = buildtree( QUEST, l->in.left, buildtree( COLON, ll, lr ) );
  455+                                lr = buildtree( UNARY AND, l->n_right->n_right, NIL );
  456+                                ll = buildtree( UNARY AND, l->n_right->n_left, NIL );
  457+                                p->n_op = l->n_op = l->n_right->n_op = FREE;
  458+                                p = buildtree( QUEST, l->n_left, buildtree( COLON, ll, lr ) );
459459                                 break;
 460460 
 461461 # ifdef ADDROREG
     
 !
467467                                  * back to PLUS/MINUS REG ICON
 468468                                  * according to local conventions
 469469                                  */
<>470 -                                p->in.op = FREE;
  470+                                p->n_op = FREE;
471471                                 p = addroreg( l );
 472472                                 break;
 473473 
 474474 # endif
 475475                         default:
<>476 -                                uerror("unacceptable operand of &: %d", l->in.op );
  476+                                uerror("unacceptable operand of &: %d", l->n_op );
477477                                 break;
 478478                                 }
 479479                         break;
 480480 
 481481                 case LS:
 482482                 case RS:
<>483 -                        if( l->in.type == CHAR || l->in.type == SHORT )
 484 -                                p->in.type = INT;
 485 -                        else if( l->in.type == UCHAR || l->in.type == USHORT )
 486 -                                p->in.type = UNSIGNED;
  483+                        if( l->n_type == CHAR || l->n_type == SHORT )
  484+                                p->n_type = INT;
  485+                        else if( l->n_type == UCHAR || l->n_type == USHORT )
  486+                                p->n_type = UNSIGNED;
487487                         else
<>488 -                                p->in.type = l->in.type;
  488+                                p->n_type = l->n_type;
489489                 case ASG LS:
 490490                 case ASG RS:
<>491 -                        if( r->in.type != INT )
 492 -                                p->in.right = r = makety(r, INT, 0, INT );
  491+                        if( r->n_type != INT )
  492+                                p->n_right = r = makety(r, INT, 0, INT );
493493                         break;
 494494 
 495495                 case RETURN:
     
 !
504504                                 TWORD t;
 505505                                 int d, s;
 506506 
<>507 -                                if( l->fn.csiz != r->fn.csiz ) uerror( "assignment of different structures" );
  507+                                if( l->n_csiz != r->n_csiz ) uerror( "assignment of different structures" );
508508 
 509509                                 r = buildtree( UNARY AND, r, NIL );
<>510 -                                t = r->in.type;
 511 -                                d = r->fn.cdim;
 512 -                                s = r->fn.csiz;
  510+                                t = r->n_type;
  511+                                d = r->n_cdim;
  512+                                s = r->n_csiz;
513513 
 514514                                 l = block( STASG, l, r, t, d, s );
 515515 
 516516                                 if( o == RETURN ){
<>517 -                                        p->in.op = FREE;
  517+                                        p->n_op = FREE;
518518                                         p = l;
 519519                                         break;
 520520                                         }
 521521 
<>522 -                                p->in.op = UNARY MUL;
 523 -                                p->in.left = l;
 524 -                                p->in.right = NIL;
  522+                                p->n_op = UNARY MUL;
  523+                                p->n_left = l;
  524+                                p->n_right = NIL;
525525                                 break;
 526526                                 }
 527527                 case COLON:
 528528                         /* structure colon */
 529529 
<>530 -                        if( l->fn.csiz != r->fn.csiz ) uerror( "type clash in conditional" );
  530+                        if( l->n_csiz != r->n_csiz ) uerror( "type clash in conditional" );
531531                         break;
 532532 
 533533                 case CALL:
<>534 -                        p->in.right = r = fixargs( p->in.right );
  534+                        p->n_right = r = fixargs( p->n_right );
535535                 case UNARY CALL:
<>536 -                        if( !ISPTR(l->in.type)) uerror("illegal function");
 537 -                        p->in.type = DECREF(l->in.type);
 538 -                        if( !ISFTN(p->in.type)) uerror("illegal function");
 539 -                        p->in.type = DECREF( p->in.type );
 540 -                        p->fn.cdim = l->fn.cdim;
 541 -                        p->fn.csiz = l->fn.csiz;
 542 -                        if( l->in.op == UNARY AND && l->in.left->in.op == NAME &&
 543 -                                l->in.left->tn.rval >= 0 && l->in.left->tn.rval != NONAME &&
 544 -                                ( (i=stab[l->in.left->tn.rval].sclass) == FORTRAN || i==UFORTRAN ) ){
 545 -                                p->in.op += (FORTCALL-CALL);
  536+                        if( !ISPTR(l->n_type)) uerror("illegal function");
  537+                        p->n_type = DECREF(l->n_type);
  538+                        if( !ISFTN(p->n_type)) uerror("illegal function");
  539+                        p->n_type = DECREF( p->n_type );
  540+                        p->n_cdim = l->n_cdim;
  541+                        p->n_csiz = l->n_csiz;
  542+                        if( l->n_op == UNARY AND && l->n_left->n_op == NAME &&
  543+                                l->n_left->n_rval >= 0 && l->n_left->n_rval != NONAME &&
  544+                                ( (i=stab[l->n_left->n_rval].sclass) == FORTRAN || i==UFORTRAN ) ){
  545+                                p->n_op += (FORTCALL-CALL);
546546                                 }
<>547 -                        if( p->in.type == STRTY || p->in.type == UNIONTY ){
  547+                        if( p->n_type == STRTY || p->n_type == UNIONTY ){
548548                                 /* function returning structure */
 549549                                 /*  make function really return ptr to str., with * */
 550550 
<>551 -                                p->in.op += STCALL-CALL;
 552 -                                p->in.type = INCREF( p->in.type );
  551+                                p->n_op += STCALL-CALL;
  552+                                p->n_type = INCREF( p->n_type );
553553                                 p = buildtree( UNARY MUL, p, NIL );
 554554 
 555555                                 }
     
 !
566566          * XXX - anything on the right side must be possible to cast.
 567567          * XXX - remove void types further on.
 568568          */
<>569 -        if (p->in.op == CAST && p->in.type == UNDEF &&
 570 -            p->in.right->in.op == ICON)
 571 -                p->in.right->in.type = UNDEF;
  569+        if (p->n_op == CAST && p->n_type == UNDEF &&
  570+            p->n_right->n_op == ICON)
  571+                p->n_right->n_type = UNDEF;
572572 
 573573         if( actions & CVTO ) p = oconvert(p);
 574574         p = clocal(p);
     
 !
602602  */
 603603 NODE *
 604604 fixargs( p ) register NODE *p;  {
<>605 -        int o = p->in.op;
  605+        int o = p->n_op;
606606 
 607607         if( o == CM ){
<>608 -                p->in.left = fixargs( p->in.left );
 609 -                p->in.right = fixargs( p->in.right );
  608+                p->n_left = fixargs( p->n_left );
  609+                p->n_right = fixargs( p->n_right );
610610                 return( p );
 611611                 }
 612612 
<>613 -        if( p->in.type == STRTY || p->in.type == UNIONTY ){
 614 -                p = block( STARG, p, NIL, p->in.type, p->fn.cdim, p->fn.csiz );
 615 -                p->in.left = buildtree( UNARY AND, p->in.left, NIL );
  613+        if( p->n_type == STRTY || p->n_type == UNIONTY ){
  614+                p = block( STARG, p, NIL, p->n_type, p->n_cdim, p->n_csiz );
  615+                p->n_left = buildtree( UNARY AND, p->n_left, NIL );
616616                 p = clocal(p);
 617617                 }
 618618         else if( o == FCON )
     
 !
669669         CONSZ val;
 670670         TWORD utype;
 671671 
<>672 -        val = q->tn.lval;
 673 -        u = ISUNSIGNED(p->in.type) || ISUNSIGNED(q->in.type);
  672+        val = q->n_lval;
  673+        u = ISUNSIGNED(p->n_type) || ISUNSIGNED(q->n_type);
674674         if( u && (o==LE||o==LT||o==GE||o==GT)) o += (UGE-GE);
 675675 
<>676 -        if( p->tn.rval != NONAME && q->tn.rval != NONAME ) return(0);
 677 -        if( q->tn.rval != NONAME && o!=PLUS ) return(0);
 678 -        if( p->tn.rval != NONAME && o!=PLUS && o!=MINUS ) return(0);
  676+        if( p->n_rval != NONAME && q->n_rval != NONAME ) return(0);
  677+        if( q->n_rval != NONAME && o!=PLUS ) return(0);
  678+        if( p->n_rval != NONAME && o!=PLUS && o!=MINUS ) return(0);
679679 
 680680         /* usual type conversions -- handle casts of constants */
 681681 #define ISLONG(t)       ((t) == LONG || (t) == ULONG)
 682682 #define ISLONGLONG(t)   ((t) == LONGLONG || (t) == ULONGLONG)
<>683 -        if (ISLONG(p->in.type) || ISLONG(q->in.type))
  683+        if (ISLONG(p->n_type) || ISLONG(q->n_type))
684684                 utype = u ? ULONG : LONG;
<>685 -        else if (ISLONGLONG(p->in.type) || ISLONGLONG(q->in.type))
  685+        else if (ISLONGLONG(p->n_type) || ISLONGLONG(q->n_type))
686686                 utype = u ? ULONGLONG : LONGLONG;
 687687         else
 688688                 utype = u ? UNSIGNED : INT;
<>689 -        if( !ISPTR(p->in.type) && p->in.type != utype )
  689+        if( !ISPTR(p->n_type) && p->n_type != utype )
690690                 p = makety(p, utype, 0, (int)utype);
<>691 -        if( q->in.type != utype )
  691+        if( q->n_type != utype )
692692                 q = makety(q, utype, 0, (int)utype);
 693693 
 694694         switch( o ){
 695695 
 696696         case PLUS:
<>697 -                p->tn.lval += val;
 698 -                if( p->tn.rval == NONAME ){
 699 -                        p->tn.rval = q->tn.rval;
 700 -                        p->in.type = q->in.type;
  697+                p->n_lval += val;
  698+                if( p->n_rval == NONAME ){
  699+                        p->n_rval = q->n_rval;
  700+                        p->n_type = q->n_type;
701701                         }
 702702                 break;
 703703         case MINUS:
<>704 -                p->tn.lval -= val;
  704+                p->n_lval -= val;
705705                 break;
 706706         case MUL:
<>707 -                p->tn.lval *= val;
  707+                p->n_lval *= val;
708708                 break;
 709709         case DIV:
 710710                 if( val == 0 ) uerror( "division by 0" );
<>711 -                else if ( u ) p->tn.lval = (unsigned) p->tn.lval / val;
 712 -                else p->tn.lval /= val;
  711+                else if ( u ) p->n_lval = (unsigned) p->n_lval / val;
  712+                else p->n_lval /= val;
713713                 break;
 714714         case MOD:
 715715                 if( val == 0 ) uerror( "division by 0" );
<>716 -                else if ( u ) p->tn.lval = (unsigned) p->tn.lval % val;
 717 -                else p->tn.lval %= val;
  716+                else if ( u ) p->n_lval = (unsigned) p->n_lval % val;
  717+                else p->n_lval %= val;
718718                 break;
 719719         case AND:
<>720 -                p->tn.lval &= val;
  720+                p->n_lval &= val;
721721                 break;
 722722         case OR:
<>723 -                p->tn.lval |= val;
  723+                p->n_lval |= val;
724724                 break;
 725725         case ER:
<>726 -                p->tn.lval ^= val;
  726+                p->n_lval ^= val;
727727                 break;
 728728         case LS:
 729729                 i = val;
<>730 -                p->tn.lval = p->tn.lval << i;
  730+                p->n_lval = p->n_lval << i;
731731                 break;
 732732         case RS:
 733733                 i = val;
<>734 -                if ( u ) p->tn.lval = (unsigned) p->tn.lval >> i;
 735 -                else p->tn.lval = p->tn.lval >> i;
  734+                if ( u ) p->n_lval = (unsigned) p->n_lval >> i;
  735+                else p->n_lval = p->n_lval >> i;
736736                 break;
 737737 
 738738         case UNARY MINUS:
<>739 -                p->tn.lval = - p->tn.lval;
  739+                p->n_lval = - p->n_lval;
740740                 break;
 741741         case COMPL:
<>742 -                p->tn.lval = ~p->tn.lval;
  742+                p->n_lval = ~p->n_lval;
743743                 break;
 744744         case NOT:
<>745 -                p->tn.lval = !p->tn.lval;
  745+                p->n_lval = !p->n_lval;
746746                 break;
 747747         case LT:
<>748 -                p->tn.lval = p->tn.lval < val;
  748+                p->n_lval = p->n_lval < val;
749749                 break;
 750750         case LE:
<>751 -                p->tn.lval = p->tn.lval <= val;
  751+                p->n_lval = p->n_lval <= val;
752752                 break;
 753753         case GT:
<>754 -                p->tn.lval = p->tn.lval > val;
  754+                p->n_lval = p->n_lval > val;
755755                 break;
 756756         case GE:
<>757 -                p->tn.lval = p->tn.lval >= val;
  757+                p->n_lval = p->n_lval >= val;
758758                 break;
 759759         case ULT:
<>760 -                p->tn.lval = p->tn.lval < (unsigned) val;
  760+                p->n_lval = p->n_lval < (unsigned) val;
761761                 break;
 762762         case ULE:
<>763 -                p->tn.lval = p->tn.lval <= (unsigned) val;
  763+                p->n_lval = p->n_lval <= (unsigned) val;
764764                 break;
 765765         case UGT:
<>766 -                p->tn.lval = p->tn.lval > (unsigned) val;
  766+                p->n_lval = p->n_lval > (unsigned) val;
767767                 break;
 768768         case UGE:
<>769 -                p->tn.lval = p->tn.lval >= (unsigned) val;
  769+                p->n_lval = p->n_lval >= (unsigned) val;
770770                 break;
 771771         case EQ:
<>772 -                p->tn.lval = p->tn.lval == val;
  772+                p->n_lval = p->n_lval == val;
773773                 break;
 774774         case NE:
<>775 -                p->tn.lval = p->tn.lval != val;
  775+                p->n_lval = p->n_lval != val;
776776                 break;
 777777         default:
 778778                 return(0);
     
 !
795795         NODE *q;
 796796         int t1, t2, d1, d2, ref1, ref2;
 797797 
<>798 -        t1 = p->in.left->in.type;
 799 -        t2 = p->in.right->in.type;
  798+        t1 = p->n_left->n_type;
  799+        t2 = p->n_right->n_type;
800800 
 801801         /* check for enumerations */
 802802         if (t1==ENUMTY || t2==ENUMTY) {
 803803                 /* rob pike says this is obnoxious...
<>804 -                if( logop( p->in.op ) && p->in.op != EQ && p->in.op != NE )
  804+                if( logop( p->n_op ) && p->n_op != EQ && p->n_op != NE )
805805                         werror( "comparison of enums" ); */
 806806                 if (t1==ENUMTY && t2==ENUMTY) {
<>807 -                        if (p->in.left->fn.csiz!=p->in.right->fn.csiz)
  807+                        if (p->n_left->n_csiz!=p->n_right->n_csiz)
808808                                 werror("enumeration type clash, "
<>809 -                                    "operator %s", opst[p->in.op]);
  809+                                    "operator %s", opst[p->n_op]);
810810                         return;
 811811                 }
 812812                 if (t1 == ENUMTY)
     
 !
820820 
 821821         if (ref1 ^ ref2) {
 822822                 if (ref1)
<>823 -                        q = p->in.right;
  823+                        q = p->n_right;
824824                 else
<>825 -                        q = p->in.left;
 826 -                if (q->in.op != ICON || q->tn.lval != 0)
  825+                        q = p->n_left;
  826+                if (q->n_op != ICON || q->n_lval != 0)
827827                         werror("illegal combination of pointer "
<>828 -                            "and integer, op %s", opst[p->in.op]);
  828+                            "and integer, op %s", opst[p->n_op]);
829829         } else if (ref1) {
 830830                 if (t1 == t2) {
<>831 -                        if (p->in.left->fn.csiz != p->in.right->fn.csiz) {
  831+                        if (p->n_left->n_csiz != p->n_right->n_csiz) {
832832                                 werror("illegal structure pointer combination");
 833833                                 return;
 834834                         }
<>835 -                        d1 = p->in.left->fn.cdim;
 836 -                        d2 = p->in.right->fn.cdim;
  835+                        d1 = p->n_left->n_cdim;
  836+                        d2 = p->n_right->n_cdim;
837837                         for (;;) {
 838838                                 if (ISARY(t1)) {
 839839                                         if (dimtab[d1] != dimtab[d2]) {
     
 !
864864         /* make p->x */
 865865         /* this is also used to reference automatic variables */
 866866 
<>867 -        snum = p->in.right->tn.rval;
  867+        snum = p->n_right->n_rval;
868868         q = &stab[snum];
<>869 -        p->in.right->in.op = FREE;
 870 -        p->in.op = FREE;
 871 -        p = pconvert(p->in.left);
  869+        p->n_right->n_op = FREE;
  870+        p->n_op = FREE;
  871+        p = pconvert(p->n_left);
872872 
 873873         /* make p look like ptr to x */
 874874 
<>875 -        if (!ISPTR(p->in.type))
 876 -                p->in.type = PTR+UNIONTY;
  875+        if (!ISPTR(p->n_type))
  876+                p->n_type = PTR+UNIONTY;
877877 
 878878         t = INCREF(q->stype);
 879879         d = q->dimoff;
     
 !
900900 
 901901         if (dsc & FIELD) {
 902902                 p = block(FLD, p, NIL, q->stype, 0, q->sizoff);
<>903 -                p->tn.rval = PKFIELD(dsc&FLDSIZ, q->offset%align);
  903+                p->n_rval = PKFIELD(dsc&FLDSIZ, q->offset%align);
904904         }
 905905 
 906906         p = clocal(p);
<>907 -        p->in.su = snum;        /* Needed if this is a function */
  907+        p->n_su = snum/* Needed if this is a function */
908908         return p;
 909909 }
 910910 
     
 !
915915 
 916916         again:
 917917 
<>918 -        switch( p->in.op ){
  918+        switch( p->n_op ){
919919 
 920920         case FLD:
<>921 -                p = p->in.left;
  921+                p = p->n_left;
922922                 goto again;
 923923 
 924924         case UNARY MUL:
 925925                 /* fix the &(a=b) bug, given that a and b are structures */
<>926 -                if( p->in.left->in.op == STASG ) return( 1 );
  926+                if( p->n_left->n_op == STASG ) return( 1 );
927927                 /* and the f().a bug, given that f returns a structure */
<>928 -                if( p->in.left->in.op == UNARY STCALL ||
 929 -                    p->in.left->in.op == STCALL ) return( 1 );
  928+                if( p->n_left->n_op == UNARY STCALL ||
  929+                    p->n_left->n_op == STCALL ) return( 1 );
930930         case NAME:
 931931         case OREG:
<>932 -                if( ISARY(p->in.type) || ISFTN(p->in.type) ) return(1);
  932+                if( ISARY(p->n_type) || ISFTN(p->n_type) ) return(1);
933933         case REG:
 934934                 return(0);
 935935 
     
 !
945945         register NODE *p;
 946946 
 947947         p = block( ICON, NIL, NIL, INT, 0, INT );
<>948 -        p->tn.lval = i;
 949 -        p->tn.rval = NONAME;
  948+        p->n_lval = i;
  949+        p->n_rval = NONAME;
950950         return( clocal(p) );
 951951         }
 952952 
 953953 NODE *
 954954 bpsize(NODE *p)
 955955 {
<>956 -        return(offcon(psize(p), p->in.type, p->fn.cdim, p->fn.csiz));
  956+        return(offcon(psize(p), p->n_type, p->n_cdim, p->n_csiz));
957957 }
 958958 
 959959 /*
     
 !
964964 psize(NODE *p)
 965965 {
 966966 
<>967 -        if (!ISPTR(p->in.type)) {
  967+        if (!ISPTR(p->n_type)) {
968968                 uerror("pointer required");
 969969                 return(SZINT);
 970970         }
 971971         /* note: no pointers to fields */
<>972 -        return(tsize(DECREF(p->in.type), p->fn.cdim, p->fn.csiz));
  972+        return(tsize(DECREF(p->n_type), p->n_cdim, p->n_csiz));
973973 }
 974974 
 975975 /*
     
 !
982982 {
 983983         NODE *q, *r, *s;
 984984 
<>985 -        q = (f == CVTL) ? p->in.left : p->in.right;
  985+        q = (f == CVTL) ? p->n_left : p->n_right;
986986 
<>987 -        s = bpsize(f == CVTL ? p->in.right : p->in.left);
  987+        s = bpsize(f == CVTL ? p->n_right : p->n_left);
988988         r = block(PMCONV, q, s, INT, 0, INT);
 989989         r = clocal(r);
 990990         /*
 991991          * Indexing is only allowed with integer arguments, so insert
 992992          * SCONV here if arg is not an integer.
 993993          * XXX - complain?
 994994          */
<>995 -        if (r->in.type != INT)
  995+        if (r->n_type != INT)
996996                 r = clocal(block(SCONV, r, NIL, INT, 0, INT));
 997997         if (f == CVTL)
<>998 -                p->in.left = r;
  998+                p->n_left = r;
999999         else
<>1000 -                p->in.right = r;
  1000+                p->n_right = r;
10011001         return(p);
 10021002 }
 10031003 
     
 !
10091009 
 10101010         register TWORD ty;
 10111011 
<>1012 -        if( (ty=BTYPE(p->in.type)) == ENUMTY || ty == MOETY ) {
 1013 -                if (dimtab[p->fn.csiz] == SZCHAR)
  1012+        if( (ty=BTYPE(p->n_type)) == ENUMTY || ty == MOETY ) {
  1013+                if (dimtab[p->n_csiz] == SZCHAR)
10141014                         ty = CHAR;
<>1015 -                else if (dimtab[p->fn.csiz] == SZINT)
  1015+                else if (dimtab[p->n_csiz] == SZINT)
10161016                         ty = INT;
<>1017 -                else if (dimtab[p->fn.csiz] == SZSHORT)
  1017+                else if (dimtab[p->n_csiz] == SZSHORT)
10181018                         ty = SHORT;
<>1019 -                else if (dimtab[p->fn.csiz] == SZLONGLONG)
  1019+                else if (dimtab[p->n_csiz] == SZLONGLONG)
10201020                         ty = LONGLONG;
 10211021                 else
 10221022                         ty = LONG;
 10231023                 ty = ctype(ty);
<>1024 -                p->fn.csiz = ty;
 1025 -                MODTYPE(p->in.type,ty);
 1026 -                if (p->in.op == ICON && ty != LONG && ty != LONGLONG)
 1027 -                        p->in.type = p->fn.csiz = INT;
  1024+                p->n_csiz = ty;
  1025+                MODTYPE(p->n_type,ty);
  1026+                if (p->n_op == ICON && ty != LONG && ty != LONGLONG)
  1027+                        p->n_type = p->n_csiz = INT;
10281028                 }
 10291029         }
 10301030 #endif
     
 !
10341034 
 10351035         /* if p should be changed into a pointer, do so */
 10361036 
<>1037 -        if( ISARY( p->in.type) ){
 1038 -                p->in.type = DECREF( p->in.type );
 1039 -                ++p->fn.cdim;
  1037+        if( ISARY( p->n_type) ){
  1038+                p->n_type = DECREF( p->n_type );
  1039+                ++p->n_cdim;
10401040                 return( buildtree( UNARY AND, p, NIL ) );
 10411041                 }
<>1042 -        if( ISFTN( p->in.type) )
  1042+        if( ISFTN( p->n_type) )
10431043                 return( buildtree( UNARY AND, p, NIL ) );
 10441044 
 10451045         return( p );
     
 !
10491049 oconvert(p) register NODE *p; {
 10501050         /* convert the result itself: used for pointer and unsigned */
 10511051 
<>1052 -        switch(p->in.op) {
  1052+        switch(p->n_op) {
10531053 
 10541054         case LE:
 10551055         case LT:
 10561056         case GE:
 10571057         case GT:
<>1058 -                if( ISUNSIGNED(p->in.left->in.type) || ISUNSIGNED(p->in.right->in.type) )  p->in.op += (ULE-LE);
  1058+                if( ISUNSIGNED(p->n_left->n_type) || ISUNSIGNED(p->n_right->n_type) )  p->n_op += (ULE-LE);
10591059         case EQ:
 10601060         case NE:
 10611061                 return( p );
 10621062 
 10631063         case MINUS:
 10641064                 returnclocal( block( PVCONV,
<>1065 -                        p, bpsize(p->in.left), INT, 0, INT ) ) );
  1065+                        p, bpsize(p->n_left), INT, 0, INT ) ) );
10661066                 }
 10671067 
<>1068 -        cerror( "illegal oconvert: %d", p->in.op );
  1068+        cerror( "illegal oconvert: %d", p->n_op );
10691069 
 10701070         return(p);
 10711071         }
     
 !
10811081         TWORD t1, t2, t;
 10821082         int o, d2, d, s2, s;
 10831083 
<>1084 -        o = p->in.op;
 1085 -        t = t1 = p->in.left->in.type;
 1086 -        t2 = p->in.right->in.type;
 1087 -        d = p->in.left->fn.cdim;
 1088 -        d2 = p->in.right->fn.cdim;
 1089 -        s = p->in.left->fn.csiz;
 1090 -        s2 = p->in.right->fn.csiz;
  1084+        o = p->n_op;
  1085+        t = t1 = p->n_left->n_type;
  1086+        t2 = p->n_right->n_type;
  1087+        d = p->n_left->n_cdim;
  1088+        d2 = p->n_right->n_cdim;
  1089+        s = p->n_left->n_csiz;
  1090+        s2 = p->n_right->n_csiz;
10911091 
 10921092         switch( o ){
 10931093 
     
 !
10971097                 {  break; }
 10981098 
 10991099         case MINUS:
<>1100 -                {  if( psize(p->in.left) != psize(p->in.right) ){
  1100+                {  if( psize(p->n_left) != psize(p->n_right) ){
11011101                         uerror( "illegal pointer subtraction");
 11021102                         }
 11031103                    break;
     
 !
11351135                 break;
 11361136                 }
 11371137 
<>1138 -        p->in.left = makety( p->in.left, t, d, s );
 1139 -        p->in.right = makety( p->in.right, t, d, s );
  1138+        p->n_left = makety( p->n_left, t, d, s );
  1139+        p->n_right = makety( p->n_right, t, d, s );
11401140         if( o!=MINUS && !logop(o) ){
 11411141 
<>1142 -                p->in.type = t;
 1143 -                p->fn.cdim = d;
 1144 -                p->fn.csiz = s;
  1142+                p->n_type = t;
  1143+                p->n_cdim = d;
  1144+                p->n_csiz = s;
11451145                 }
 11461146 
 11471147         return(clocal(p));
     
 !
11651165         TWORD t1, t2, t, tu;
 11661166         int o, u;
 11671167 
<>1168 -        o = p->in.op;
  1168+        o = p->n_op;
11691169 
<>1170 -        t1 = p->in.left->in.type;
 1171 -        t2 = p->in.right->in.type;
  1170+        t1 = p->n_left->n_type;
  1171+        t2 = p->n_right->n_type;
11721172         if( (t1==UNDEF || t2==UNDEF) && o!=CAST )
 11731173                 uerror("void type illegal in expression");
 11741174 
     
 !
12021202                 t = INT;
 12031203 
 12041204         if( o == ASSIGN || o == CAST || o == RETURN ) {
<>1205 -                tu = p->in.left->in.type;
  1205+                tu = p->n_left->n_type;
12061206                 t = t1;
 12071207         } else {
 12081208                 tu = (u && UNSIGNABLE(t))?ENUNSIGN(t):t;
     
 !
12131213            are those involving FLOAT/DOUBLE, and those
 12141214            from LONG to INT and ULONG to UNSIGNED */
 12151215 
<>1216 -        if( (t != t1 || (u && !ISUNSIGNED(p->in.left->in.type))) && ! asgop(o) )
 1217 -                p->in.left = makety( p->in.left, tu, 0, (int)tu );
  1216+        if( (t != t1 || (u && !ISUNSIGNED(p->n_left->n_type))) && ! asgop(o) )
  1217+                p->n_left = makety( p->n_left, tu, 0, (int)tu );
12181218 
<>1219 -        if( t != t2 || (u && !ISUNSIGNED(p->in.right->in.type)) || o==CAST) {
  1219+        if( t != t2 || (u && !ISUNSIGNED(p->n_right->n_type)) || o==CAST) {
12201220                 if ( tu == ENUMTY ) {/* always asgop */
<>1221 -                        p->in.right = makety( p->in.right, INT, 0, INT );
 1222 -                        p->in.right->in.type = tu;
 1223 -                        p->in.right->fn.cdim = p->in.left->fn.cdim;
 1224 -                        p->in.right->fn.csiz = p->in.left->fn.csiz;
  1221+                        p->n_right = makety( p->n_right, INT, 0, INT );
  1222+                        p->n_right->n_type = tu;
  1223+                        p->n_right->n_cdim = p->n_left->n_cdim;
  1224+                        p->n_right->n_csiz = p->n_left->n_csiz;
12251225                         }
 12261226                 else
<>1227 -                        p->in.right = makety( p->in.right, tu, 0, (int)tu );
  1227+                        p->n_right = makety( p->n_right, tu, 0, (int)tu );
12281228         }
 12291229 
 12301230         if( asgop(o) ){
<>1231 -                p->in.type = p->in.left->in.type;
 1232 -                p->fn.cdim = p->in.left->fn.cdim;
 1233 -                p->fn.csiz = p->in.left->fn.csiz;
  1231+                p->n_type = p->n_left->n_type;
  1232+                p->n_cdim = p->n_left->n_cdim;
  1233+                p->n_csiz = p->n_left->n_csiz;
12341234                 }
 12351235         else if( !logop(o) ){
<>1236 -                p->in.type = tu;
 1237 -                p->fn.cdim = 0;
 1238 -                p->fn.csiz = t;
  1236+                p->n_type = tu;
  1237+                p->n_cdim = 0;
  1238+                p->n_csiz = t;
12391239                 }
 12401240 
 12411241 # ifndef BUG1
     
 !
12501250 makety( p, t, d, s ) register NODE *p; TWORD t; {
 12511251         /* make p into type t by inserting a conversion */
 12521252 
<>1253 -        if( p->in.type == ENUMTY && p->in.op == ICON ) econvert(p);
 1254 -        if( t == p->in.type ){
 1255 -                p->fn.cdim = d;
 1256 -                p->fn.csiz = s;
  1253+        if( p->n_type == ENUMTY && p->n_op == ICON ) econvert(p);
  1254+        if( t == p->n_type ){
  1255+                p->n_cdim = d;
  1256+                p->n_csiz = s;
12571257                 return( p );
 12581258                 }
 12591259 
     
 !
12621262                 return( block( PCONV, p, NIL, t, d, s ) );
 12631263                 }
 12641264 
<>1265 -        if( p->in.op == ICON ){
  1265+        if( p->n_op == ICON ){
12661266                 if (t == DOUBLE) {
<>1267 -                        p->in.op = DCON;
 1268 -                        if (ISUNSIGNED(p->in.type))
 1269 -                                p->dpn.dval = (U_CONSZ) p->tn.lval;
  1267+                        p->n_op = DCON;
  1268+                        if (ISUNSIGNED(p->n_type))
  1269+                                p->n_dcon = (U_CONSZ) p->n_lval;
12701270                         else
<>1271 -                                p->dpn.dval = p->tn.lval;
 1272 -                        p->in.type = p->fn.csiz = t;
  1271+                                p->n_dcon = p->n_lval;
  1272+                        p->n_type = p->n_csiz = t;
12731273                         return (clocal(p));
 12741274                 }
 12751275                 if (t == FLOAT) {
<>1276 -                        p->in.op = FCON;
 1277 -                        if( ISUNSIGNED(p->in.type) ){
 1278 -                                p->fpn.fval = (U_CONSZ) p->tn.lval;
  1276+                        p->n_op = FCON;
  1277+                        if( ISUNSIGNED(p->n_type) ){
  1278+                                p->n_fcon = (U_CONSZ) p->n_lval;
12791279                                 }
 12801280                         else {
<>1281 -                                p->fpn.fval = p->tn.lval;
  1281+                                p->n_fcon = p->n_lval;
12821282                                 }
 12831283 
<>1284 -                        p->in.type = p->fn.csiz = t;
  1284+                        p->n_type = p->n_csiz = t;
12851285                         return( clocal(p) );
 12861286                         }
 12871287                 }
<>1288 -        else if (p->in.op == FCON && t == DOUBLE) {
  1288+        else if (p->n_op == FCON && t == DOUBLE) {
12891289                 double db;
 12901290 
<>1291 -                p->in.op = DCON;
 1292 -                db = p->fpn.fval;
 1293 -                p->dpn.dval = db;
 1294 -                p->in.type = p->fn.csiz = t;
  1291+                p->n_op = DCON;
  1292+                db = p->n_fcon;
  1293+                p->n_dcon = db;
  1294+                p->n_type = p->n_csiz = t;
12951295                 return (clocal(p));
<>1296 -        } else if (p->in.op == DCON && t == FLOAT) {
  1296+        } else if (p->n_op == DCON && t == FLOAT) {
12971297                 float fl;
 12981298 
<>1299 -                p->in.op = FCON;
 1300 -                fl = p->dpn.dval;
  1299+                p->n_op = FCON;
  1300+                fl = p->n_dcon;
13011301 #ifdef notdef
<>1302 -                if (fl != p->dpn.dval)
  1302+                if (fl != p->n_dcon)
13031303                         werror("float conversion loses precision");
 13041304 #endif
<>1305 -                p->fpn.fval = fl;
 1306 -                p->in.type = p->fn.csiz = t;
  1305+                p->n_fcon = fl;
  1306+                p->n_type = p->n_csiz = t;
13071307                 return (clocal(p));
 13081308         }
 13091309 
     
 !
13171317         register NODE *p;
 13181318 
 13191319         p = talloc();
<>1320 -        p->tn.rval = 0;
 1321 -        p->in.op = o;
 1322 -        p->in.left = l;
 1323 -        p->in.right = r;
 1324 -        p->in.type = t;
 1325 -        p->in.su = 0;
 1326 -        p->fn.cdim = d;
 1327 -        p->fn.csiz = s;
  1320+        p->n_rval = 0;
  1321+        p->n_op = o;
  1322+        p->n_left = l;
  1323+        p->n_right = r;
  1324+        p->n_type = t;
  1325+        p->n_su = 0;
  1326+        p->n_cdim = d;
  1327+        p->n_csiz = s;
13281328         return(p);
 13291329         }
 13301330 
     
 !
13331333         /* if p is an integer constant, return its value */
 13341334         int val;
 13351335 
<>1336 -        if( p->in.op != ICON ){
  1336+        if( p->n_op != ICON ){
13371337                 uerror( "constant expected");
 13381338                 val = 1;
 13391339                 }
 13401340         else {
<>1341 -                val = p->tn.lval;
 1342 -                if( val != p->tn.lval ) uerror( "constant too big for cross-compiler" );
  1341+                val = p->n_lval;
  1342+                if( val != p->n_lval ) uerror( "constant too big for cross-compiler" );
13431343                 }
 13441344         tfree( p );
 13451345         return(val);
     
 !
13881388 
 13891389         mt1 = mt2 = mt12 = 0;
 13901390 
<>1391 -        switch (optype(o = p->in.op)) {
  1391+        switch (optype(o = p->n_op)) {
13921392         case BITYPE:
<>1393 -                mt2 = moditype(p->in.right->in.type);
  1393+                mt2 = moditype(p->n_right->n_type);
13941394         case UTYPE:
<>1395 -                mt1 = moditype(p->in.left->in.type);
  1395+                mt1 = moditype(p->n_left->n_type);
13961396                 break;
 13971397         }
 13981398 
     
 !
15031503                 if(o==CAST && mt1==MVOID)return(TYPL+TYMATCH);
 15041504                 else if( mt12 & MDBI ) return( TYPL+LVAL+NCVT+TYMATCH );
 15051505                 else if( mt2 == MVOID &&
<>1506 -                        ( p->in.right->in.op == CALL ||
 1507 -                          p->in.right->in.op == UNARY CALL)) break;
  1506+                        ( p->n_right->n_op == CALL ||
  1507+                          p->n_right->n_op == UNARY CALL)) break;
15081508                 else if( (mt1 & MPTR) && (mt2 & MPTI) )
 15091509                         return( LVAL+PTMATCH+PUN );
 15101510                 else if( mt12 & MPTI ) return( TYPL+LVAL+TYMATCH+PUN );
     
 !
16021602         int i;
 16031603 
 16041604         /* whatever is the meaning of this if it is a bitfield? */
<>1605 -        i = tsize( p->in.type, p->fn.cdim, p->fn.csiz )/SZCHAR;
  1605+        i = tsize( p->n_type, p->n_cdim, p->n_csiz )/SZCHAR;
16061606 
 16071607         tfree(p);
 16081608         if( i <= 0 ) werror( "sizeof returns 0" );
     
 !
16211621                 }
 16221622         if( down ) printf( "    " );
 16231623 
<>1624 -        ty = optype( p->in.op );
  1624+        ty = optype( p->n_op );
16251625 
<>1626 -        printf("%p) %s, ", p, opst[p->in.op] );
  1626+        printf("%p) %s, ", p, opst[p->n_op] );
16271627         if( ty == LTYPE ){
<>1628 -                printf( CONFMT, p->tn.lval );
 1629 -                printf( ", %d, ", p->tn.rval );
  1628+                printf( CONFMT, p->n_lval );
  1629+                printf( ", %d, ", p->n_rval );
16301630                 }
<>1631 -        tprint( p->in.type );
 1632 -        printf( ", %d, %d\n", p->fn.cdim, p->fn.csiz );
  1631+        tprint( p->n_type );
  1632+        printf( ", %d, %d\n", p->n_cdim, p->n_csiz );
16331633         return 0;
 16341634 }
 16351635 # endif
     
 !
16381638 void
 16391639 prtdcon(NODE *p)
 16401640 {
<>1641 -        int o = p->in.op, i;
  1641+        int o = p->n_op, i;
16421642 
 16431643         if( o == DCON || o == FCON ){
 16441644                 (void) locctr( DATA );
 16451645                 defalign( o == DCON ? ALDOUBLE : ALFLOAT );
 16461646                 deflab( i = getlab() );
 16471647                 if( o == FCON )
<>1648 -                        fincode( p->fpn.fval, SZFLOAT );
  1648+                        fincode( p->n_fcon, SZFLOAT );
16491649                 else
<>1650 -                        fincode( p->dpn.dval, SZDOUBLE );
 1651 -                p->tn.lval = 0;
 1652 -                p->tn.rval = -i;
 1653 -                p->in.type = (o == DCON ? DOUBLE : FLOAT);
 1654 -                p->in.op = NAME;
  1650+                        fincode( p->n_dcon, SZDOUBLE );
  1651+                p->n_lval = 0;
  1652+                p->n_rval = -i;
  1653+                p->n_type = (o == DCON ? DOUBLE : FLOAT);
  1654+                p->n_op = NAME;
16551655         }
 16561656 }
 16571657 #endif PRTDCON
     
 !
16851685         MYP2TREE(p);  /* local action can be taken here; then return... */
 16861686 # endif
 16871687 
<>1688 -        ty = optype(p->in.op);
  1688+        ty = optype(p->n_op);
16891689 
<>1690 -        switch( p->in.op ){
  1690+        switch( p->n_op ){
16911691 
 16921692         case NAME:
 16931693         case ICON:
<>1694 -                if( p->tn.rval == NONAME ) p->in.name = "";
 1695 -                else if( p->tn.rval >= 0 ){ /* copy name from exname */
  1694+                if( p->n_rval == NONAME ) p->n_name = "";
  1695+                else if( p->n_rval >= 0 ){ /* copy name from exname */
16961696                         register char *cp;
<>1697 -                        cp = exname( stab[p->tn.rval].sname );
  1697+                        cp = exname( stab[p->n_rval].sname );
16981698                         if (isinlining)
<>1699 -                                p->in.name = strdup(cp);
  1699+                                p->n_name = strdup(cp);
17001700                         else
<>1701 -                                p->in.name = tstr(cp);
  1701+                                p->n_name = tstr(cp);
17021702                         }
 17031703                 else {
 17041704                         char temp[32];
<>1705 -                        sprintf( temp, LABFMT, -p->tn.rval );
  1705+                        sprintf( temp, LABFMT, -p->n_rval );
17061706                         if (isinlining)
<>1707 -                                p->in.name = strdup(temp);
  1707+                                p->n_name = strdup(temp);
17081708                         else
<>1709 -                                p->in.name = tstr(temp);
  1709+                                p->n_name = tstr(temp);
17101710                 }
 17111711                 break;
 17121712 
     
 !
17151715         case STCALL:
 17161716         case UNARY STCALL:
 17171717                 /* set up size parameters */
<>1718 -                p->stn.stsize = (tsize(STRTY,p->in.left->fn.cdim,p->in.left->fn.csiz)+SZCHAR-1)/SZCHAR;
 1719 -                p->stn.stalign = talign(STRTY,p->in.left->fn.csiz)/SZCHAR;
  1718+                p->n_stsize = (tsize(STRTY,p->n_left->n_cdim,p->n_left->n_csiz)+SZCHAR-1)/SZCHAR;
  1719+                p->n_stalign = talign(STRTY,p->n_left->n_csiz)/SZCHAR;
17201720                 break;
 17211721 
 17221722         case REG:
<>1723 -                rbusy( p->tn.rval, p->in.type );
  1723+                rbusy( p->n_rval, p->n_type );
17241724         default:
<>1725 -                p->in.name = "";
  1725+                p->n_name = "";
17261726                 }
 17271727 
<>1728 -        p->in.rall = NOPREF;
  1728+        p->n_rall = NOPREF;
17291729 
<>1730 -        if( ty != LTYPE ) p2tree( p->in.left );
 1731 -        if( ty == BITYPE ) p2tree( p->in.right );
  1730+        if( ty != LTYPE ) p2tree( p->n_left );
  1731+        if( ty == BITYPE ) p2tree( p->n_right );
<_17321732         }
 17331733 
 17341734 # endif
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-18 14:28 +0100