#include <u.h>
#include <libc.h>
#include <bio.h>
#include "cb.h"
#include "cbtype.h"

static void
usage(void)
{
       fprint(2, "usage: cb [-sj] [-l width]\n");
       exits("usage");
}

void
main(int argc, char *argv[])
{
       Biobuf stdin, stdout;

       ARGBEGIN{
       case 'j':
               join = 1;
               break;
       case 'l':
               maxleng = atoi(EARGF(usage()));
               maxtabs = maxleng/TABLENG - 2;
               maxleng -= (maxleng + 5)/10;
               break;
       case 's':
               strict = 1;
               break;
       default:
               usage();
       }ARGEND

       Binit(&stdout, 1, OWRITE);
       output = &stdout;
       if (argc <= 0){
               Binit(&stdin, 0, OREAD);
               input = &stdin;
               work();
               Bterm(input);
       } else {
               while (argc-- > 0){
                       if ((input = Bopen(*argv, OREAD)) == 0)
                               sysfatal("can't open input file %s: %r", *argv);
                       work();
                       Bterm(input);
                       argv++;
               }
       }
       exits(0);
}
void
work(void)
{
       int c, cc;
       struct keyw *lptr;
       char *pt;
       int ct;

       while ((c = getch()) != Beof){
               switch (c){
               case '{':
                       if ((lptr = lookup(lastlook,p)) != 0){
                               if (lptr->type == ELSE)gotelse();
                               else if(lptr->type == DO)gotdo();
                               else if(lptr->type == STRUCT)structlev++;
                       }
                       if(++clev >= &ind[CLEVEL-1]){
                               fprint(2,"too many levels of curly brackets\n");
                               clev = &ind[CLEVEL-1];
                       }
                       clev->pdepth = 0;
                       clev->tabs = (clev-1)->tabs;
                       clearif(clev);
                       if(strict && clev->tabs > 0)
                               putspace(' ',NO);
                       putch(c,NO);
                       getnl();
                       if(keyflag == DATADEF){
                               OUT;
                       }
                       else {
                               OUTK;
                       }
                       clev->tabs++;
                       pt = getnext(0);                /* to handle initialized structures */
                       if(*pt == '{'){         /* hide one level of {} */
                               while((c=getch()) != '{')
                                       if(c == Beof)error("{");
                               putch(c,NO);
                               if(strict){
                                       putch(' ',NO);
                                       eatspace();
                               }
                               keyflag = SINIT;
                       }
                       continue;
               case '}':
                       pt = getnext(0);                /* to handle initialized structures */
                       if(*pt == ','){
                               if(strict){
                                       putspace(' ',NO);
                                       eatspace();
                               }
                               putch(c,NO);
                               putch(*pt,NO);
                               *pt = '\0';
                               ct = getnl();
                               pt = getnext(0);
                               if(*pt == '{'){
                                       OUT;
                                       while((cc = getch()) != '{')
                                               if(cc == Beof)error("}");
                                       putch(cc,NO);
                                       if(strict){
                                               putch(' ',NO);
                                               eatspace();
                                       }
                                       getnext(0);
                                       continue;
                               }
                               else if(strict || ct){
                                       OUT;
                               }
                               continue;
                       }
                       else if(keyflag == SINIT && *pt == '}'){
                               if(strict)
                                       putspace(' ',NO);
                               putch(c,NO);
                               getnl();
                               OUT;
                               keyflag = DATADEF;
                               *pt = '\0';
                               pt = getnext(0);
                       }
                       outs(clev->tabs);
                       if(--clev < ind)clev = ind;
                       ptabs(clev->tabs);
                       putch(c,NO);
                       lbegin = 0;
                       lptr=lookup(pt,lastplace+1);
                       c = *pt;
                       if(*pt == ';' || *pt == ','){
                               putch(*pt,NO);
                               *pt = '\0';
                               lastplace=pt;
                       }
                       ct = getnl();
                       if((dolevel && clev->tabs <= dotabs[dolevel]) || (structlev )
                           || (lptr != 0 &&lptr->type == ELSE&& clev->pdepth == 0)){
                               if(c == ';'){
                                       OUTK;
                               }
                               else if(strict || (lptr != 0 && lptr->type == ELSE && ct == 0)){
                                       putspace(' ',NO);
                                       eatspace();
                               }
                               else if(lptr != 0 && lptr->type == ELSE){
                                       OUTK;
                               }
                               if(structlev){
                                       structlev--;
                                       keyflag = DATADEF;
                               }
                       }
                       else {
                               OUTK;
                               if(strict && clev->tabs == 0){
                                       if((c=getch()) != '\n'){
                                               Bputc(output, '\n');
                                               Bputc(output, '\n');
                                               unget(c);
                                       }
                                       else {
                                               lineno++;
                                               Bputc(output, '\n');
                                               if((c=getch()) != '\n')unget(c);
                                               else lineno++;
                                               Bputc(output, '\n');
                                       }
                               }
                       }
                       if(lptr != 0 && lptr->type == ELSE && clev->pdepth != 0){
                               UNBUMP;
                       }
                       if(lptr == 0 || lptr->type != ELSE){
                               clev->iflev = 0;
                               if(dolevel && docurly[dolevel] == NO && clev->tabs == dotabs[dolevel]+1)
                                       clev->tabs--;
                               else if(clev->pdepth != 0){
                                       UNBUMP;
                               }
                       }
                       continue;
               case '(':
                       paren++;
                       if ((lptr = lookup(lastlook,p)) != 0){
                               if(!(lptr->type == TYPE || lptr->type == STRUCT))keyflag=KEYWORD;
                               if (strict){
                                       putspace(lptr->punc,NO);
                                       opflag = 1;
                               }
                               putch(c,NO);
                               if (lptr->type == IF)gotif();
                       }
                       else {
                               putch(c,NO);
                               lastlook = p;
                               opflag = 1;
                       }
                       continue;
               case ')':
                       if(--paren < 0)paren = 0;
                       putch(c,NO);
                       if((lptr = lookup(lastlook,p)) != 0){
                               if(lptr->type == TYPE || lptr->type == STRUCT)
                                       opflag = 1;
                       }
                       else if(keyflag == DATADEF)opflag = 1;
                       else opflag = 0;
                       outs(clev->tabs);
                       pt = getnext(1);
                       if ((ct = getnl()) == 1 && !strict){
                               if(dolevel && clev->tabs <= dotabs[dolevel])
                                       resetdo();
                               if(clev->tabs > 0 && (paren != 0 || keyflag == 0)){
                                       if(join){
                                               eatspace();
                                               putch(' ',YES);
                                               continue;
                                       } else {
                                               OUT;
                                               split = 1;
                                               continue;
                                       }
                               }
                               else if(clev->tabs > 0 && *pt != '{'){
                                       BUMP;
                               }
                               OUTK;
                       }
                       else if(strict){
                               if(clev->tabs == 0){
                                       if(*pt != ';' && *pt != ',' && *pt != '(' && *pt != '['){
                                               OUTK;
                                       }
                               }
                               else {
                                       if(keyflag == KEYWORD && paren == 0){
                                               if(dolevel && clev->tabs <= dotabs[dolevel]){
                                                       resetdo();
                                                       eatspace();
                                                       continue;
                                               }
                                               if(*pt != '{'){
                                                       BUMP;
                                                       OUTK;
                                               }
                                               else {
                                                       *pt='\0';
                                                       eatspace();
                                                       unget('{');
                                               }
                                       }
                                       else if(ct){
                                               if(paren){
                                                       if(join){
                                                               eatspace();
                                                       } else {
                                                               split = 1;
                                                               OUT;
                                                       }
                                               }
                                               else {
                                                       OUTK;
                                               }
                                       }
                               }
                       }
                       else if(dolevel && clev->tabs <= dotabs[dolevel])
                               resetdo();
                       continue;
               case ' ':
               case '\t':
                       if ((lptr = lookup(lastlook,p)) != 0){
                               if(!(lptr->type==TYPE||lptr->type==STRUCT))
                                       keyflag = KEYWORD;
                               else if(paren == 0)keyflag = DATADEF;
                               if(strict){
                                       if(lptr->type != ELSE){
                                               if(lptr->type == TYPE){
                                                       if(paren != 0)putch(' ',YES);
                                               }
                                               else
                                                       putch(lptr->punc,NO);
                                               eatspace();
                                       }
                               }
                               else putch(c,YES);
                               switch(lptr->type){
                               case CASE:
                                       outs(clev->tabs-1);
                                       continue;
                               case ELSE:
                                       pt = getnext(1);
                                       eatspace();
                                       if((cc = getch()) == '\n' && !strict){
                                               unget(cc);
                                       }
                                       else {
                                               unget(cc);
                                               if(checkif(pt))continue;
                                       }
                                       gotelse();
                                       if(strict) unget(c);
                                       if(getnl() == 1 && !strict){
                                               OUTK;
                                               if(*pt != '{'){
                                                       BUMP;
                                               }
                                       }
                                       else if(strict){
                                               if(*pt != '{'){
                                                       OUTK;
                                                       BUMP;
                                               }
                                       }
                                       continue;
                               case IF:
                                       gotif();
                                       continue;
                               case DO:
                                       gotdo();
                                       pt = getnext(1);
                                       if(*pt != '{'){
                                               eatallsp();
                                               OUTK;
                                               docurly[dolevel] = NO;
                                               dopdepth[dolevel] = clev->pdepth;
                                               clev->pdepth = 0;
                                               clev->tabs++;
                                       }
                                       continue;
                               case TYPE:
                                       if(paren)continue;
                                       if(!strict)continue;
                                       gottype(lptr);
                                       continue;
                               case STRUCT:
                                       gotstruct();
                                       continue;
                               }
                       }
                       else if (lbegin == 0 || p > string)
                               if(strict)
                                       putch(c,NO);
                               else putch(c,YES);
                       continue;
               case ';':
                       putch(c,NO);
                       if(paren != 0){
                               if(strict){
                                       putch(' ',YES);
                                       eatspace();
                               }
                               opflag = 1;
                               continue;
                       }
                       outs(clev->tabs);
                       pt = getnext(0);
                       lptr=lookup(pt,lastplace+1);
                       if(lptr == 0 || lptr->type != ELSE){
                               clev->iflev = 0;
                               if(clev->pdepth != 0){
                                       UNBUMP;
                               }
                               if(dolevel && docurly[dolevel] == NO && clev->tabs <= dotabs[dolevel]+1)
                                       clev->tabs--;
/*
                               else if(clev->pdepth != 0){
                                       UNBUMP;
                               }
*/
                       }
                       getnl();
                       OUTK;
                       continue;
               case '\n':
                       if ((lptr = lookup(lastlook,p)) != 0){
                               pt = getnext(1);
                               if (lptr->type == ELSE){
                                       if(strict)
                                               if(checkif(pt))continue;
                                       gotelse();
                                       OUTK;
                                       if(*pt != '{'){
                                               BUMP;
                                       }
                               }
                               else if(lptr->type == DO){
                                       OUTK;
                                       gotdo();
                                       if(*pt != '{'){
                                               docurly[dolevel] = NO;
                                               dopdepth[dolevel] = clev->pdepth;
                                               clev->pdepth = 0;
                                               clev->tabs++;
                                       }
                               }
                               else {
                                       OUTK;
                                       if(lptr->type == STRUCT)gotstruct();
                               }
                       }
                       else if(p == string)Bputc(output, '\n');
                       else {
                               if(clev->tabs > 0 &&(paren != 0 || keyflag == 0)){
                                       if(join){
                                               putch(' ',YES);
                                               eatspace();
                                               continue;
                                       } else {
                                               OUT;
                                               split = 1;
                                               continue;
                                       }
                               }
                               else if(keyflag == KEYWORD){
                                       OUTK;
                                       continue;
                               }
                               OUT;
                       }
                       continue;
               case '"':
               case '\'':
                       putch(c,NO);
                       while ((cc = getch()) != c){
                               if(cc == Beof)
                                       error("\" or '");
                               putch(cc,NO);
                               if (cc == '\\'){
                                       putch(getch(),NO);
                               }
                               if (cc == '\n'){
                                       outs(clev->tabs);
                                       lbegin = 1;
                                       count = 0;
                               }
                       }
                       putch(cc,NO);
                       opflag=0;
                       if (getnl() == 1){
                               unget('\n');
                       }
                       continue;
               case '\\':
                       putch(c,NO);
                       putch(getch(),NO);
                       continue;
               case '?':
                       question = 1;
                       gotop(c);
                       continue;
               case ':':
                       if ((cc = getch()) == ':') {
                               putch(c,NO);
                               putch(cc,NO);
                               continue;
                       }
                       unget(cc);
                       if (question == 1){
                               question = 0;
                               gotop(c);
                               continue;
                       }
                       putch(c,NO);
                       if(structlev)continue;
                       if ((lptr = lookup(lastlook,p)) != 0){
                               if (lptr->type == CASE)outs(clev->tabs - 1);
                       }
                       else {
                               lbegin = 0;
                               outs(clev->tabs);
                       }
                       getnl();
                       OUTK;
                       continue;
               case '/':
                       if ((cc = getch()) == '/') {
                               putch(c,NO);
                               putch(cc,NO);
                               cpp_comment(YES);
                               OUT;
                               lastlook = 0;
                               continue;
                       }
                       else if (cc != '*') {
                               unget(cc);
                               gotop(c);
                               continue;
                       }
                       putch(c,NO);
                       putch(cc,NO);
                       cc = comment(YES);
                       if(getnl() == 1){
                               if(cc == 0){
                                       OUT;
                               }
                               else {
                                       outs(0);
                                       Bputc(output, '\n');
                                       lbegin = 1;
                                       count = 0;
                               }
                               lastlook = 0;
                       }
                       continue;
               case '[':
                       putch(c,NO);
                       ct = 0;
                       while((c = getch()) != ']' || ct > 0){
                               if(c == Beof)error("]");
                               putch(c,NO);
                               if(c == '[')ct++;
                               if(c == ']')ct--;
                       }
                       putch(c,NO);
                       continue;
               case '#':
                       putch(c,NO);
                       while ((cc = getch()) != '\n'){
                               if(cc == Beof)error("newline");
                               if (cc == '\\'){
                                       putch(cc,NO);
                                       cc = getch();
                               }
                               putch(cc,NO);
                       }
                       putch(cc,NO);
                       lbegin = 0;
                       outs(clev->tabs);
                       lbegin = 1;
                       count = 0;
                       continue;
               default:
                       if (c == ','){
                               opflag = 1;
                               putch(c,YES);
                               if (strict){
                                       if ((cc = getch()) != ' ')unget(cc);
                                       if(cc != '\n')putch(' ',YES);
                               }
                       }
                       else if(isop(c))gotop(c);
                       else {
                               if(isalnum(c) && lastlook == 0)lastlook = p;
                               if(isdigit(c)){
                                       putch(c,NO);
                                       while(isdigit(c=Bgetc(input))||c == '.')putch(c,NO);
                                       if(c == 'e'){
                                               putch(c,NO);
                                               c = Bgetc(input);
                                               putch(c, NO);
                                               while(isdigit(c=Bgetc(input)))putch(c,NO);
                                       }
                                       Bungetc(input);
                               }
                               else putch(c,NO);
                               if(keyflag != DATADEF)opflag = 0;
                       }
               }
       }
}
void
gotif(void){
       outs(clev->tabs);
       if(++clev->iflev >= IFLEVEL-1){
               fprint(2,"too many levels of if %d\n",clev->iflev );
               clev->iflev = IFLEVEL-1;
       }
       clev->ifc[clev->iflev] = clev->tabs;
       clev->spdepth[clev->iflev] = clev->pdepth;
}
void
gotelse(void){
       clev->tabs = clev->ifc[clev->iflev];
       clev->pdepth = clev->spdepth[clev->iflev];
       if(--(clev->iflev) < 0)clev->iflev = 0;
}
int
checkif(char *pt)
{
       struct keyw *lptr;
       int cc;
       if((lptr=lookup(pt,lastplace+1))!= 0){
               if(lptr->type == IF){
                       if(strict)putch(' ',YES);
                       copy(lptr->name);
                       *pt='\0';
                       lastplace = pt;
                       if(strict){
                               putch(lptr->punc,NO);
                               eatallsp();
                       }
                       clev->tabs = clev->ifc[clev->iflev];
                       clev->pdepth = clev->spdepth[clev->iflev];
                       keyflag = KEYWORD;
                       return(1);
               }
       }
       return(0);
}
void
gotdo(void){
       if(++dolevel >= DOLEVEL-1){
               fprint(2,"too many levels of do %d\n",dolevel);
               dolevel = DOLEVEL-1;
       }
       dotabs[dolevel] = clev->tabs;
       docurly[dolevel] = YES;
}
void
resetdo(void){
       if(docurly[dolevel] == NO)
               clev->pdepth = dopdepth[dolevel];
       if(--dolevel < 0)dolevel = 0;
}
void
gottype(struct keyw *lptr)
{
       char *pt;
       struct keyw *tlptr;
       int c;
       while(1){
               pt = getnext(1);
               if((tlptr=lookup(pt,lastplace+1))!=0){
                       putch(' ',YES);
                       copy(tlptr->name);
                       *pt='\0';
                       lastplace = pt;
                       if(tlptr->type == STRUCT){
                               putch(tlptr->punc,YES);
                               gotstruct();
                               break;
                       }
                       lptr=tlptr;
                       continue;
               }
               else{
                       putch(lptr->punc,NO);
                       while((c=getch())== ' ' || c == '\t');
                       unget(c);
                       break;
               }
       }
}
void
gotstruct(void){
       int c;
       int cc;
       char *pt;
       while((c=getch()) == ' ' || c == '\t')
               if(!strict)putch(c,NO);
       if(c == '{'){
               structlev++;
               unget(c);
               return;
       }
       if(isalpha(c)){
               putch(c,NO);
               while(isalnum(c=getch()))putch(c,NO);
       }
       unget(c);
       pt = getnext(1);
       if(*pt == '{')structlev++;
       if(strict){
               eatallsp();
               putch(' ',NO);
       }
}
void
gotop(int c)
{
       char optmp[OPLENGTH];
       char *op_ptr;
       struct op *s_op;
       char *a, *b;
       op_ptr = optmp;
       *op_ptr++ = c;
       while (isop(( *op_ptr = getch())))op_ptr++;
       if(!strict)unget(*op_ptr);
       else if (*op_ptr != ' ')unget( *op_ptr);
       *op_ptr = '\0';
       s_op = op;
       b = optmp;
       while ((a = s_op->name) != 0){
               op_ptr = b;
               while ((*op_ptr == *a) && (*op_ptr != '\0')){
                       a++;
                       op_ptr++;
               }
               if (*a == '\0'){
                       keep(s_op);
                       opflag = s_op->setop;
                       if (*op_ptr != '\0'){
                               b = op_ptr;
                               s_op = op;
                               continue;
                       }
                       else break;
               }
               else s_op++;
       }
}
void
keep(struct op *o)
{
       char    *s;
       int ok;
       if(o->blanks == NEVER)ok = NO;
       else ok = YES;
       if (strict && ((o->blanks & ALWAYS)
           || ((opflag == 0 && o->blanks & SOMETIMES) && clev->tabs != 0)))
               putspace(' ',YES);
       for(s=o->name; *s != '\0'; s++){
               if(*(s+1) == '\0')putch(*s,ok);
               else
                       putch(*s,NO);
       }
       if (strict && ((o->blanks & ALWAYS)
           || ((opflag == 0 && o->blanks & SOMETIMES) && clev->tabs != 0))) putch(' ',YES);
}
int
getnl(void){
       int ch;
       char *savp;
       int gotcmt;
       gotcmt = 0;
       savp = p;
       while ((ch = getch()) == '\t' || ch == ' ')putch(ch,NO);
       if (ch == '/'){
               if ((ch = getch()) == '*'){
                       putch('/',NO);
                       putch('*',NO);
                       comment(NO);
                       ch = getch();
                       gotcmt=1;
               }
               else if (ch == '/') {
                       putch('/',NO);
                       putch('/',NO);
                       cpp_comment(NO);
                       ch = getch();
                       gotcmt = 1;
               }
               else {
                       if(inswitch)*(++lastplace) = ch;
                       else {
                               inswitch = 1;
                               *lastplace = ch;
                       }
                       unget('/');
                       return(0);
               }
       }
       if(ch == '\n'){
               if(gotcmt == 0)p=savp;
               return(1);
       }
       unget(ch);
       return(0);
}
void
ptabs(int n){
       int     i;
       int num;
       if(n > maxtabs){
               if(!folded){
                       Bprint(output, "/* code folded from here */\n");
                       folded = 1;
               }
               num = n-maxtabs;
       }
       else {
               num = n;
               if(folded){
                       folded = 0;
                       Bprint(output, "/* unfolding */\n");
               }
       }
       for (i = 0; i < num; i++)Bputc(output, '\t');
}
void
outs(int n){
       if (p > string){
               if (lbegin){
                       ptabs(n);
                       lbegin = 0;
                       if (split == 1){
                               split = 0;
                               if (clev->tabs > 0)Bprint(output, "\t");
                       }
               }
               *p = '\0';
               Bprint(output, "%s", string);
               lastlook = p = string;
       }
       else {
               if (lbegin != 0){
                       lbegin = 0;
                       split = 0;
               }
       }
}
void
putch(char c,int ok)
{
       int cc;
       if(p < &string[LINE-1]){
               if(count+TABLENG*clev->tabs >= maxleng && ok && !folded){
                       if(c != ' ')*p++ = c;
                       OUT;
                       split = 1;
                       if((cc=getch()) != '\n')unget(cc);
               }
               else {
                       *p++ = c;
                       count++;
               }
       }
       else {
               outs(clev->tabs);
               *p++ = c;
               count = 0;
       }
}
struct keyw *
lookup(char *first, char *last)
{
       struct keyw *ptr;
       char    *cptr, *ckey, *k;

       if(first == last || first == 0)return(0);
       cptr = first;
       while (*cptr == ' ' || *cptr == '\t')cptr++;
       if(cptr >= last)return(0);
       ptr = key;
       while ((ckey = ptr->name) != 0){
               for (k = cptr; (*ckey == *k && *ckey != '\0'); k++, ckey++);
               if(*ckey=='\0' && (k==last|| (k<last && !isalnum(*k)))){
                       opflag = 1;
                       lastlook = 0;
                       return(ptr);
               }
               ptr++;
       }
       return(0);
}
int
comment(int ok)
{
       int ch;
       int hitnl;

       hitnl = 0;
       while ((ch  = getch()) != Beof){
               putch(ch, NO);
               if (ch == '*'){
gotstar:
                       if ((ch  = getch()) == '/'){
                               putch(ch,NO);
                               return(hitnl);
                       }
                       putch(ch,NO);
                       if (ch == '*')goto gotstar;
               }
               if (ch == '\n'){
                       if(ok && !hitnl){
                               outs(clev->tabs);
                       }
                       else {
                               outs(0);
                       }
                       lbegin = 1;
                       count = 0;
                       hitnl = 1;
               }
       }
       return(hitnl);
}
int
cpp_comment(int ok)
{
       int ch;
       int hitnl;

       hitnl = 0;
       while ((ch = getch()) != -1) {
               if (ch == '\n') {
                       if (ok && !hitnl)
                               outs(clev->tabs);
                       else
                               outs(0);
                       lbegin = 1;
                       count = 0;
                       hitnl = 1;
                       break;
               }
               putch(ch, NO);
       }
       return hitnl;
}
void
putspace(char ch, int ok)
{
       if(p == string)putch(ch,ok);
       else if (*(p - 1) != ch) putch(ch,ok);
}
int
getch(void){
       char c;
       if(inswitch){
               if(next != '\0'){
                       c=next;
                       next = '\0';
                       return(c);
               }
               if(tptr <= lastplace){
                       if(*tptr != '\0')return(*tptr++);
                       else if(++tptr <= lastplace)return(*tptr++);
               }
               inswitch=0;
               lastplace = tptr = temp;
       }
       return(Bgetc(input));
}
void
unget(char c)
{
       if(inswitch){
               if(tptr != temp)
                       *(--tptr) = c;
               else next = c;
       }
       else Bungetc(input);
}
char *
getnext(int must){
       int c;
       char *beg;
       int prect,nlct;
       prect = nlct = 0;
       if(tptr > lastplace){
               tptr = lastplace = temp;
               err = 0;
               inswitch = 0;
       }
       tp = lastplace;
       if(inswitch && tptr <= lastplace)
               if (isalnum(*lastplace)||ispunct(*lastplace)||isop(*lastplace))return(lastplace);
space:
       while(isspace(c=Bgetc(input)))puttmp(c,1);
       beg = tp;
       puttmp(c,1);
       if(c == '/'){
               if(puttmp(Bgetc(input),1) == '*'){
cont:
                       while((c=Bgetc(input)) != '*'){
                               puttmp(c,0);
                               if(must == 0 && c == '\n')
                                       if(nlct++ > 2)goto done;
                       }
                       puttmp(c,1);
       star:
                       if(puttmp((c=Bgetc(input)),1) == '/'){
                               beg = tp;
                               puttmp((c=Bgetc(input)),1);
                       }
                       else if(c == '*')goto star;
                       else goto cont;
               }
               else goto done;
       }
       if(isspace(c))goto space;
       if(c == '#' && tp > temp+1 && *(tp-2) == '\n'){
               if(prect++ > 2)goto done;
               while(puttmp((c=Bgetc(input)),1) != '\n')
                       if(c == '\\')puttmp(Bgetc(input),1);
               goto space;
       }
       if(isalnum(c)){
               while(isalnum(c = Bgetc(input)))puttmp(c,1);
               Bungetc(input);
       }
done:
       puttmp('\0',1);
       lastplace = tp-1;
       inswitch = 1;
       return(beg);
}
void
copy(char *s)
{
       while(*s != '\0')putch(*s++,NO);
}
void
clearif(struct indent *cl)
{
       int i;
       for(i=0;i<IFLEVEL-1;i++)cl->ifc[i] = 0;
}
char
puttmp(char c, int keep)
{
       if(tp < &temp[TEMP-120])
               *tp++ = c;
       else {
               if(keep){
                       if(tp >= &temp[TEMP-1]){
                               fprint(2,"can't look past huge comment - quiting\n");
                               exits("boom");
                       }
                       *tp++ = c;
               }
               else if(err == 0){
                       err++;
                       fprint(2,"truncating long comment\n");
               }
       }
       return(c);
}
void
error(char *s)
{
       fprint(2,"saw EOF while looking for %s\n",s);
       exits("boom");
}

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.