# 2.11BSD#431 - /usr/src/ucb/PORT/pascal/src/yylex.c

##### Functions

    setuflg           X
    unyylex           X
    yylex             X
    yyset             X

##### Variables

    Yla               X
    yylacnt           X

##### Macros

    YYLASIZ           X

       1: /*
       2:  * Copyright (c) 1980 Regents of the University of California.
       3:  * All rights reserved.  The Berkeley software License Agreement
       4:  * specifies the terms and conditions for redistribution.
       5:  */
       6:
       7: #ifndef lint
       8: static char sccsid[] = "@(#)yylex.c	5.1 (Berkeley) 6/5/85";
       9: #endif not lint
      10:
      11: #include "whoami.h"
      12: #include "0.h"
      13: #include "tree_ty.h"    /* must be included for yy.h */
      14: #include "yy.h"
      15:
      16: /*
      17:  * Scanner
      18:  */
      19: int yylacnt;
      20:
      21: #define YYLASIZ 10
      22:
      23: struct  yytok Yla[YYLASIZ];
      24:
      25: unyylex(y)
      26:     struct yytok *y;
      27: {
      28:
      29:     if (yylacnt == YYLASIZ)
      30:         panic("unyylex");
      31:     copy((char *) &Yla[yylacnt], (char *) y, sizeof Yla[0]);
      32:     yylacnt++;
      33:
      34: }
      35:
      36: yylex()
      37: {
      38:     register c;
      39:     register int **ip;
      40:     register char *cp;
      41:     int f;
      42:     char delim;
      43:
      44:     if (yylacnt != 0) {
      45:         yylacnt--;
      46:         copy((char *) &Y, (char *) &Yla[yylacnt], sizeof Y);
      47:         return (yychar);
      48:     }
      49:     if (c = yysavc)
      50:         yysavc = 0;
      51:     else
      52:         c = readch();
      53: #ifdef PXP
      54:     yytokcnt++;
      55: #endif
      56:
      57: next:
      58:     /*
      59: 	 * skip white space
      60: 	 */
      61: #ifdef PXP
      62:     yywhcnt = 0;
      63: #endif
      64:     while (c == ' ' || c == '\t') {
      65: #ifdef PXP
      66:         if (c == '\t')
      67:             yywhcnt++;
      68:         yywhcnt++;
      69: #endif
      70:         c = readch();
      71:     }
      72:     yyecol = yycol;
      73:     yyeline = yyline;
      74:     yyefile = filename;
      75:     yyeseqid = yyseqid;
      76:     yyseekp = yylinpt;
      77:     cp = token;
      78:     yylval = yyline;
      79:     switch (c) {
      80:         case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
      81:         case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n':
      82:         case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u':
      83:         case 'v': case 'w': case 'x': case 'y': case 'z':
      84:         case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G':
      85:         case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N':
      86:         case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U':
      87:         case 'V': case 'W': case 'X': case 'Y': case 'Z':
      88:             do {
      89:                 *cp++ = c;
      90:                 c = readch();
      91:             } while (alph(c) || digit(c));
      92:             *cp = 0;
      93:             if (opt('s'))
      94:                 for (cp = token; *cp; cp++)
      95:                     if (*cp >= 'A' && *cp <= 'Z') {
      96:                         *cp |= ' ';
      97:                     }
      98:             yysavc = c;
      99:             ip = (int **) hash((char *) 0, 1);
     100:             if (*ip < (int *) yykey || *ip >= (int *) lastkey) {
     101:                 yylval = (int) *ip;
     102:                 return (YID);
     103:             }
     104:             yylval = yyline;
     105:             /*
     106: 			 * For keywords
     107: 			 * the lexical token
     108: 			 * is magically retrieved
     109: 			 * from the keyword table.
     110: 			 */
     111:             return ((*ip)[1]);
     112:         case '0': case '1': case '2': case '3': case '4':
     113:         case '5': case '6': case '7': case '8': case '9':
     114:             f = 0;
     115:             do {
     116:                 *cp++ = c;
     117:                 c = readch();
     118:             } while (digit(c));
     119:             if (c == 'b' || c == 'B') {
     120:                 /*
     121: 				 * nonstandard - octal constants
     122: 				 */
     123:                 if (opt('s')) {
     124:                     standard();
     125:                     yerror("Octal constants are non-standard");
     126:                 }
     127:                 *cp = 0;
     128:                 yylval = copystr(token);
     129:                 return (YBINT);
     130:             }
     131:             if (c == '.') {
     132:                 c = readch();
     133:                 if (c == '.') {
     134:                     *cp = 0;
     135:                     yysavc = YDOTDOT;
     136:                     yylval = copystr(token);
     137:                     return (YINT);
     138:                 }
     139: infpnumb:
     140:                 f++;
     141:                 *cp++ = '.';
     142:                 if (!digit(c)) {
     143:                     yyset();
     144:                     recovered();
     145:                     yerror("Digits required after decimal point");
     146:                     *cp++ = '0';
     147:                 } else
     148:                     while (digit(c)) {
     149:                         *cp++ = c;
     150:                         c = readch();
     151:                     }
     152:             }
     153:             if (c == 'e' || c == 'E') {
     154:                 f++;
     155:                 *cp++ = c;
     156:                 if ((c = yysavc) == 0)
     157:                     c = readch();
     158:                 if (c == '+' || c == '-') {
     159:                     *cp++ = c;
     160:                     c = readch();
     161:                 }
     162:                 if (!digit(c)) {
     163:                     yyset();
     164:                     yerror("Digits required in exponent");
     165:                     *cp++ = '0';
     166:                 } else
     167:                     while (digit(c)) {
     168:                         *cp++ = c;
     169:                         c = readch();
     170:                     }
     171:             }
     172:             *cp = 0;
     173:             yysavc = c;
     174:             yylval = copystr(token);
     175:             if (f)
     176:                 return (YNUMB);
     177:             return (YINT);
     178:         case '"':
     179:         case '`':
     180:         case '#':
     181:             if (!any(bufp + 1, c))
     182:                 goto illch;
     183:             if (!dquote) {
     184:                 recovered();
     185:                 dquote++;
     186:                 yerror("Character/string delimiter is '");
     187:             }
     188:         case '\'':
     189:             delim = c;
     190:             do {
     191:                 do {
     192:                     c = readch();
     193:                     if (c == '\n') {
     194:                         yerror("Unmatched %c for string", (char *) delim);
     195:                         if (cp == token)
     196:                             *cp++ = ' ', cp++;
     197:                         break;
     198:                     }
     199:                     *cp++ = c;
     200:                 } while (c != delim);
     201:                 c = readch();
     202:             } while (c == delim);
     203:             *--cp = 0;
     204:             if (cp == token) {
     205:                 yerror("Null string not allowed");
     206:                 *cp++ = ' ';
     207:                 *cp++ = 0;
     208:             }
     209:             yysavc = c;
     210:             yylval = copystr(token);
     211:             return (YSTRING);
     212:         case '.':
     213:             c = readch();
     214:             if (c == '.')
     215:                 return (YDOTDOT);
     216:             if (digit(c)) {
     217:                 recovered();
     218:                 yerror("Digits required before decimal point");
     219:                 *cp++ = '0';
     220:                 goto infpnumb;
     221:             }
     222:             yysavc = c;
     223:             return ('.');
     224:         case '{':
     225:             /*
     226: 			 * { ... } comment
     227: 			 */
     228: #ifdef PXP
     229:             getcm(c);
     230: #endif
     231: #ifdef PI
     232:             c = options();
     233:             while (c != '}') {
     234:                 if (c <= 0)
     235:                     goto nonterm;
     236:                 if (c == '{') {
     237:                     warning();
     238:                     yyset();
     239:                     yerror("{ in a { ... } comment");
     240:                 }
     241:                 c = readch();
     242:             }
     243: #endif
     244:             c = readch();
     245:             goto next;
     246:         case '(':
     247:             if ((c = readch()) == '*') {
     248:                 /*
     249: 				 * (* ... *) comment
     250: 				 */
     251: #ifdef PXP
     252:                 getcm(c);
     253:                 c = readch();
     254:                 goto next;
     255: #endif
     256: #ifdef PI
     257:                 c = options();
     258:                 for (;;) {
     259:                     if (c < 0) {
     260: nonterm:
     261:                         yerror("Comment does not terminate - QUIT");
     262:                         pexit(ERRS);
     263:                     }
     264:                     if (c == '(' && (c = readch()) == '*') {
     265:                         warning();
     266:                         yyset();
     267:                         yerror("(* in a (* ... *) comment");
     268:                     }
     269:                     if (c == '*') {
     270:                         if ((c = readch()) != ')')
     271:                             continue;
     272:                         c = readch();
     273:                         goto next;
     274:                     }
     275:                     c = readch();
     276:                 }
     277: #endif
     278:             }
     279:             yysavc = c;
     280:             c = '(';
     281:         case ';':
     282:         case ',':
     283:         case ':':
     284:         case '=':
     285:         case '*':
     286:         case '+':
     287:         case '/':
     288:         case '-':
     289:         case ')':
     290:         case '[':
     291:         case ']':
     292:         case '<':
     293:         case '>':
     294:         case '^':
     295:             return (c);
     296:         case '~':
     297:         case '|':
     298:         case '&':
     299:             if ( opt('s') ) {
     300:                 yyset();
     301:                 standard();
     302:                 yerror("%c is non-standard", (char *) c);
     303:             }
     304:             return c;
     305:         default:
     306:             switch (c) {
     307:                 case YDOTDOT:
     308:                     return (c);
     309:                 case '\n':
     310:                     c = readch();
     311: #ifdef PXP
     312:                     yytokcnt++;
     313: #endif
     314:                     goto next;
     315:                 case '\f':
     316:                     c = readch();
     317:                     goto next;
     318:             }
     319:             if (c <= 0)
     320:                 return (YEOF);
     321: illch:
     322:             do
     323:                 yysavc = readch();
     324:             while (yysavc == c);
     325:             yylval = c;
     326:             return (YILLCH);
     327:     }
     328: }
     329:
     330: yyset()
     331: {
     332:
     333:     yyecol = yycol;
     334:     yyeline = yyline;
     335:     yyefile = filename;
     336:     yyseekp = yylinpt;
     337: }
     338:
     339: /*
     340:  * Setuflg trims the current
     341:  * input line to at most 72 chars
     342:  * for the u option.
     343:  */
     344: setuflg()
     345: {
     346:
     347:     if (charbuf[71] != '\n') {
     348:         charbuf[72] = '\n';
     349:         charbuf[73] = 0;
     350:     }
     351: }

#### Defined functions

setuflg defined in line 344; used 2 times

- in /usr/src/ucb/PORT/pascal/src/yyget.c line 163
- in /usr/src/ucb/PORT/pascal/src/yyoptions.c line 84

unyylex defined in line 25; used 5 times

- in /usr/src/ucb/PORT/pascal/src/yypanic.c line 95, 145, 162
- in /usr/src/ucb/PORT/pascal/src/yyrecover.c line 496-498(2)

yylex defined in line 36; used 13 times

- in /usr/src/ucb/PORT/pascal/src/pas.y line 527-532(2)
- in /usr/src/ucb/PORT/pascal/src/yypanic.c line 43-44(2), 69, 103, 148
- in /usr/src/ucb/PORT/pascal/src/yyparse.c line 55, 93, 120
- in /usr/src/ucb/PORT/pascal/src/yyrecover.c line 225, 237, 503

yyset defined in line 330; used 5 times

- in line 143, 163, 238, 266, 300

#### Defined variables

Yla defined in line 23; used 3 times

- in line 31(2), 46

sccsid defined in line 8; never used
yylacnt defined in line 19; used 7 times

- in line 29-32(3), 44-46(3)
- in /usr/src/ucb/PORT/pascal/src/tree.c line 149

#### Defined macros

YYLASIZ defined in line 21; used 2 times

- in line 23, 29

Last modified: 1985-06-06 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1361 |