Return to lex.c CVS log

Up to [local] / rpl / rplawk

Quelques patches pour rplawk et ncurses.

    1: /****************************************************************
    2: Copyright (C) Lucent Technologies 1997
    3: All Rights Reserved
    4: 
    5: Permission to use, copy, modify, and distribute this software and
    6: its documentation for any purpose and without fee is hereby
    7: granted, provided that the above copyright notice appear in all
    8: copies and that both that the copyright notice and this
    9: permission notice and warranty disclaimer appear in supporting
   10: documentation, and that the name Lucent Technologies or any of
   11: its entities not be used in advertising or publicity pertaining
   12: to distribution of the software without specific, written prior
   13: permission.
   14: 
   15: LUCENT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
   16: INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
   17: IN NO EVENT SHALL LUCENT OR ANY OF ITS ENTITIES BE LIABLE FOR ANY
   18: SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
   19: WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
   20: IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
   21: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
   22: THIS SOFTWARE.
   23: ****************************************************************/
   24: 
   25: #include <stdio.h>
   26: #include <stdlib.h>
   27: #include <string.h>
   28: #include <ctype.h>
   29: #include "awk.h"
   30: #include "ytab.h"
   31: 
   32: extern YYSTYPE  yylval;
   33: extern int  infunc;
   34: 
   35: int lineno  = 1;
   36: int bracecnt = 0;
   37: int brackcnt  = 0;
   38: int parencnt = 0;
   39: 
   40: typedef struct Keyword {
   41:     const char *word;
   42:     int sub;
   43:     int type;
   44: } Keyword;
   45: 
   46: Keyword keywords[] ={   /* keep sorted: binary searched */
   47:     { "BEGIN",  XBEGIN,     XBEGIN },
   48:     { "END",    XEND,       XEND },
   49:     { "NF",     VARNF,      VARNF },
   50:     { "atan2",  FATAN,      BLTIN },
   51:     { "break",  BREAK,      BREAK },
   52:     { "close",  CLOSE,      CLOSE },
   53:     { "continue",   CONTINUE,   CONTINUE },
   54:     { "cos",    FCOS,       BLTIN },
   55:     { "delete", DELETE,     DELETE },
   56:     { "do",     DO,     DO },
   57:     { "else",   ELSE,       ELSE },
   58:     { "exit",   EXIT,       EXIT },
   59:     { "exp",    FEXP,       BLTIN },
   60:     { "fflush", FFLUSH,     BLTIN },
   61:     { "for",    FOR,        FOR },
   62:     { "func",   FUNC,       FUNC },
   63:     { "function",   FUNC,       FUNC },
   64:     { "getline",    GETLINE,    GETLINE },
   65:     { "gsub",   GSUB,       GSUB },
   66:     { "if",     IF,     IF },
   67:     { "in",     IN,     IN },
   68:     { "index",  INDEX,      INDEX },
   69:     { "int",    FINT,       BLTIN },
   70:     { "length", FLENGTH,    BLTIN },
   71:     { "log",    FLOG,       BLTIN },
   72:     { "match",  MATCHFCN,   MATCHFCN },
   73:     { "next",   NEXT,       NEXT },
   74:     { "nextfile",   NEXTFILE,   NEXTFILE },
   75:     { "print",  PRINT,      PRINT },
   76:     { "printf", PRINTF,     PRINTF },
   77:     { "rand",   FRAND,      BLTIN },
   78:     { "return", RETURN,     RETURN },
   79:     { "sin",    FSIN,       BLTIN },
   80:     { "split",  SPLIT,      SPLIT },
   81:     { "sprintf",    SPRINTF,    SPRINTF },
   82:     { "sqrt",   FSQRT,      BLTIN },
   83:     { "srand",  FSRAND,     BLTIN },
   84:     { "sub",    SUB,        SUB },
   85:     { "substr", SUBSTR,     SUBSTR },
   86:     { "system", FSYSTEM,    BLTIN },
   87:     { "tolower",    FTOLOWER,   BLTIN },
   88:     { "toupper",    FTOUPPER,   BLTIN },
   89:     { "while",  WHILE,      WHILE },
   90: };
   91: 
   92: #define RET(x)  { if(dbg)printf("lex %s\n", tokname(x)); return(x); }
   93: 
   94: int peek(void)
   95: {
   96:     int c = input();
   97:     unput(c);
   98:     return c;
   99: }
  100: 
  101: int gettok(char **pbuf, int *psz)   /* get next input token */
  102: {
  103:     int c, retc;
  104:     char *buf = *pbuf;
  105:     int sz = *psz;
  106:     char *bp = buf;
  107: 
  108:     c = input();
  109:     if (c == 0)
  110:         return 0;
  111:     buf[0] = c;
  112:     buf[1] = 0;
  113:     if (!isalnum(c) && c != '.' && c != '_')
  114:         return c;
  115: 
  116:     *bp++ = c;
  117:     if (isalpha(c) || c == '_') {   /* it's a varname */
  118:         for ( ; (c = input()) != 0; ) {
  119:             if (bp-buf >= sz)
  120:                 if (!adjbuf(&buf, &sz, bp-buf+2, 100, &bp, "gettok"))
  121:                     FATAL( "out of space for name %.10s...", buf );
  122:             if (isalnum(c) || c == '_')
  123:                 *bp++ = c;
  124:             else {
  125:                 *bp = 0;
  126:                 unput(c);
  127:                 break;
  128:             }
  129:         }
  130:         *bp = 0;
  131:         retc = 'a'; /* alphanumeric */
  132:     } else {    /* maybe it's a number, but could be . */
  133:         char *rem;
  134:         /* read input until can't be a number */
  135:         for ( ; (c = input()) != 0; ) {
  136:             if (bp-buf >= sz)
  137:                 if (!adjbuf(&buf, &sz, bp-buf+2, 100, &bp, "gettok"))
  138:                     FATAL( "out of space for number %.10s...", buf );
  139:             if (isdigit(c) || c == 'e' || c == 'E' 
  140:               || c == '.' || c == '+' || c == '-')
  141:                 *bp++ = c;
  142:             else {
  143:                 unput(c);
  144:                 break;
  145:             }
  146:         }
  147:         *bp = 0;
  148:         strtod(buf, &rem);  /* parse the number */
  149:         if (rem == buf) {   /* it wasn't a valid number at all */
  150:             buf[1] = 0; /* return one character as token */
  151:             retc = buf[0];  /* character is its own type */
  152:             unputstr(rem+1); /* put rest back for later */
  153:         } else {    /* some prefix was a number */
  154:             unputstr(rem);  /* put rest back for later */
  155:             rem[0] = 0; /* truncate buf after number part */
  156:             retc = '0'; /* type is number */
  157:         }
  158:     }
  159:     *pbuf = buf;
  160:     *psz = sz;
  161:     return retc;
  162: }
  163: 
  164: int word(char *);
  165: int string(void);
  166: int regexpr(void);
  167: int sc  = 0;    /* 1 => return a } right now */
  168: int reg = 0;    /* 1 => return a REGEXPR now */
  169: 
  170: int yylex(void)
  171: {
  172:     int c;
  173:     static char *buf = 0;
  174:     static int bufsize = 5; /* BUG: setting this small causes core dump! */
  175: 
  176:     if (buf == 0 && (buf = (char *) malloc(bufsize)) == NULL)
  177:         FATAL( "out of space in yylex" );
  178:     if (sc) {
  179:         sc = 0;
  180:         RET('}');
  181:     }
  182:     if (reg) {
  183:         reg = 0;
  184:         return regexpr();
  185:     }
  186:     for (;;) {
  187:         c = gettok(&buf, &bufsize);
  188:         if (c == 0)
  189:             return 0;
  190:         if (isalpha(c) || c == '_')
  191:             return word(buf);
  192:         if (isdigit(c)) {
  193:             yylval.cp = setsymtab(buf, tostring(buf), atof(buf), CON|NUM, symtab);
  194:             /* should this also have STR set? */
  195:             RET(NUMBER);
  196:         }
  197:     
  198:         yylval.i = c;
  199:         switch (c) {
  200:         case '\n':  /* {EOL} */
  201:             RET(NL);
  202:         case '\r':  /* assume \n is coming */
  203:         case ' ':   /* {WS}+ */
  204:         case '\t':
  205:             break;
  206:         case '#':   /* #.* strip comments */
  207:             while ((c = input()) != '\n' && c != 0)
  208:                 ;
  209:             unput(c);
  210:             break;
  211:         case ';':
  212:             RET(';');
  213:         case '\\':
  214:             if (peek() == '\n') {
  215:                 input();
  216:             } else if (peek() == '\r') {
  217:                 input(); input();   /* \n */
  218:                 lineno++;
  219:             } else {
  220:                 RET(c);
  221:             }
  222:             break;
  223:         case '&':
  224:             if (peek() == '&') {
  225:                 input(); RET(AND);
  226:             } else 
  227:                 RET('&');
  228:         case '|':
  229:             if (peek() == '|') {
  230:                 input(); RET(BOR);
  231:             } else
  232:                 RET('|');
  233:         case '!':
  234:             if (peek() == '=') {
  235:                 input(); yylval.i = NE; RET(NE);
  236:             } else if (peek() == '~') {
  237:                 input(); yylval.i = NOTMATCH; RET(MATCHOP);
  238:             } else
  239:                 RET(NOT);
  240:         case '~':
  241:             yylval.i = MATCH;
  242:             RET(MATCHOP);
  243:         case '<':
  244:             if (peek() == '=') {
  245:                 input(); yylval.i = LE; RET(LE);
  246:             } else {
  247:                 yylval.i = LT; RET(LT);
  248:             }
  249:         case '=':
  250:             if (peek() == '=') {
  251:                 input(); yylval.i = EQ; RET(EQ);
  252:             } else {
  253:                 yylval.i = ASSIGN; RET(ASGNOP);
  254:             }
  255:         case '>':
  256:             if (peek() == '=') {
  257:                 input(); yylval.i = GE; RET(GE);
  258:             } else if (peek() == '>') {
  259:                 input(); yylval.i = APPEND; RET(APPEND);
  260:             } else {
  261:                 yylval.i = GT; RET(GT);
  262:             }
  263:         case '+':
  264:             if (peek() == '+') {
  265:                 input(); yylval.i = INCR; RET(INCR);
  266:             } else if (peek() == '=') {
  267:                 input(); yylval.i = ADDEQ; RET(ASGNOP);
  268:             } else
  269:                 RET('+');
  270:         case '-':
  271:             if (peek() == '-') {
  272:                 input(); yylval.i = DECR; RET(DECR);
  273:             } else if (peek() == '=') {
  274:                 input(); yylval.i = SUBEQ; RET(ASGNOP);
  275:             } else
  276:                 RET('-');
  277:         case '*':
  278:             if (peek() == '=') {    /* *= */
  279:                 input(); yylval.i = MULTEQ; RET(ASGNOP);
  280:             } else if (peek() == '*') { /* ** or **= */
  281:                 input();    /* eat 2nd * */
  282:                 if (peek() == '=') {
  283:                     input(); yylval.i = POWEQ; RET(ASGNOP);
  284:                 } else {
  285:                     RET(POWER);
  286:                 }
  287:             } else
  288:                 RET('*');
  289:         case '/':
  290:             RET('/');
  291:         case '%':
  292:             if (peek() == '=') {
  293:                 input(); yylval.i = MODEQ; RET(ASGNOP);
  294:             } else
  295:                 RET('%');
  296:         case '^':
  297:             if (peek() == '=') {
  298:                 input(); yylval.i = POWEQ; RET(ASGNOP);
  299:             } else
  300:                 RET(POWER);
  301: 
  302:         case '$':
  303:             /* BUG: awkward, if not wrong */
  304:             c = gettok(&buf, &bufsize);
  305:             if (isalpha(c)) {
  306:                 if (strcmp(buf, "NF") == 0) {   /* very special */
  307:                     unputstr("(NF)");
  308:                     RET(INDIRECT);
  309:                 }
  310:                 c = peek();
  311:                 if (c == '(' || c == '[' || (infunc && isarg(buf) >= 0)) {
  312:                     unputstr(buf);
  313:                     RET(INDIRECT);
  314:                 }
  315:                 yylval.cp = setsymtab(buf, "", 0.0, STR|NUM, symtab);
  316:                 RET(IVAR);
  317:             } else if (c == 0) {    /*  */
  318:                 SYNTAX( "unexpected end of input after $" );
  319:                 RET(';');
  320:             } else {
  321:                 unputstr(buf);
  322:                 RET(INDIRECT);
  323:             }
  324:     
  325:         case '}':
  326:             if (--bracecnt < 0)
  327:                 SYNTAX( "extra }" );
  328:             sc = 1;
  329:             RET(';');
  330:         case ']':
  331:             if (--brackcnt < 0)
  332:                 SYNTAX( "extra ]" );
  333:             RET(']');
  334:         case ')':
  335:             if (--parencnt < 0)
  336:                 SYNTAX( "extra )" );
  337:             RET(')');
  338:         case '{':
  339:             bracecnt++;
  340:             RET('{');
  341:         case '[':
  342:             brackcnt++;
  343:             RET('[');
  344:         case '(':
  345:             parencnt++;
  346:             RET('(');
  347:     
  348:         case '"':
  349:             return string();    /* BUG: should be like tran.c ? */
  350:     
  351:         default:
  352:             RET(c);
  353:         }
  354:     }
  355: }
  356: 
  357: int string(void)
  358: {
  359:     int c, n;
  360:     char *s, *bp;
  361:     static char *buf = 0;
  362:     static int bufsz = 500;
  363: 
  364:     if (buf == 0 && (buf = (char *) malloc(bufsz)) == NULL)
  365:         FATAL("out of space for strings");
  366:     for (bp = buf; (c = input()) != '"'; ) {
  367:         if (!adjbuf(&buf, &bufsz, bp-buf+2, 500, &bp, "string"))
  368:             FATAL("out of space for string %.10s...", buf);
  369:         switch (c) {
  370:         case '\n':
  371:         case '\r':
  372:         case 0:
  373:             SYNTAX( "non-terminated string %.10s...", buf );
  374:             lineno++;
  375:             if (c == 0) /* hopeless */
  376:                 FATAL( "giving up" );
  377:             break;
  378:         case '\\':
  379:             c = input();
  380:             switch (c) {
  381:             case '"': *bp++ = '"'; break;
  382:             case 'n': *bp++ = '\n'; break;  
  383:             case 't': *bp++ = '\t'; break;
  384:             case 'f': *bp++ = '\f'; break;
  385:             case 'r': *bp++ = '\r'; break;
  386:             case 'b': *bp++ = '\b'; break;
  387:             case 'v': *bp++ = '\v'; break;
  388:             case 'a': *bp++ = '\007'; break;
  389:             case '\\': *bp++ = '\\'; break;
  390: 
  391:             case '0': case '1': case '2': /* octal: \d \dd \ddd */
  392:             case '3': case '4': case '5': case '6': case '7':
  393:                 n = c - '0';
  394:                 if ((c = peek()) >= '0' && c < '8') {
  395:                     n = 8 * n + input() - '0';
  396:                     if ((c = peek()) >= '0' && c < '8')
  397:                         n = 8 * n + input() - '0';
  398:                 }
  399:                 *bp++ = n;
  400:                 break;
  401: 
  402:             case 'x':   /* hex  \x0-9a-fA-F + */
  403:                 {   char xbuf[100], *px;
  404:                 for (px = xbuf; (c = input()) != 0 && px-xbuf < 100-2; ) {
  405:                     if (isdigit(c)
  406:                      || (c >= 'a' && c <= 'f')
  407:                      || (c >= 'A' && c <= 'F'))
  408:                         *px++ = c;
  409:                     else
  410:                         break;
  411:                 }
  412:                 *px = 0;
  413:                 unput(c);
  414:                 sscanf(xbuf, "%x", (unsigned int *) &n);
  415:                 *bp++ = n;
  416:                 break;
  417:                 }
  418: 
  419:             default: 
  420:                 *bp++ = c;
  421:                 break;
  422:             }
  423:             break;
  424:         default:
  425:             *bp++ = c;
  426:             break;
  427:         }
  428:     }
  429:     *bp = 0; 
  430:     s = tostring(buf);
  431:     *bp++ = ' '; *bp++ = 0;
  432:     yylval.cp = setsymtab(buf, s, 0.0, CON|STR|DONTFREE, symtab);
  433:     RET(STRING);
  434: }
  435: 
  436: 
  437: int binsearch(char *w, Keyword *kp, int n)
  438: {
  439:     int cond, low, mid, high;
  440: 
  441:     low = 0;
  442:     high = n - 1;
  443:     while (low <= high) {
  444:         mid = (low + high) / 2;
  445:         if ((cond = strcmp(w, kp[mid].word)) < 0)
  446:             high = mid - 1;
  447:         else if (cond > 0)
  448:             low = mid + 1;
  449:         else
  450:             return mid;
  451:     }
  452:     return -1;
  453: }
  454: 
  455: int word(char *w) 
  456: {
  457:     Keyword *kp;
  458:     int c, n;
  459: 
  460:     n = binsearch(w, keywords, sizeof(keywords)/sizeof(keywords[0]));
  461: /* BUG: this ought to be inside the if; in theory could fault (daniel barrett) */
  462:     kp = keywords + n;
  463:     if (n != -1) {  /* found in table */
  464:         yylval.i = kp->sub;
  465:         switch (kp->type) { /* special handling */
  466:         case BLTIN:
  467:             if (kp->sub == FSYSTEM && safe)
  468:                 SYNTAX( "system is unsafe" );
  469:             RET(kp->type);
  470:         case FUNC:
  471:             if (infunc)
  472:                 SYNTAX( "illegal nested function" );
  473:             RET(kp->type);
  474:         case RETURN:
  475:             if (!infunc)
  476:                 SYNTAX( "return not in function" );
  477:             RET(kp->type);
  478:         case VARNF:
  479:             yylval.cp = setsymtab("NF", "", 0.0, NUM, symtab);
  480:             RET(VARNF);
  481:         default:
  482:             RET(kp->type);
  483:         }
  484:     }
  485:     c = peek(); /* look for '(' */
  486:     if (c != '(' && infunc && (n=isarg(w)) >= 0) {
  487:         yylval.i = n;
  488:         RET(ARG);
  489:     } else {
  490:         yylval.cp = setsymtab(w, "", 0.0, STR|NUM|DONTFREE, symtab);
  491:         if (c == '(') {
  492:             RET(CALL);
  493:         } else {
  494:             RET(VAR);
  495:         }
  496:     }
  497: }
  498: 
  499: void startreg(void) /* next call to yylex will return a regular expression */
  500: {
  501:     reg = 1;
  502: }
  503: 
  504: int regexpr(void)
  505: {
  506:     int c;
  507:     static char *buf = 0;
  508:     static int bufsz = 500;
  509:     char *bp;
  510: 
  511:     if (buf == 0 && (buf = (char *) malloc(bufsz)) == NULL)
  512:         FATAL("out of space for rex expr");
  513:     bp = buf;
  514:     for ( ; (c = input()) != '/' && c != 0; ) {
  515:         if (!adjbuf(&buf, &bufsz, bp-buf+3, 500, &bp, "regexpr"))
  516:             FATAL("out of space for reg expr %.10s...", buf);
  517:         if (c == '\n') {
  518:             SYNTAX( "newline in regular expression %.10s...", buf ); 
  519:             unput('\n');
  520:             break;
  521:         } else if (c == '\\') {
  522:             *bp++ = '\\'; 
  523:             *bp++ = input();
  524:         } else {
  525:             *bp++ = c;
  526:         }
  527:     }
  528:     *bp = 0;
  529:     if (c == 0)
  530:         SYNTAX("non-terminated regular expression %.10s...", buf);
  531:     yylval.s = tostring(buf);
  532:     unput('/');
  533:     RET(REGEXPR);
  534: }
  535: 
  536: /* low-level lexical stuff, sort of inherited from lex */
  537: 
  538: char    ebuf[300];
  539: char    *ep = ebuf;
  540: char    yysbuf[100];    /* pushback buffer */
  541: char    *yysptr = yysbuf;
  542: FILE    *yyin = 0;
  543: 
  544: int input(void) /* get next lexical input character */
  545: {
  546:     int c;
  547:     extern char *lexprog;
  548: 
  549:     if (yysptr > yysbuf)
  550:         c = (uschar)*--yysptr;
  551:     else if (lexprog != NULL) { /* awk '...' */
  552:         if ((c = (uschar)*lexprog) != 0)
  553:             lexprog++;
  554:     } else              /* awk -f ... */
  555:         c = pgetc();
  556:     if (c == '\n')
  557:         lineno++;
  558:     else if (c == EOF)
  559:         c = 0;
  560:     if (ep >= ebuf + sizeof ebuf)
  561:         ep = ebuf;
  562:     return *ep++ = c;
  563: }
  564: 
  565: void unput(int c)   /* put lexical character back on input */
  566: {
  567:     if (c == '\n')
  568:         lineno--;
  569:     if (yysptr >= yysbuf + sizeof(yysbuf))
  570:         FATAL("pushed back too much: %.20s...", yysbuf);
  571:     *yysptr++ = c;
  572:     if (--ep < ebuf)
  573:         ep = ebuf + sizeof(ebuf) - 1;
  574: }
  575: 
  576: void unputstr(const char *s)    /* put a string back on input */
  577: {
  578:     int i;
  579: 
  580:     for (i = strlen(s)-1; i >= 0; i--)
  581:         unput(s[i]);
  582: }