l.c

Go to the documentation of this file.

/*
 * a small awk clone
 *
 * (C) 1989 Saeko Hirabauashi & Kouichi Hirabayashi
 *
 * Absolutely no warranty. Use this software with your own risk.
 *
 * Permission to use, copy, modify and distribute this software for any
 * purpose and without fee is hereby granted, provided that the above
 * copyright and disclaimer notice.
 *
 * This program was written to fit into 64K+64K memory of the Minix 1.2.
 */


#include <stdio.h>
#include <ctype.h>
#include "awk.h"

extern char *srcprg;    /* inline program */
extern FILE *pfp;       /* program file */

int sym;        /* lexical token */
int sym1;       /* auxiliary lexical token */
int regexflg;   /* set by parser (y.c) to indicate parsing REGEXPR */
int funflg;     /* set by parser (y.c) to indicate parsing FUNCTION */
int printflg;   /* set by parser (y.c) to indicate parsing PRINT */
int getlineflg; /* set by parser (y.c) to indicate parsing GETLINE */
char text[BUFSIZ];      /* lexical word */
char line[BUFSIZ];      /* program line for error message (ring buffer) */
char *linep = line;     /* line pointer */
char funnam[128];       /* function name for error message */
int lineno = 1;

lex()
{
  int c, d;
  char *s;

  if (regexflg)
        return sym = scanreg();
next:
  while ((c = Getc()) == ' ' || c == '\t')
        ;
  while (c == '#')
        for (c = Getc(); c != '\n'; c = Getc())
                ;
  switch (c) {
  case '\\':
        if ((c = Getc()) == '\n') {
                lineno++;
                goto next;
        }
        break;
  case '\n':
        lineno++;
        break;
  }
  switch (c) {
  case EOF:     return sym = 0;
  case '+':     return sym = follow2('=', '+', ADDEQ, INC, ADD);
  case '-':     return sym = follow2('=', '-', SUBEQ, DEC, SUB);
  case '*':     return sym = follow('=', MULTEQ, MULT);
  case '/':     return sym = follow('=', DIVEQ, DIV);
  case '%':     return sym = follow('=', MODEQ, MOD);
  case '^':     return sym = follow('=', POWEQ, POWER);
  case '=':     return sym = follow('=', EQ, ASSIGN);
  case '!':     return sym = follow2('=', '~', NE, NOMATCH, NOT);
  case '&':     return sym = follow('&', AND, BINAND);
  case '|':     sym = follow('|', OR, BINOR);
                if (printflg && sym == BINOR)
                        sym = R_POUT;
                return sym;
  case '<':     sym = follow2('=', '<', LE, SHIFTL, LT);
                if (getlineflg && sym == LT)
                        sym = R_IN;
                return sym;
  case '>':     sym = follow2('=', '>', GE, SHIFTR, GT);
                if (printflg) {
                        switch (sym) {
                        case GT: sym = R_OUT; break;
                        case SHIFTR: sym = R_APD; break;
                        }
                }
                return sym;
  case '~':     return sym = MATCH; break;
  case ';': case '\n':  return sym = EOL;
  }
  if (isalpha(c) || c == '_') {
        for (s = text; isalnum(c) || c == '_'; ) {
                *s++ = c; c = Getc();
        }
        Ungetc(c);
        *s = '\0';
        if ((d = iskeywd(text)) == 0 &&
                (d = isbuiltin(text, &sym1)) == 0) {
                        if (c == '(')
                                return sym = CALL;
                        else if (funflg) {
                                if ((sym1 = isarg(text)) != -1)
                                        return sym = ARG;
                        }
        }
        return sym = d ? d : IDENT;
  }
  else if (c == '.' || (isdigit(c))) {
        Ungetc(c);
        return sym = scannum(text);     /* NUMBER */
  }
  else if (c == '"')
        return sym = scanstr(text);     /* STRING */
  return sym = c;
}

static
follow(c1, r1, r2)
{
  register int c;

  if ((c = Getc()) == c1)
        return r1;
  else {
        Ungetc(c);
        return r2;
  }
}

static
follow2(c1, c2, r1, r2, r3)
{
  register int c;

  if ((c = Getc()) == c1)
        return r1;
  else if (c == c2)
        return r2;
  else {
        Ungetc(c);
        return r3;
  }
}

static
iskeywd(s) char *s;
{
  static struct { char *kw; int token; } tab[] = {
        "BEGIN", BEGIN,
        "END", END,
        "break", BREAK,
        "continue", CONTIN,
        "delete", DELETE,
        "do", DO,
        "else", ELSE,
        "exit", EXIT,
        "for", FOR,
        "func", FUNC,
        "function", FUNC,
        "getline", GETLINE,
        "if", IF,
        "in", IN,
        "next", NEXT,
        "print", PRINT,
        "printf", PRINTF,
        "return", RETURN,
        "sprint", SPRINT,
        "sprintf", SPRINTF,
        "while", WHILE,
        "", 0, 0
  };
  register int i;

  for (i = 0; tab[i].token; i++)
        if (strcmp(tab[i].kw, s) == 0)
                break;
  return tab[i].token;
}

static
isbuiltin(s, p) char *s; int *p;
{
  static struct { char *kw; int type; int token; } tab[] = {
        "atan2", MATHFUN, ATAN2,
        "close", STRFUN, CLOSE,
        "cos", MATHFUN, COS,
        "exp", MATHFUN, EXP,
        "gsub", SUBST, RGSUB,
        "index", STRFUN, INDEX,
        "int", MATHFUN, INT,
        "length", STRFUN, LENGTH,
        "log", MATHFUN, LOG,
        "match", STRFUN, RMATCH,
        "sin", MATHFUN, SIN,
        "sqrt", MATHFUN, SQRT,
        "rand", MATHFUN, RAND,
        "srand", MATHFUN, SRAND,
        "split", STRFUN, SPLIT,
        "sub", SUBST, RSUB,
        "substr", STRFUN, SUBSTR,
        "system", STRFUN, SYSTEM,
        "", 0, 0
  };
  register int i;

  for (i = 0; tab[i].token; i++)
        if (strcmp(tab[i].kw, s) == 0)
                break;
  *p = tab[i].token;
  return tab[i].type;
}

static
scannum(s) char *s;
{
  register int c;
  char *strchr();

  if ((c = Getc()) && strchr("+-", c) != NULL) {
        *s++ = c; c = Getc();
  }
  while (isdigit(c)) {
        *s++ = c; c = Getc();
  }
  if (c == '.') {
        *s++ = c; c = Getc();
        while (isdigit(c)) {
                *s++ = c; c = Getc();
        }
  }
  if (c && strchr("eE", c) != NULL) {
        *s++ = c; c = Getc();
        if (c && strchr("+-", c) != NULL) {
                *s++ = c; c = Getc();
        }
        while (isdigit(c)) {
                *s++ = c; c = Getc();
        }
  }
  *s = '\0';
  Ungetc(c);
  return NUMBER;
}

static
scanstr(s) char *s;
{
  register int c, i, j;

  for (c = Getc(); c != EOF & c != '"'; ) {
        if (c == '\\') {
                switch (c = Getc()) {
                case 'b': c = '\b'; break;
                case 'f': c = '\f'; break;
                case 'n': c = '\n'; break;
                case 'r': c = '\r'; break;
                case 't': c = '\t'; break;
                default:
                if (isdigit(c)) {
                        for (i = j = 0; i < 3 && isdigit(c); c = Getc(), i++)
                                j = j * 8 + c - '0';
                        Ungetc(c);
                        c = j;
                }
                break;
                }
        }
        *s++ = c;
        if (isKanji(c))
                *s++ = Getc();
        c = Getc();
  }
  *s = '\0';
  return STRING;
}

static
scanreg()
{
  register int c;
  register char *s;

  for (s = text; (c = Getc()) != '/'; )
        if (c == '\n')
                error("newline in regular expression");
        else {
                if (isKanji(c) || c == '\\') {
                        *s++ = c; c = Getc();
                }
                *s++ = c;
        }
  *s = '\0';
  return REGEXP;
}

static int c0;

Ungetc(c)
{
  c0 = c;

  if (linep > line) {
        if (--linep < line)
                linep == line + BUFSIZ - 1;
  }
}

Getc()
{
  register int c;
  char *s, *t;

  if (c0) {
        c = c0; c0 = 0;
  }     
  else if (srcprg)
        c = *srcprg ? *srcprg++ : EOF;
  else
        c = fgetc(pfp);

#if 0
  if (linep - line == BUFSIZ) {
printf("!!!\n");
        for (s = line; *s != '\n' && ((s - line) <BUFSIZ); s++)
                ;
printf("***(%d)***\n", *s);
        for (t = line; s < linep; )
                *t++ = *++s;
  }
#endif
  *linep++ = c;
  if ((linep - line) == BUFSIZ)
        linep = line;
  return c;
}

---