UNIX 7th Ed. - /usr/src/cmd/c/c03.c

   1: #
   2: /*
   3:  * C compiler, phase 1
   4:  *
   5:  *
   6:  * Handles processing of declarations,
   7:  * except for top-level processing of
   8:  * externals.
   9:  */
  10: 
  11: #include "c0.h"
  12: 
  13: /*
  14:  * Process a sequence of declaration statements
  15:  */
  16: declist(sclass)
  17: {
  18:     register sc, offset;
  19:     struct hshtab typer;
  20: 
  21:     offset = 0;
  22:     sc = sclass;
  23:     while (getkeywords(&sclass, &typer)) {
  24:         offset = declare(sclass, &typer, offset);
  25:         sclass = sc;
  26:     }
  27:     return(offset+align(INT, offset, 0));
  28: }
  29: 
  30: /*
  31:  * Read the keywords introducing a declaration statement
  32:  * Store back the storage class, and fill in the type
  33:  * entry, which looks like a hash table entry.
  34:  */
  35: getkeywords(scptr, tptr)
  36: int *scptr;
  37: struct hshtab *tptr;
  38: {
  39:     register skw, tkw, longf;
  40:     int o, isadecl, ismos, unsignf;
  41: 
  42:     isadecl = 0;
  43:     longf = 0;
  44:     unsignf = 0;
  45:     tptr->htype = INT;
  46:     tptr->hstrp = NULL;
  47:     tptr->hsubsp = NULL;
  48:     tkw = -1;
  49:     skw = *scptr;
  50:     ismos = skw==MOS||skw==MOU;
  51:     for (;;) {
  52:         mosflg = ismos && isadecl;
  53:         o = symbol();
  54:         if (o==NAME && csym->hclass==TYPEDEF && tkw<0) {
  55:             tkw = csym->htype;
  56:             tptr->hsubsp = csym->hsubsp;
  57:             tptr->hstrp = csym->hstrp;
  58:             isadecl++;
  59:             continue;
  60:         }
  61:         switch (o==KEYW? cval: -1) {
  62:         case AUTO:
  63:         case STATIC:
  64:         case EXTERN:
  65:         case REG:
  66:         case TYPEDEF:
  67:             if (skw && skw!=cval) {
  68:                 if (skw==ARG && cval==REG)
  69:                     cval = AREG;
  70:                 else
  71:                     error("Conflict in storage class");
  72:             }
  73:             skw = cval;
  74:             break;
  75: 
  76:         case UNSIGN:
  77:             unsignf++;
  78:             break;
  79: 
  80:         case LONG:
  81:             longf++;
  82:             break;
  83: 
  84:         case ENUM:
  85:             strdec(ismos, cval);
  86:             cval = INT;
  87:             goto types;
  88: 
  89:         case UNION:
  90:         case STRUCT:
  91:             tptr->hstrp = strdec(ismos, cval);
  92:             cval = STRUCT;
  93:         case INT:
  94:         case CHAR:
  95:         case FLOAT:
  96:         case DOUBLE:
  97:         types:
  98:             if (tkw>=0)
  99:                 error("Type clash");
 100:             tkw = cval;
 101:             break;
 102: 
 103:         default:
 104:             peeksym = o;
 105:             if (isadecl==0)
 106:                 return(0);
 107:             if (tkw<0)
 108:                 tkw = INT;
 109:             if (skw==0)
 110:                 skw = blklev==0? DEFXTRN: AUTO;
 111:             if (unsignf) {
 112:                 if (tkw==INT)
 113:                     tkw = UNSIGN;
 114:                 else
 115:                     error("Misplaced 'unsigned'");
 116:             }
 117:             if (longf) {
 118:                 if (tkw==FLOAT)
 119:                     tkw = DOUBLE;
 120:                 else if (tkw==INT)
 121:                     tkw = LONG;
 122:                 else
 123:                     error("Misplaced 'long'");
 124:             }
 125:             *scptr = skw;
 126:             tptr->htype = tkw;
 127:             return(1);
 128:         }
 129:         isadecl++;
 130:     }
 131: }
 132: 
 133: /*
 134:  * Process a structure, union, or enum declaration; a subroutine
 135:  * of getkeywords.
 136:  */
 137: struct str *
 138: strdec(mosf, kind)
 139: {
 140:     register elsize, o;
 141:     register struct hshtab *ssym;
 142:     int savebits;
 143:     struct hshtab **savememlist;
 144:     int savenmems;
 145:     struct str *strp;
 146:     struct hshtab *ds;
 147:     struct hshtab *mems[NMEMS];
 148:     struct hshtab typer;
 149:     int tagkind;
 150: 
 151:     if (kind!=ENUM) {
 152:         tagkind = STRTAG;
 153:         mosflg = 1;
 154:     } else
 155:         tagkind = ENUMTAG;
 156:     ssym = 0;
 157:     if ((o=symbol())==NAME) {
 158:         ssym = csym;
 159:         mosflg = mosf;
 160:         o = symbol();
 161:         if (o==LBRACE && ssym->hblklev<blklev)
 162:             pushdecl(ssym);
 163:         if (ssym->hclass==0) {
 164:             ssym->hclass = tagkind;
 165:             ssym->strp = gblock(sizeof(*strp));
 166:             funcbase = curbase;
 167:             ssym->strp->ssize = 0;
 168:             ssym->strp->memlist = NULL;
 169:         }
 170:         if (ssym->hclass != tagkind)
 171:             redec();
 172:         strp = ssym->strp;
 173:     } else {
 174:         strp = gblock(sizeof(*strp));
 175:         funcbase = curbase;
 176:         strp->ssize = 0;
 177:         strp->memlist = NULL;
 178:     }
 179:     mosflg = 0;
 180:     if (o != LBRACE) {
 181:         if (ssym==0)
 182:             goto syntax;
 183:         if (ssym->hclass!=tagkind)
 184:             error("Bad structure/union/enum name");
 185:         peeksym = o;
 186:     } else {
 187:         ds = defsym;
 188:         mosflg = 0;
 189:         savebits = bitoffs;
 190:         savememlist = memlist;
 191:         savenmems = nmems;
 192:         memlist = mems;
 193:         nmems = 2;
 194:         bitoffs = 0;
 195:         if (kind==ENUM) {
 196:             typer.htype = INT;
 197:             typer.hstrp = strp;
 198:             declare(ENUM, &typer, 0);
 199:         } else
 200:             elsize = declist(kind==UNION?MOU:MOS);
 201:         bitoffs = savebits;
 202:         defsym = ds;
 203:         if (strp->ssize)
 204:             error("%.8s redeclared", ssym->name);
 205:         strp->ssize = elsize;
 206:         *memlist++ = NULL;
 207:         strp->memlist = gblock((memlist-mems)*sizeof(*memlist));
 208:         funcbase = curbase;
 209:         for (o=0; &mems[o] != memlist; o++)
 210:             strp->memlist[o] = mems[o];
 211:         memlist = savememlist;
 212:         nmems = savenmems;
 213:         if ((o = symbol()) != RBRACE)
 214:             goto syntax;
 215:     }
 216:     return(strp);
 217:    syntax:
 218:     decsyn(o);
 219:     return(0);
 220: }
 221: 
 222: /*
 223:  * Process a comma-separated list of declarators
 224:  */
 225: declare(askw, tptr, offset)
 226: struct hshtab *tptr;
 227: {
 228:     register int o;
 229:     register int skw, isunion;
 230: 
 231:     skw = askw;
 232:     isunion = 0;
 233:     if (skw==MOU) {
 234:         skw = MOS;
 235:         isunion++;
 236:         mosflg = 1;
 237:         if ((peeksym=symbol()) == SEMI) {
 238:             o = length(tptr);
 239:             if (o>offset)
 240:                 offset = o;
 241:         }
 242:     }
 243:     do {
 244:         if (skw==ENUM && (peeksym=symbol())==RBRACE) {
 245:             o = peeksym;
 246:             peeksym = -1;
 247:             break;
 248:         }
 249:         o = decl1(skw, tptr, isunion?0:offset, NULL);
 250:         if (isunion) {
 251:             o =+ align(CHAR, o, 0);
 252:             if (o>offset)
 253:                 offset = o;
 254:         } else
 255:             offset =+ o;
 256:     } while ((o=symbol()) == COMMA);
 257:     if (o==RBRACE) {
 258:         peeksym = o;
 259:         o = SEMI;
 260:     }
 261:     if (o!=SEMI && (o!=RPARN || skw!=ARG1))
 262:         decsyn(o);
 263:     return(offset);
 264: }
 265: 
 266: /*
 267:  * Process a single declarator
 268:  */
 269: decl1(askw, atptr, offset, absname)
 270: struct hshtab *atptr, *absname;
 271: {
 272:     int t1, chkoff, a, elsize;
 273:     register int skw;
 274:     int type;
 275:     register struct hshtab *dsym;
 276:     register struct hshtab *tptr;
 277:     struct tdim dim;
 278:     struct field *fldp;
 279:     int *dp;
 280:     int isinit;
 281: 
 282:     skw = askw;
 283:     tptr = atptr;
 284:     chkoff = 0;
 285:     mosflg = skw==MOS;
 286:     dim.rank = 0;
 287:     if (((peeksym=symbol())==SEMI || peeksym==RPARN) && absname==NULL)
 288:         return(0);
 289:     /*
 290: 	 * Filler field
 291: 	 */
 292:     if (peeksym==COLON && skw==MOS) {
 293:         peeksym = -1;
 294:         t1 = conexp();
 295:         elsize = align(tptr->htype, offset, t1);
 296:         bitoffs =+ t1;
 297:         return(elsize);
 298:     }
 299:     t1 = getype(&dim, absname);
 300:     if (t1 == -1)
 301:         return(0);
 302:     if (tptr->hsubsp) {
 303:         type = tptr->htype;
 304:         for (a=0; type&XTYPE;) {
 305:             if ((type&XTYPE)==ARRAY)
 306:                 dim.dimens[dim.rank++] = tptr->hsubsp[a++];
 307:             type =>> TYLEN;
 308:         }
 309:     }
 310:     type = tptr->htype & ~TYPE;
 311:     while (t1&XTYPE) {
 312:         if (type&BIGTYPE) {
 313:             typov();
 314:             type = t1 = 0;
 315:         }
 316:         type = type<<TYLEN | (t1 & XTYPE);
 317:         t1 =>> TYLEN;
 318:     }
 319:     type =| tptr->htype&TYPE;
 320:     if (absname)
 321:         defsym = absname;
 322:     dsym = defsym;
 323:     if (dsym->hblklev < blklev)
 324:         pushdecl(dsym);
 325:     if (dim.rank == 0)
 326:         dsym->subsp = NULL;
 327:     else {
 328:         dp = gblock(dim.rank*sizeof(dim.rank));
 329:         funcbase = curbase;
 330:         if (skw==EXTERN)
 331:             maxdecl = curbase;
 332:         for (a=0; a<dim.rank; a++) {
 333:             if ((t1 = dp[a] = dim.dimens[a])
 334:              && (dsym->htype&XTYPE) == ARRAY
 335:              && dsym->subsp[a] && t1!=dsym->subsp[a])
 336:                 redec();
 337:         }
 338:         dsym->subsp = dp;
 339:     }
 340:     if ((type&XTYPE) == FUNC) {
 341:         if (skw==AUTO)
 342:             skw = EXTERN;
 343:         if ((skw!=EXTERN && skw!=TYPEDEF) && absname==NULL)
 344:             error("Bad func. storage class");
 345:     }
 346:     if (!(dsym->hclass==0
 347:        || ((skw==ARG||skw==AREG) && dsym->hclass==ARG1)
 348:        || (skw==EXTERN && dsym->hclass==EXTERN && dsym->htype==type)))
 349:         if (skw==MOS && dsym->hclass==MOS && dsym->htype==type)
 350:             chkoff = 1;
 351:         else {
 352:             redec();
 353:             goto syntax;
 354:         }
 355:     if (dsym->hclass && (dsym->htype&TYPE)==STRUCT && (type&TYPE)==STRUCT)
 356:         if (dsym->hstrp != tptr->hstrp) {
 357:             error("Warning: structure redeclaration");
 358:             nerror--;
 359:         }
 360:     dsym->htype = type;
 361:     if (tptr->hstrp)
 362:         dsym->hstrp = tptr->hstrp;
 363:     if (skw==TYPEDEF) {
 364:         dsym->hclass = TYPEDEF;
 365:         return(0);
 366:     }
 367:     if (absname)
 368:         return(0);
 369:     if (skw==ARG1) {
 370:         if (paraml==0)
 371:             paraml = dsym;
 372:         else
 373:             parame->hoffset = dsym;
 374:         parame = dsym;
 375:         dsym->hclass = skw;
 376:         return(0);
 377:     }
 378:     elsize = 0;
 379:     if (skw==MOS) {
 380:         elsize = length(dsym);
 381:         if ((peeksym = symbol())==COLON) {
 382:             elsize = 0;
 383:             peeksym = -1;
 384:             t1 = conexp();
 385:             a = align(type, offset, t1);
 386:             if (dsym->hflag&FFIELD) {
 387:                 if (dsym->hstrp->bitoffs!=bitoffs
 388:                  || dsym->hstrp->flen!=t1)
 389:                     redec();
 390:             } else {
 391:                 dsym->hstrp = gblock(sizeof(*fldp));
 392:                 funcbase = curbase;
 393:             }
 394:             dsym->hflag =| FFIELD;
 395:             dsym->hstrp->bitoffs = bitoffs;
 396:             dsym->hstrp->flen = t1;
 397:             bitoffs =+ t1;
 398:         } else
 399:             a = align(type, offset, 0);
 400:         elsize =+ a;
 401:         offset =+ a;
 402:         if (++nmems >= NMEMS) {
 403:             error("Too many structure members");
 404:             nmems =- NMEMS/2;
 405:             memlist =- NMEMS/2;
 406:         }
 407:         if (a)
 408:             *memlist++ = &structhole;
 409:         if (chkoff && dsym->hoffset != offset)
 410:             redec();
 411:         dsym->hoffset = offset;
 412:         *memlist++ = dsym;
 413:     }
 414:     if (skw==REG)
 415:         if ((dsym->hoffset = goodreg(dsym)) < 0)
 416:             skw = AUTO;
 417:     dsym->hclass = skw;
 418:     isinit = 0;
 419:     if ((a=symbol())!=COMMA && a!=SEMI && a!=RBRACE)
 420:         isinit++;
 421:     if (a!=ASSIGN)
 422:         peeksym = a;
 423:     if (skw==AUTO) {
 424:     /*	if (STAUTO < 0) {	*/
 425:             autolen =- rlength(dsym);
 426:             dsym->hoffset = autolen;
 427:             if (autolen < maxauto)
 428:                 maxauto = autolen;
 429:     /*	} else { 			*/
 430:     /*		dsym->hoffset = autolen;	*/
 431:     /*		autolen =+ rlength(dsym);	*/
 432:     /*		if (autolen > maxauto)		*/
 433:     /*			maxauto = autolen;	*/
 434:     /*	}			*/
 435:         if (isinit)
 436:             cinit(dsym, 0, AUTO);
 437:     } else if (skw==STATIC) {
 438:         dsym->hoffset = isn;
 439:         if (isinit) {
 440:             outcode("BBN", DATA, LABEL, isn++);
 441:             if (cinit(dsym, 1, STATIC) & ALIGN)
 442:                 outcode("B", EVEN);
 443:         } else
 444:             outcode("BBNBN", BSS, LABEL, isn++, SSPACE, rlength(dsym));
 445:         outcode("B", PROG);
 446:     } else if (skw==REG && isinit)
 447:         cinit(dsym, 0, REG);
 448:     else if (skw==ENUM) {
 449:         if (type!=INT)
 450:             error("Illegal enumeration %.8s", dsym->name);
 451:         dsym->hclass = ENUMCON;
 452:         dsym->hoffset = offset;
 453:         if (isinit)
 454:             cinit(dsym, 0, ENUMCON);
 455:         elsize = dsym->hoffset-offset+1;
 456:     }
 457:     prste(dsym);
 458: syntax:
 459:     return(elsize);
 460: }
 461: 
 462: /*
 463:  * Push down an outer-block declaration
 464:  * after redeclaration in an inner block.
 465:  */
 466: pushdecl(asp)
 467: struct phshtab *asp;
 468: {
 469:     register struct phshtab *sp, *nsp;
 470: 
 471:     sp = asp;
 472:     nsp = gblock(sizeof(*nsp));
 473:     maxdecl = funcbase = curbase;
 474:     cpysymb(nsp, sp);
 475:     sp->hclass = 0;
 476:     sp->hflag =& (FKEYW|FMOS);
 477:     sp->htype = 0;
 478:     sp->hoffset = 0;
 479:     sp->hblklev = blklev;
 480:     sp->hpdown = nsp;
 481: }
 482: 
 483: /*
 484:  * Copy the non-name part of a symbol
 485:  */
 486: cpysymb(s1, s2)
 487: struct phshtab *s1, *s2;
 488: {
 489:     register struct phshtab *rs1, *rs2;
 490: 
 491:     rs1 = s1;
 492:     rs2 = s2;
 493:     rs1->hclass = rs2->hclass;
 494:     rs1->hflag = rs2->hflag;
 495:     rs1->htype = rs2->htype;
 496:     rs1->hoffset = rs2->hoffset;
 497:     rs1->hsubsp = rs2->hsubsp;
 498:     rs1->hstrp = rs2->hstrp;
 499:     rs1->hblklev = rs2->hblklev;
 500:     rs1->hpdown = rs2->hpdown;
 501: }
 502: 
 503: 
 504: /*
 505:  * Read a declarator and get the implied type
 506:  */
 507: getype(adimp, absname)
 508: struct tdim *adimp;
 509: struct hshtab *absname;
 510: {
 511:     static struct hshtab argtype;
 512:     int type;
 513:     register int o;
 514:     register struct hshtab *ds;
 515:     register struct tdim *dimp;
 516: 
 517:     ds = defsym;
 518:     dimp = adimp;
 519:     type = 0;
 520:     switch(o=symbol()) {
 521: 
 522:     case TIMES:
 523:         type = getype(dimp, absname);
 524:         if (type==-1)
 525:             return(type);
 526:         if (type&BIGTYPE) {
 527:             typov();
 528:             type = 0;
 529:         }
 530:         return(type<<TYLEN | PTR);
 531: 
 532:     case LPARN:
 533:         if (absname==NULL || nextchar()!=')') {
 534:             type = getype(dimp, absname);
 535:             if (type==-1)
 536:                 return(type);
 537:             ds = defsym;
 538:             if ((o=symbol()) != RPARN)
 539:                 goto syntax;
 540:             goto getf;
 541:         }
 542: 
 543:     default:
 544:         peeksym = o;
 545:         if (absname) {
 546:             defsym = ds = absname;
 547:             absname = NULL;
 548:             goto getf;
 549:         }
 550:         break;
 551: 
 552:     case NAME:
 553:         defsym = ds = csym;
 554:     getf:
 555:         switch(o=symbol()) {
 556: 
 557:         case LPARN:
 558:             if (blklev==0) {
 559:                 blklev++;
 560:                 ds = defsym;
 561:                 declare(ARG1, &argtype, 0);
 562:                 defsym = ds;
 563:                 blklev--;
 564:             } else
 565:                 if ((o=symbol()) != RPARN)
 566:                     goto syntax;
 567:             if (type&BIGTYPE) {
 568:                 typov();
 569:                 type = 0;
 570:             }
 571:             type = type<<TYLEN | FUNC;
 572:             goto getf;
 573: 
 574:         case LBRACK:
 575:             if (dimp->rank>=5) {
 576:                 error("Rank too large");
 577:                 dimp->rank = 4;
 578:             }
 579:             if ((o=symbol()) != RBRACK) {
 580:                 peeksym = o;
 581:                 cval = conexp();
 582:                 defsym = ds;
 583:                 if ((o=symbol())!=RBRACK)
 584:                     goto syntax;
 585:             } else {
 586:                 if (dimp->rank!=0)
 587:                     error("Null dimension");
 588:                 cval = 0;
 589:             }
 590:             dimp->dimens[dimp->rank++] = cval;
 591:             if (type&BIGTYPE) {
 592:                 typov();
 593:                 type = 0;
 594:             }
 595:             type = type<<TYLEN | ARRAY;
 596:             goto getf;
 597:         }
 598:         peeksym = o;
 599:         return(type);
 600:     }
 601: syntax:
 602:     decsyn(o);
 603:     return(-1);
 604: }
 605: 
 606: /*
 607:  * More bits required for type than allowed.
 608:  */
 609: typov()
 610: {
 611:     error("Type is too complicated");
 612: }
 613: 
 614: /*
 615:  * Enforce alignment restrictions in structures,
 616:  * including bit-field considerations.
 617:  */
 618: align(type, offset, aflen)
 619: {
 620:     register a, t, flen;
 621:     char *ftl;
 622: 
 623:     flen = aflen;
 624:     a = offset;
 625:     t = type;
 626:     ftl = "Field too long";
 627:     if (flen==0) {
 628:         a =+ (NBPC+bitoffs-1) / NBPC;
 629:         bitoffs = 0;
 630:     }
 631:     while ((t&XTYPE)==ARRAY)
 632:         t = decref(t);
 633:     if (t!=CHAR) {
 634:         a = (a+ALIGN) & ~ALIGN;
 635:         if (a>offset)
 636:             bitoffs = 0;
 637:     }
 638:     if (flen) {
 639:         if (type==INT || type==UNSIGN) {
 640:             if (flen > NBPW)
 641:                 error(ftl);
 642:             if (flen+bitoffs > NBPW) {
 643:                 bitoffs = 0;
 644:                 a =+ NCPW;
 645:             }
 646:         } else if (type==CHAR) {
 647:             if (flen > NBPC)
 648:                 error(ftl);
 649:             if (flen+bitoffs > NBPC) {
 650:                 bitoffs = 0;
 651:                 a =+ 1;
 652:             }
 653:         } else
 654:             error("Bad type for field");
 655:     }
 656:     return(a-offset);
 657: }
 658: 
 659: /*
 660:  * Complain about syntax error in declaration
 661:  */
 662: decsyn(o)
 663: {
 664:     error("Declaration syntax");
 665:     errflush(o);
 666: }
 667: 
 668: /*
 669:  * Complain about a redeclaration
 670:  */
 671: redec()
 672: {
 673:     error("%.8s redeclared", defsym->name);
 674: }
 675: 
 676: /*
 677:  * Determine if a variable is suitable for storage in
 678:  * a register; if so return the register number
 679:  */
 680: goodreg(hp)
 681: struct hshtab *hp;
 682: {
 683:     int type;
 684: 
 685:     type = hp->htype;
 686:     /*
 687: 	 * Special dispensation for unions
 688: 	 */
 689:     if (type==STRUCT && length(hp)<=SZINT)
 690:         type = INT;
 691:     if ((type!=INT && type!=CHAR && type!=UNSIGN && (type&XTYPE)==0)
 692:      || (type&XTYPE)>PTR || regvar<3)
 693:         return(-1);
 694:     return(--regvar);
 695: }

Defined functions