preamble.c

編譯器的辭法分析器工具

/* PRECC library
 *
 *This file contains functions which precc requires to build ITSELF and
 *cannot be generated from the precc code in precc*.y (except as drop
 *through inclusions).
 *
 *These routines should not be required for other compilations
 *(the cc.c routines in the kernel suffice).
 *
 */

# include "preamble.h"

# undef UNSETNAME

/* startup functions */
void usage(int n)
{

    switch (n){
    case 1: fprintf(stderr,"mixed swiches and files\n");
            break;
    case 2: fprintf(stderr,"error opening %s for writing\n",p_outfile);
            break;
    case 3: fprintf(stderr,"unknown option\n");
            break;
    case 4: fprintf(stderr,"bad numerical option\n");
            break;
    case 5: fprintf(stderr,"error opening %s for reading\n",p_infile);
            break;
    }

    fprintf(stderr,"usage %s [options] [infile [outfile]]\n",p_argv[0]);
    fprintf(stderr,"options : -r<read buffer size in kb>      (%d)\n",
      (int)(precc_data.readbuffersize*(sizeof (TOKEN) + sizeof (VALUE))/1024));
    fprintf(stderr,"          -p<program buffer size in kb>   (%d)\n",
      (int)(precc_data.maxprogramsize*sizeof(VALUE)/1024));
    fprintf(stderr,"          -v<attribute buffer size in kb> (%d)\n",
      (int)(precc_data.stacksize*sizeof(STACKVALUE)/1024));
    fprintf(stderr,"          -f<context buffer size in kb>   (%d)\n",
      (int)(precc_data.contextstacksize*sizeof(FRAME)/1024));
    fprintf(stderr,"          -old                       (not set)\n");
    p_exit (n);
}

int getkintarg(char *s,int *t,size_t n)
/* read a number in kbytes and translate it to calloc units */
{
    if (1 != sscanf(s,"%u",t))
        usage(4);
    *t *= 1000; /* kbytes */
    *t /= n;    /* the unit size */
    return 0;
}


/* agents are buffers, safe places to put characters to be able to refer back to
   them later. One can 

   Concatenate a word to a buffer
   and close off the slot:            nputagent(A,word);getagent(A,&place)

   Concatenate a char to a buffer
   and close off the slot:          putagent(A,char);getagent(A,&place)

   Initialize the buffer:           initagent(A,buffer)

   Reset the buffer, old data is
   now unsafe:                      resetagent(A)
*/

CHAR cbuff[CBUFFSIZE];                    /* read buffer*/
AGENT chars = {cbuff,cbuff,cbuff};        /* read agent */
CHAR nbuff[NBUFFSIZE];                    /* name buffer*/
AGENT namE  = {nbuff,nbuff,nbuff};        /* name agent */
static CHAR abuff[NBUFFSIZE];             /* args buffer*/
AGENT args  = {abuff,abuff,abuff};        /* args agent */
static CHAR kbuff[NBUFFSIZE];             /* keys buffer*/
AGENT keys  = {kbuff,kbuff,kbuff};        /* keys agent */
static CHAR mbuff[NBUFFSIZE];             /* keys buffer*/
AGENT meta  = {mbuff,mbuff,mbuff};        /* meta agent */

void resetall ()
{
  CHARS resetagent();

  resetagent(&chars);
  resetagent(&namE);
  resetagent(&args);
  resetagent(&meta);
  resetagent(&keys);
}


/* methods on agents */
VOID initagent(AGENT *x,CHARS y){
x->buffer=y;
x->in=y;
x->out=y;
*y=0;
}

CHARS putagent(AGENT *x,char y){
*x->in++=y;                /* move the in pointer on one place */
*x->in=0;
return(x->in-1);
}

CHARS nputagent(AGENT *x,CHARS y){
*(x->in= p_scpy(x->in,y))=0;
return(x->out);            /* the current out-pointer is returned */
}                          /* which points to the start of the current word */

CHARS getagent(AGENT *x,CHARS *y){
*x->in++=0;                /* finish the current in word */
*y=x->out;                 /* report the out pointer */
*x->in=0;                  /* zero next word */
return(x->out=x->in);      /* set the out pointer to next incoming word */
}

CHARS resetagent(AGENT *x){
*x->buffer=0;              /* zero first word */
return(x->out=x->in=x->buffer);
}

/* in particular */

CHARS myputchar(char c){
return(putagent(&chars,c));
}

CHARS getname(CHARS *x){
return(getagent(&chars,x));
}

CHARS putname(CHARS x){
return(nputagent(&chars,(x)));
}

CHARS putint(int x){
static char shortbuf[32];
sprintf(shortbuf,"%d",x);
return(putname(shortbuf));
}

CHARS putargs(CHARS x){
return(nputagent(&args,x));
}

CHARS getargs(CHARS *x){
return(getagent(&args,x));
}

CHARS putmeta(CHARS x){
return(nputagent(&meta,x));
}

CHARS getmeta(CHARS *x){
return(getagent(&meta,x));
}


CHARS putkeys(CHARS x){
return(nputagent(&keys,x));
}

CHARS getkeys(CHARS *x){
return(getagent(&keys,x));
}



/* end of methods on agents */


# include <ctype.h>
 

        /* these are here to do char-int argument conversions */

BOOLEAN p_isalpha(c)
char c;
{
        return(isalpha((int)c) || (c=='_'));
}
 
BOOLEAN p_isdigit(c)
char c;
{
        return(isdigit((int)c));
}

BOOLEAN p_isspace(c)
char c;
{
        return((c==' ') || (c== *"\t"));
}

BOOLEAN p_isalnum(c)
char c;
{
        return(isalnum((int)c) || (c=='_'));
}

        /* this returns the address of the LAST char copied */
 
char *p_scpy(char *x,char *y)
{
        while((*x++ = *y++) != 0);
        return(&x[-1]);
}

int yytchar;
int yylen;
CHARS yylloc; /* this is the address of the LAST token
               * I returned from the readahead buffer, if it's not NULL,
               * which means the buffer is empty. */
int  yylineno;/* I need to supply this for precc */
VALUE yylval; /* ditto */

 
int yylex()
/*
 * Read ahead lines into yybuffer until EOL,
 * but ignore escaped End-Of-Lines (either escaped by
 * trailing `\' or by `@' at beginning of next line after this line began
 * with one.
 *
 * Dole out characters one at a time.
 *
 * Return 0!=TOKEN for a good read and 0=FAILURE when an EOF is encountered.
 */
{         

    int n;
    CHARS buff = yybuffer;
    static int atsignalled, linecount;
    static char c; extern int yytchar; extern int yylen;
    static int nbuff;

         /* gets returns nonzero EITHER if given ^^Z OR on the next
            call after a ^foo^Z - which is all OK for nonzero=EOF
          */

    if(NULL!=yylloc) {

        if (nbuff>0) {/* we can use a token we read ahead for */
            yylen=1;
            nbuff--;
            return(yytchar=(int)(yylval=(VALUE)(int) *++yylloc));
        }

         /* otherwise we ask for more TOKENS next time and return the EOL
            (0) now and it'll be used to terminate a string. */

        yylloc=NULL;
        yylen=0;    
        nbuff=0;
        return (yytchar=(int)(yylval=(VALUE)0));
        
    }


    /*if(NULL==yylloc){*/   /* we have to load the readahead buff  */
    
        yylloc=buff-1;      /* we will return a token at *buff ... */
        *buff=yytchar=0;    /* ... but we start clean              */
        nbuff=0;            /* length of readahead buffer          */
        atsignalled=0;      /* we're not in an @ sequence yet      */
        linecount=0;        /* we've read no sequence of lines yet */

        /* and carry on */

    
        /* we're here because the readahead buffer was empty and so
           the initialization conditions hold: yylloc=buff-1, etc. */

        while (gets((char*)buff)!=NULL) { 

          yylineno++;
          linecount++;

          n = (int)strlen((char*)buff);  /* count the booty */
          nbuff+=n;         /* keep count of the buffer contents */

          if (n==0) {       /* we got a linefeed only  and it's time to start
                             * feeding out stuff from the buffer */
            
          if (nbuff>0){
                 yylen=1;
                 nbuff--;
                 return(yytchar=(int)(yylval=(VALUE)(int) *++yylloc));
          }
                
                             /* here we've got no tokens, now or before */
          yylen=0;        
          yylloc=NULL;       /* signal to read ahead again next time round */
          return (yytchar=(int)(yylval=(VALUE)0));   /* return the 0 string
                              * terminator */
        }


        /* we're here with nbuff>0 already, and with n>0 */

                             /* check to see if this is an @ seq start */

        if ((linecount==1) && (*buff=='@'))