# 2.11BSD#431 - /usr/src/usr.bin/eqn/lex.c

##### Functions

    cstr              X
    define            X
    delim             X
    getstr            X
    gtc               X
    include           X
    openinfile        X
    pbstr             X
    strsave           X
    yylex             X

##### Variables

    ibuf              X
    ip                X
    sp                X
    token             X

##### Macros

    PUSHBACK          X
    SSIZE             X
    putbak            X

       1: #ifndef lint
       2: static char sccsid[] = "@(#)lex.c	4.3 9/3/83";
       3: #endif
       4:
       5: #include "e.h"
       6: #include "e.def"
       7:
       8: #define SSIZE   400
       9: char    token[SSIZE];
      10: int sp;
      11: #define putbak(c)   *ip++ = c;
      12: #define PUSHBACK    300 /* maximum pushback characters */
      13: char    ibuf[PUSHBACK+SSIZE];   /* pushback buffer for definitions, etc. */
      14: char    *ip = ibuf;
      15:
      16: gtc() {
      17:   loop:
      18:     if (ip > ibuf)
      19:         return(*--ip);  /* already present */
      20:     lastchar = getc(curfile);
      21:     if (lastchar=='\n')
      22:         linect++;
      23:     if (lastchar != EOF)
      24:         return(lastchar);
      25:     if (++ifile > svargc) {
      26:         return(EOF);
      27:     }
      28:     fclose(curfile);
      29:     linect = 1;
      30:     if (openinfile() == 0)
      31:         goto loop;
      32:     return(EOF);
      33: }
      34: /*
      35:  *	open file indexed by ifile in svargv, return non zero if fail
      36:  */
      37: openinfile()
      38: {
      39:     if (strcmp(svargv[ifile], "-") == 0){
      40:         curfile = stdin;
      41:         return(0);
      42:     } else if ((curfile=fopen(svargv[ifile], "r")) != NULL){
      43:         return(0);
      44:     }
      45:     error(FATAL, "can't open file %s", svargv[ifile]);
      46:     return(1);
      47: }
      48:
      49: pbstr(str)
      50: register char *str;
      51: {
      52:     register char *p;
      53:
      54:     p = str;
      55:     while (*p++);
      56:     --p;
      57:     if (ip >= &ibuf[PUSHBACK])
      58:         error( FATAL, "pushback overflow");
      59:     while (p > str)
      60:         putbak(*--p);
      61: }
      62:
      63: yylex() {
      64:     register int c;
      65:     tbl *tp, *lookup();
      66:     extern tbl **keytbl, **deftbl;
      67:
      68:   beg:
      69:     while ((c=gtc())==' ' || c=='\n')
      70:         ;
      71:     yylval=c;
      72:     switch(c) {
      73:
      74:     case EOF:
      75:         return(EOF);
      76:     case '~':
      77:         return(SPACE);
      78:     case '^':
      79:         return(THIN);
      80:     case '\t':
      81:         return(TAB);
      82:     case '{':
      83:         return('{');
      84:     case '}':
      85:         return('}');
      86:     case '"':
      87:         for (sp=0; (c=gtc())!='"' && c != '\n'; ) {
      88:             if (c == '\\')
      89:                 if ((c = gtc()) != '"')
      90:                     token[sp++] = '\\';
      91:             token[sp++] = c;
      92:             if (sp>=SSIZE)
      93:                 error(FATAL, "quoted string %.20s... too long", token);
      94:         }
      95:         token[sp]='\0';
      96:         yylval = (int) &token[0];
      97:         if (c == '\n')
      98:             error(!FATAL, "missing \" in %.20s", token);
      99:         return(QTEXT);
     100:     }
     101:     if (c==righteq)
     102:         return(EOF);
     103:
     104:     putbak(c);
     105:     getstr(token, SSIZE);
     106:     if (dbg)printf(".\tlex token = |%s|\n", token);
     107:     if ((tp = lookup(&deftbl, token, NULL)) != NULL) {
     108:         putbak(' ');
     109:         pbstr(tp->defn);
     110:         putbak(' ');
     111:         if (dbg)
     112:             printf(".\tfound %s|=%s|\n", token, tp->defn);
     113:     }
     114:     else if ((tp = lookup(&keytbl, token, NULL)) == NULL) {
     115:         if(dbg)printf(".\t%s is not a keyword\n", token);
     116:         return(CONTIG);
     117:     }
     118:     else if (tp->defn == (char *) DEFINE || tp->defn == (char *) NDEFINE || tp->defn == (char *) TDEFINE)
     119:         define(tp->defn);
     120:     else if (tp->defn == (char *) DELIM)
     121:         delim();
     122:     else if (tp->defn == (char *) GSIZE)
     123:         globsize();
     124:     else if (tp->defn == (char *) GFONT)
     125:         globfont();
     126:     else if (tp->defn == (char *) INCLUDE)
     127:         include();
     128:     else {
     129:         return((int) tp->defn);
     130:     }
     131:     goto beg;
     132: }
     133:
     134: getstr(s, n) char *s; register int n; {
     135:     register int c;
     136:     register char *p;
     137:
     138:     p = s;
     139:     while ((c = gtc()) == ' ' || c == '\n')
     140:         ;
     141:     if (c == EOF) {
     142:         *s = 0;
     143:         return;
     144:     }
     145:     while (c != ' ' && c != '\t' && c != '\n' && c != '{' && c != '}'
     146:       && c != '"' && c != '~' && c != '^' && c != righteq) {
     147:         if (c == '\\')
     148:             if ((c = gtc()) != '"')
     149:                 *p++ = '\\';
     150:         *p++ = c;
     151:         if (--n <= 0)
     152:             error(FATAL, "token %.20s... too long", s);
     153:         c = gtc();
     154:     }
     155:     if (c=='{' || c=='}' || c=='"' || c=='~' || c=='^' || c=='\t' || c==righteq)
     156:         putbak(c);
     157:     *p = '\0';
     158:     yylval = (int) s;
     159: }
     160:
     161: cstr(s, quote, maxs) char *s; int quote; {
     162:     int del, c, i;
     163:
     164:     while((del=gtc()) == ' ' || del == '\t' || del == '\n');
     165:     if (quote)
     166:         for (i=0; (c=gtc()) != del && c != EOF;) {
     167:             s[i++] = c;
     168:             if (i >= maxs)
     169:                 return(1);  /* disaster */
     170:         }
     171:     else {
     172:         s[0] = del;
     173:         for (i=1; (c=gtc())!=' ' && c!= '\t' && c!='\n' && c!=EOF;) {
     174:             s[i++]=c;
     175:             if (i >= maxs)
     176:                 return(1);  /* disaster */
     177:         }
     178:     }
     179:     s[i] = '\0';
     180:     if (c == EOF)
     181:         error(FATAL, "Unexpected end of input at %.20s", s);
     182:     return(0);
     183: }
     184:
     185: define(type) int type; {
     186:     char *strsave(), *p1, *p2;
     187:     tbl *lookup();
     188:     extern tbl **deftbl;
     189:
     190:     getstr(token, SSIZE);   /* get name */
     191:     if (type != DEFINE) {
     192:         cstr(token, 1, SSIZE);  /* skip the definition too */
     193:         return;
     194:     }
     195:     p1 = strsave(token);
     196:     if (cstr(token, 1, SSIZE))
     197:         error(FATAL, "Unterminated definition at %.20s", token);
     198:     p2 = strsave(token);
     199:     lookup(&deftbl, p1, p2);
     200:     if (dbg)printf(".\tname %s defined as %s\n", p1, p2);
     201: }
     202:
     203: char *strsave(s)
     204: char *s;
     205: {
     206:     char *malloc();
     207:     register char *q;
     208:
     209:     q = malloc(strlen(s)+1);
     210:     if (q == NULL)
     211:         error(FATAL, "out of space in strsave on %s", s);
     212:     strcpy(q, s);
     213:     return(q);
     214: }
     215:
     216: include() {
     217:     error(!FATAL, "Include not yet implemented");
     218: }
     219:
     220: delim() {
     221:     yyval = eqnreg = 0;
     222:     if (cstr(token, 0, SSIZE))
     223:         error(FATAL, "Bizarre delimiters at %.20s", token);
     224:     lefteq = token[0];
     225:     righteq = token[1];
     226:     if (lefteq == 'o' && righteq == 'f')
     227:         lefteq = righteq = '\0';
     228: }

#### Defined functions

cstr defined in line 161; used 3 times

- in line 192-196(2), 222

define defined in line 185; used 1 times

- in line 119

delim defined in line 220; used 1 times

- in line 121

getstr defined in line 134; used 4 times

- in line 105, 190
- in /usr/src/usr.bin/eqn/font.c line 51
- in /usr/src/usr.bin/eqn/size.c line 36

gtc defined in line 16; used 11 times

- in line 69, 87-89(2), 139, 148-153(2), 164-166(2), 173
- in /usr/src/usr.bin/eqn/io.c line 56, 68

include defined in line 216; used 1 times

- in line 127

openinfile defined in line 37; used 2 times

- in line 30
- in /usr/src/usr.bin/eqn/io.c line 182

pbstr defined in line 49; used 1 times

- in line 109

strsave defined in line 203; used 3 times

- in line 186, 195-198(2)

yylex defined in line 63; never used

#### Defined variables

ibuf defined in line 13; used 3 times

- in line 14-18(2), 57

ip defined in line 14; used 4 times

- in line 11, 18-19(2), 57

sccsid defined in line 2; never used
sp defined in line 10; used 5 times

- in line 87-95(5)

token defined in line 9; used 22 times

- in line 90-98(6), 105-115(6), 190-198(6), 222-225(4)

#### Defined macros

PUSHBACK defined in line 12; used 2 times

- in line 13, 57

SSIZE defined in line 8; used 8 times

- in line 9-13(2), 92, 105, 190-196(3), 222

putbak defined in line 11; used 5 times

- in line 60, 104-110(3), 156

Last modified: 1987-02-17 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1306 |