home *** CD-ROM | disk | FTP | other *** search
/ minnie.tuhs.org / unixen.tar / unixen / PDP-11 / Trees / V7 / usr / src / cmd / c / c02.c < prev    next >
Encoding:
C/C++ Source or Header  |  1979-05-03  |  14.3 KB  |  793 lines
  1. #
  2. /* C compiler
  3.  *
  4.  *
  5.  */
  6.  
  7. #include "c0.h"
  8.  
  9. /*
  10.  * Process a single external definition
  11.  */
  12. extdef()
  13. {
  14.     register o;
  15.     int sclass, scflag, *cb;
  16.     struct hshtab typer;
  17.     register struct hshtab *ds;
  18.  
  19.     if(((o=symbol())==EOFC) || o==SEMI)
  20.         return;
  21.     peeksym = o;
  22.     sclass = 0;
  23.     blklev = 0;
  24.     if (getkeywords(&sclass, &typer)==0) {
  25.         sclass = EXTERN;
  26.         if (peeksym!=NAME)
  27.             goto syntax;
  28.     }
  29.     scflag = 0;
  30.     if (sclass==DEFXTRN) {
  31.         scflag++;
  32.         sclass = EXTERN;
  33.     }
  34.     if (sclass!=EXTERN && sclass!=STATIC && sclass!=TYPEDEF)
  35.         error("Illegal storage class");
  36.     do {
  37.         defsym = 0;
  38.         paraml = 0;
  39.         parame = 0;
  40.         if (sclass==TYPEDEF) {
  41.             decl1(TYPEDEF, &typer, 0, NULL);
  42.             continue;
  43.         }
  44.         decl1(EXTERN, &typer, 0, NULL);
  45.         if ((ds=defsym)==0)
  46.             return;
  47.         funcsym = ds;
  48.         if ((ds->type&XTYPE)==FUNC) {
  49.             if ((peeksym=symbol())==LBRACE || peeksym==KEYW
  50.              || (peeksym==NAME && csym->hclass==TYPEDEF)) {
  51.                 funcblk.type = decref(ds->type);
  52.                 funcblk.strp = ds->strp;
  53.                 setinit(ds);
  54.                 outcode("BS", SYMDEF, sclass==EXTERN?ds->name:"");
  55.                 cfunc();
  56.                 return;
  57.             }
  58.             if (paraml)
  59.                 error("Inappropriate parameters");
  60.         } else if ((o=symbol())==COMMA || o==SEMI) {
  61.             peeksym = o;
  62.             o = (length(ds)+ALIGN) & ~ALIGN;
  63.             if (sclass==STATIC) {
  64.                 setinit(ds);
  65.                 outcode("BSBBSBN", SYMDEF, "", BSS, NLABEL, ds->name, SSPACE, o);
  66.             } else if (scflag)
  67.                 outcode("BSN", CSPACE, ds->name, o);
  68.         } else {
  69.             if (o!=ASSIGN)
  70.                 peeksym = o;
  71.             setinit(ds);
  72.             if (sclass==EXTERN)
  73.                 outcode("BS", SYMDEF, ds->name);
  74.             outcode("BBS", DATA, NLABEL, ds->name);
  75.             cb = funcbase;
  76.             if (cinit(ds, 1, sclass) & ALIGN)
  77.                 outcode("B", EVEN);
  78.             if (maxdecl > cb)
  79.                 cb = maxdecl;
  80.             funcbase = cb;
  81.         }
  82.     } while ((o=symbol())==COMMA);
  83.     if (o==SEMI)
  84.         return;
  85. syntax:
  86.     if (o==RBRACE) {
  87.         error("Too many }'s");
  88.         peeksym = 0;
  89.         return;
  90.     }
  91.     error("External definition syntax");
  92.     errflush(o);
  93.     statement();
  94. }
  95.  
  96. /*
  97.  * Process a function definition.
  98.  */
  99. cfunc()
  100. {
  101.     register int *cb;
  102.     register sloc;
  103.  
  104.     sloc = isn;
  105.     isn =+ 2;
  106.     outcode("BBS", PROG, RLABEL, funcsym->name);
  107.     if (proflg)
  108.         outcode("BN", PROFIL, isn++);
  109.     cb = curbase;
  110.     regvar = 5;
  111.     autolen = STAUTO;
  112.     maxauto = STAUTO;
  113.     blklev = 1;
  114.     declist(ARG);
  115.     outcode("B", SAVE);
  116.     funchead();
  117.     branch(sloc);
  118.     label(sloc+1);
  119.     retlab = isn++;
  120.     blklev = 0;
  121.     if ((peeksym = symbol()) != LBRACE)
  122.         error("Compound statement required");
  123.     statement();
  124.     outcode("BNB", LABEL, retlab, RETRN);
  125.     label(sloc);
  126.     outcode("BN", SETSTK, -maxauto);
  127.     branch(sloc+1);
  128.     if (cb < maxdecl)
  129.         cb = maxdecl;
  130.     curbase = funcbase = cb;
  131. }
  132.  
  133. /*
  134.  * Process the initializers for an external definition.
  135.  */
  136. cinit(anp, flex, sclass)
  137. struct hshtab *anp;
  138. {
  139.     register struct phshtab *np;
  140.     register nel, ninit;
  141.     int width, isarray, o, brace, realtype, *cb;
  142.     struct tnode *s;
  143.  
  144.     cb = funcbase;
  145.     np = gblock(sizeof(*np));
  146.     funcbase = curbase;
  147.     cpysymb(np, anp);
  148.     realtype = np->type;
  149.     isarray = 0;
  150.     if ((realtype&XTYPE) == ARRAY)
  151.         isarray++;
  152.     else
  153.         flex = 0;
  154.     width = length(np);
  155.     nel = 1;
  156.     /*
  157.      * If it's an array, find the number of elements.
  158.      * temporarily modify to look like kind of thing it's
  159.      * an array of.
  160.      */
  161.     if (sclass==AUTO)
  162.         if (isarray || realtype==STRUCT)
  163.             error("No auto. aggregate initialization");
  164.     if (isarray) {
  165.         np->type = decref(realtype);
  166.         np->subsp++;
  167.         if (width==0 && flex==0)
  168.             error("0-length row: %.8s", anp->name);
  169.         o = length(np);
  170.         /* nel = ldiv(0, width, o); */
  171.         nel = (unsigned)width/o;
  172.         width = o;
  173.     }
  174.     brace = 0;
  175.     if ((peeksym=symbol())==LBRACE && (isarray || np->type!=STRUCT)) {
  176.         peeksym = -1;
  177.         brace++;
  178.     }
  179.     ninit = 0;
  180.     do {
  181.         if ((o=symbol())==RBRACE)
  182.             break;
  183.         peeksym = o;
  184.         if (o==STRING && realtype==ARRAY+CHAR) {
  185.             if (sclass==AUTO)
  186.                 error("No strings in automatic");
  187.             peeksym = -1;
  188.             putstr(0, flex?10000:nel);
  189.             ninit =+ nchstr;
  190.             o = symbol();
  191.             break;
  192.         } else if (np->type==STRUCT) {
  193.             strinit(np, sclass);
  194.         } else if ((np->type&ARRAY)==ARRAY || peeksym==LBRACE)
  195.             cinit(np, 0, sclass);
  196.         else {
  197.             initflg++;
  198.             s = tree();
  199.             initflg = 0;
  200.             if (np->hflag&FFIELD)
  201.                 error("No field initialization");
  202.             *cp++ = nblock(np);
  203.             *cp++ = s;
  204.             build(ASSIGN);
  205.             if (sclass==AUTO||sclass==REG)
  206.                 rcexpr(*--cp);
  207.             else if (sclass==ENUMCON) {
  208.                 if (s->op!=CON)
  209.                     error("Illegal enum constant for %.8s", anp->name);
  210.                 anp->hoffset = s->value;
  211.             } else
  212.                 rcexpr(block(INIT,np->type,NULL,NULL,(*--cp)->tr2));
  213.         }
  214.         ninit++;
  215.         if ((ninit&077)==0 && sclass==EXTERN)
  216.             outcode("BS", SYMDEF, "");
  217.     } while ((o=symbol())==COMMA && (ninit<nel || brace || flex));
  218.     if (brace==0 || o!=RBRACE)
  219.         peeksym = o;
  220.     /*
  221.      * If there are too few initializers, allocate
  222.      * more storage.
  223.      * If there are too many initializers, extend
  224.      * the declared size for benefit of "sizeof"
  225.      */
  226.     if (ninit<nel && sclass!=AUTO)
  227.         outcode("BN", SSPACE, (nel-ninit)*width);
  228.     else if (ninit>nel) {
  229.         if (flex && nel==0) {
  230.             np->subsp[-1] = ninit;
  231.         } else
  232.             error("Too many initializers: %.8s", anp->name);
  233.         nel = ninit;
  234.     }
  235.     curbase = funcbase = cb;
  236.     return(nel*width);
  237. }
  238.  
  239. /*
  240.  * Initialize a structure
  241.  */
  242. strinit(np, sclass)
  243. struct tnode *np;
  244. {
  245.     register struct hshtab **mlp;
  246.     static zerloc;
  247.     register int o, brace;
  248.  
  249.     if ((mlp = np->strp->memlist)==NULL) {
  250.         mlp = &zerloc;
  251.         error("Undefined structure initialization");
  252.     }
  253.     brace = 0;
  254.     if ((o = symbol()) == LBRACE)
  255.         brace++;
  256.     else
  257.         peeksym = o;
  258.     do {
  259.         if ((o=symbol()) == RBRACE)
  260.             break;
  261.         peeksym = o;
  262.         if (*mlp==0) {
  263.             error("Too many structure initializers");
  264.             cinit(&funcblk, 0, sclass);
  265.         } else
  266.             cinit(*mlp++, 0, sclass);
  267.         if (*mlp ==  &structhole) {
  268.             outcode("B", EVEN);
  269.             mlp++;
  270.         }
  271.     } while ((o=symbol())==COMMA && (*mlp || brace));
  272.     if (sclass!=AUTO && sclass!=REG) {
  273.         if (*mlp)
  274.             outcode("BN", SSPACE, np->strp->ssize - (*mlp)->hoffset);
  275.         outcode("B", EVEN);
  276.     }
  277.     if (o!=RBRACE || brace==0)
  278.         peeksym = o;
  279. }
  280.  
  281. /*
  282.  * Mark already initialized
  283.  */
  284. setinit(anp)
  285. struct hshtab *anp;
  286. {
  287.     register struct hshtab *np;
  288.  
  289.     np = anp;
  290.     if (np->hflag&FINIT)
  291.         error("%s multiply defined", np->name);
  292.     np->hflag =| FINIT;
  293. }
  294.  
  295. /*
  296.  * Process one statement in a function.
  297.  */
  298. statement()
  299. {
  300.     register o, o1, o2;
  301.     int o3;
  302.     struct tnode *np;
  303.     int sauto, sreg;
  304.  
  305. stmt:
  306.     switch(o=symbol()) {
  307.  
  308.     case EOFC:
  309.         error("Unexpected EOF");
  310.     case SEMI:
  311.         return;
  312.  
  313.     case LBRACE:
  314.         sauto = autolen;
  315.         sreg = regvar;
  316.         blockhead();
  317.         while (!eof) {
  318.             if ((o=symbol())==RBRACE) {
  319.                 autolen = sauto;
  320.                 if (sreg!=regvar)
  321.                     outcode("BN", SETREG, sreg);
  322.                 regvar = sreg;
  323.                 blkend();
  324.                 return;
  325.             }
  326.             peeksym = o;
  327.             statement();
  328.         }
  329.         error("Missing '}'");
  330.         return;
  331.  
  332.     case KEYW:
  333.         switch(cval) {
  334.  
  335.         case GOTO:
  336.             if (o1 = simplegoto())
  337.                 branch(o1);
  338.             else 
  339.                 dogoto();
  340.             goto semi;
  341.  
  342.         case RETURN:
  343.             doret();
  344.             goto semi;
  345.  
  346.         case IF:
  347.             np = pexpr();
  348.             o2 = 0;
  349.             if ((o1=symbol())==KEYW) switch (cval) {
  350.             case GOTO:
  351.                 if (o2=simplegoto())
  352.                     goto simpif;
  353.                 cbranch(np, o2=isn++, 0);
  354.                 dogoto();
  355.                 label(o2);
  356.                 goto hardif;
  357.  
  358.             case RETURN:
  359.                 if (nextchar()==';') {
  360.                     o2 = retlab;
  361.                     goto simpif;
  362.                 }
  363.                 cbranch(np, o1=isn++, 0);
  364.                 doret();
  365.                 label(o1);
  366.                 o2++;
  367.                 goto hardif;
  368.  
  369.             case BREAK:
  370.                 o2 = brklab;
  371.                 goto simpif;
  372.  
  373.             case CONTIN:
  374.                 o2 = contlab;
  375.             simpif:
  376.                 chconbrk(o2);
  377.                 cbranch(np, o2, 1);
  378.             hardif:
  379.                 if ((o=symbol())!=SEMI)
  380.                     goto syntax;
  381.                 if ((o1=symbol())==KEYW && cval==ELSE) 
  382.                     goto stmt;
  383.                 peeksym = o1;
  384.                 return;
  385.             }
  386.             peeksym = o1;
  387.             cbranch(np, o1=isn++, 0);
  388.             statement();
  389.             if ((o=symbol())==KEYW && cval==ELSE) {
  390.                 o2 = isn++;
  391.                 branch(o2);
  392.                 label(o1);
  393.                 statement();
  394.                 label(o2);
  395.                 return;
  396.             }
  397.             peeksym = o;
  398.             label(o1);
  399.             return;
  400.  
  401.         case WHILE:
  402.             o1 = contlab;
  403.             o2 = brklab;
  404.             label(contlab = isn++);
  405.             cbranch(pexpr(), brklab=isn++, 0);
  406.             statement();
  407.             branch(contlab);
  408.             label(brklab);
  409.             contlab = o1;
  410.             brklab = o2;
  411.             return;
  412.  
  413.         case BREAK:
  414.             chconbrk(brklab);
  415.             branch(brklab);
  416.             goto semi;
  417.  
  418.         case CONTIN:
  419.             chconbrk(contlab);
  420.             branch(contlab);
  421.             goto semi;
  422.  
  423.         case DO:
  424.             o1 = contlab;
  425.             o2 = brklab;
  426.             contlab = isn++;
  427.             brklab = isn++;
  428.             label(o3 = isn++);
  429.             statement();
  430.             label(contlab);
  431.             contlab = o1;
  432.             if ((o=symbol())==KEYW && cval==WHILE) {
  433.                 cbranch(tree(), o3, 1);
  434.                 label(brklab);
  435.                 brklab = o2;
  436.                 goto semi;
  437.             }
  438.             goto syntax;
  439.  
  440.         case CASE:
  441.             o1 = conexp();
  442.             if ((o=symbol())!=COLON)
  443.                 goto syntax;
  444.             if (swp==0) {
  445.                 error("Case not in switch");
  446.                 goto stmt;
  447.             }
  448.             if(swp>=swtab+SWSIZ) {
  449.                 error("Switch table overflow");
  450.             } else {
  451.                 swp->swlab = isn;
  452.                 (swp++)->swval = o1;
  453.                 label(isn++);
  454.             }
  455.             goto stmt;
  456.  
  457.         case SWITCH:
  458.             o1 = brklab;
  459.             brklab = isn++;
  460.             np = pexpr();
  461.             chkw(np, -1);
  462.             rcexpr(block(RFORCE,0,NULL,NULL,np));
  463.             pswitch();
  464.             brklab = o1;
  465.             return;
  466.  
  467.         case DEFAULT:
  468.             if (swp==0)
  469.                 error("Default not in switch");
  470.             if (deflab)
  471.                 error("More than 1 'default'");
  472.             if ((o=symbol())!=COLON)
  473.                 goto syntax;
  474.             label(deflab = isn++);
  475.             goto stmt;
  476.  
  477.         case FOR:
  478.             o1 = contlab;
  479.             o2 = brklab;
  480.             contlab = isn++;
  481.             brklab = isn++;
  482.             if (o=forstmt())
  483.                 goto syntax;
  484.             label(brklab);
  485.             contlab = o1;
  486.             brklab = o2;
  487.             return;
  488.  
  489.         case ELSE:
  490.             error("Inappropriate 'else'");
  491.             statement();
  492.             return;
  493.         }
  494.         error("Unknown keyword");
  495.         goto syntax;
  496.  
  497.     case NAME:
  498.         if (nextchar()==':') {
  499.             peekc = 0;
  500.             o1 = csym;
  501.             if (o1->hclass>0) {
  502.                 if (o1->hblklev==0) {
  503.                     pushdecl(o1);
  504.                     o1->hoffset = 0;
  505.                 } else {
  506.                     defsym = o1;
  507.                     redec();
  508.                     goto stmt;
  509.                 }
  510.             }
  511.             o1->hclass = STATIC;
  512.             o1->htype = ARRAY;
  513.             o1->hflag =| FLABL;
  514.             if (o1->hoffset==0)
  515.                 o1->hoffset = isn++;
  516.             label(o1->hoffset);
  517.             goto stmt;
  518.         }
  519.     }
  520.     peeksym = o;
  521.     rcexpr(tree());
  522.  
  523. semi:
  524.     if ((o=symbol())==SEMI)
  525.         return;
  526. syntax:
  527.     error("Statement syntax");
  528.     errflush(o);
  529. }
  530.  
  531. /*
  532.  * Process a for statement.
  533.  */
  534. forstmt()
  535. {
  536.     register int l, o, sline;
  537.     int sline1, *ss;
  538.     struct tnode *st;
  539.  
  540.     if ((o=symbol()) != LPARN)
  541.         return(o);
  542.     if ((o=symbol()) != SEMI) {        /* init part */
  543.         peeksym = o;
  544.         rcexpr(tree());
  545.         if ((o=symbol()) != SEMI)
  546.             return(o);
  547.     }
  548.     label(contlab);
  549.     if ((o=symbol()) != SEMI) {        /* test part */
  550.         peeksym = o;
  551.         cbranch(tree(), brklab, 0);
  552.         if ((o=symbol()) != SEMI)
  553.             return(o);
  554.     }
  555.     if ((peeksym=symbol()) == RPARN) {    /* incr part */
  556.         peeksym = -1;
  557.         statement();
  558.         branch(contlab);
  559.         return(0);
  560.     }
  561.     l = contlab;
  562.     contlab = isn++;
  563.     st = tree();
  564.     sline = line;
  565.     if ((o=symbol()) != RPARN)
  566.         return(o);
  567.     ss = funcbase;
  568.     funcbase = curbase;
  569.     statement();
  570.     sline1 = line;
  571.     line = sline;
  572.     label(contlab);
  573.     rcexpr(st);
  574.     line = sline1;
  575.     if (ss < maxdecl)
  576.         ss = maxdecl;
  577.     curbase = funcbase = ss;
  578.     branch(l);
  579.     return(0);
  580. }
  581.  
  582. /*
  583.  * A parenthesized expression,
  584.  * as after "if".
  585.  */
  586. struct tnode *
  587. pexpr()
  588. {
  589.     register o, t;
  590.  
  591.     if ((o=symbol())!=LPARN)
  592.         goto syntax;
  593.     t = tree();
  594.     if ((o=symbol())!=RPARN)
  595.         goto syntax;
  596.     return(t);
  597. syntax:
  598.     error("Statement syntax");
  599.     errflush(o);
  600.     return(0);
  601. }
  602.  
  603. /*
  604.  * The switch statement, which involves collecting the
  605.  * constants and labels for the cases.
  606.  */
  607. pswitch()
  608. {
  609.     register struct swtab *cswp, *sswp;
  610.     int dl, swlab;
  611.  
  612.     cswp = sswp = swp;
  613.     if (swp==0)
  614.         cswp = swp = swtab;
  615.     branch(swlab=isn++);
  616.     dl = deflab;
  617.     deflab = 0;
  618.     statement();
  619.     branch(brklab);
  620.     label(swlab);
  621.     if (deflab==0)
  622.         deflab = brklab;
  623.     outcode("BNN", SWIT, deflab, line);
  624.     for (; cswp < swp; cswp++)
  625.         outcode("NN", cswp->swlab, cswp->swval);
  626.     outcode("0");
  627.     label(brklab);
  628.     deflab = dl;
  629.     swp = sswp;
  630. }
  631.  
  632. /*
  633.  * funchead is called at the start of each function
  634.  * to process the arguments, which have been linked in a list.
  635.  * This list is necessary because in
  636.  * f(a, b) float b; int a; ...
  637.  * the names are seen before the types.
  638.  */
  639. /*
  640.  * Structure resembling a block for a register variable.
  641.  */
  642. struct    hshtab    hreg    { REG, 0, 0, NULL, NULL, 0 };
  643. struct    tnode    areg    { NAME, 0, NULL, NULL, &hreg};
  644. funchead()
  645. {
  646.     register pl;
  647.     register struct hshtab *cs;
  648.     struct tnode *bstack[2];
  649.  
  650.     pl = STARG;
  651.     while(paraml) {
  652.         parame->hoffset = 0;
  653.         cs = paraml;
  654.         paraml = paraml->hoffset;
  655.         if (cs->htype==FLOAT)
  656.             cs->htype = DOUBLE;
  657.         cs->hoffset = pl;
  658.         if ((cs->htype&XTYPE) == ARRAY) {
  659.             cs->htype =- (ARRAY-PTR);    /* set ptr */
  660.             cs->subsp++;        /* pop dims */
  661.         }
  662.         pl =+ rlength(cs);
  663.         if (cs->hclass==AREG && (hreg.hoffset=goodreg(cs))>=0) {
  664.             bstack[0] = &areg;
  665.             bstack[1] = nblock(cs);
  666.             cp = &bstack[2];
  667.             areg.type = cs->htype;
  668.             cs->hclass = AUTO;
  669.             build(ASSIGN);
  670.             rcexpr(bstack[0]);
  671.             cs->hoffset = hreg.hoffset;
  672.             cs->hclass = REG;
  673.         } else
  674.             cs->hclass = AUTO;
  675.         prste(cs);
  676.     }
  677.     for (cs=hshtab; cs<hshtab+HSHSIZ; cs++) {
  678.         if (cs->name[0] == '\0')
  679.             continue;
  680.         if (cs->hclass == ARG || cs->hclass==AREG)
  681.             error("Not an argument: %.8s", cs->name);
  682.     }
  683.     outcode("BN", SETREG, regvar);
  684. }
  685.  
  686. blockhead()
  687. {
  688.     register r;
  689.  
  690.     r = regvar;
  691.     blklev++;
  692.     declist(0);
  693.     if (r != regvar)
  694.         outcode("BN", SETREG, regvar);
  695. }
  696.  
  697. /*
  698.  * After the end of a block, delete local
  699.  * symbols; save those that are external.
  700.  * Also complain about undefined labels.
  701.  */
  702. blkend()
  703. {
  704.     register struct hshtab *cs, *ncs;
  705.     struct hshtab *endcs;
  706.     register i;
  707.  
  708.     blklev--;
  709.     for (cs=hshtab; cs->name[0] && cs<hshtab+HSHSIZ-1; ++cs)
  710.         ;
  711.     endcs = cs;
  712.     do  if (cs->name[0]) {
  713.         if (cs->hblklev <= blklev)
  714.             continue;
  715.         if ((cs->hclass!=EXTERN || blklev!=0)
  716.          && ((cs->hflag&FLABL)==0 || blklev==0)) {
  717.             if (cs->hclass==0)
  718.                 error("%.8s undefined", cs->name);
  719.             if ((ncs = cs->hpdown)==NULL) {
  720.                 cs->name[0] = '\0';
  721.                 hshused--;
  722.                 cs->hflag =& FKEYW;
  723.             } else {
  724.                 cpysymb(cs, ncs);
  725.             }
  726.             continue;
  727.         }
  728.         /*
  729.          * Retained name; must rehash.
  730.          */
  731.         for (i=0; i<NCPS; i++)
  732.             symbuf[i] = cs->name[i];
  733.         mossym = cs->hflag&FMOS;
  734.         lookup();
  735.         if ((ncs=csym) != cs) {
  736.             cs->name[0] = '\0';
  737.             hshused--;
  738.             i = ncs->hflag;
  739.             cpysymb(ncs, cs);
  740.             ncs->hflag =| i&FKEYW;
  741.             cs->hflag =& FKEYW;
  742.         }
  743.         if (ncs->hblklev>1 || (ncs->hblklev>0 && ncs->hclass==EXTERN))
  744.             ncs->hblklev--;
  745.     } while ((cs = (cs<&hshtab[HSHSIZ-1])? ++cs: hshtab) != endcs);
  746. }
  747.  
  748. /*
  749.  * write out special definitions of local symbols for
  750.  * benefit of the debugger.  None of these are used
  751.  * by the assembler except to save them.
  752.  */
  753. prste(acs)
  754. struct hshtab *acs;
  755. {
  756.     register struct hshtab *cs;
  757.     register nkind;
  758.  
  759.     cs = acs;
  760.     switch (cs->hclass) {
  761.     case REG:
  762.         nkind = RNAME;
  763.         break;
  764.  
  765.     case AUTO:
  766.         nkind = ANAME;
  767.         break;
  768.  
  769.     case STATIC:
  770.         nkind = SNAME;
  771.         break;
  772.  
  773.     default:
  774.         return;
  775.  
  776.     }
  777.     outcode("BSN", nkind, cs->name, cs->hoffset);
  778. }
  779.  
  780. /*
  781.  * In case of error, skip to the next
  782.  * statement delimiter.
  783.  */
  784. errflush(ao)
  785. {
  786.     register o;
  787.  
  788.     o = ao;
  789.     while(o>RBRACE)    /* ; { } */
  790.         o = symbol();
  791.     peeksym  = o;
  792. }
  793.