lex.c

/* vim: set ts=8 : */
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdarg.h>
#include <stdlib.h>
#include <math.h>
#include <float.h>

#include "config.h"
#include "instrs.h"
#include "lint.h"
#include "lang.h"
#include "string.h"
#include "interpret.h"
#include "exec.h"
#include "lex.h"
#include "mstring.h"
#include "mudstat.h"
#include "simulate.h"
#include "efun_table.h"
#include "backend.h"
#include "hash.h"

#define isalunum(c) (isalnum(c) || (c) == '_')
#define NELEM(a) (sizeof (a) / sizeof((a)[0]))

#define WARNING 0
#define ERROR   1

int current_line;
int total_lines;    /* Used to compute average compiled lines/s */
char *current_file;
int pragma_strict_types;    /* Force usage of strict types. */
int pragma_no_clone;
int pragma_no_inherit;
int pragma_no_shadow;
int pragma_resident;

extern void smart_log (char *, int, char *);
struct lpc_predef_s *lpc_predefs=NULL;
static void handle_define (char *);
static void free_defines (void), add_define (char *, int, char *);
static int expand_define (void);
static void add_input (char *);
static void myungetc (int);
static int lookup_resword (char *);
static int cond_get_exp (int);
static int exgetc (void);
static void refill (void);
static int cmygetc (void);
static int yylex1 (void);
static void skip_comment (void);
static void skip_comment2 (void);
static INLINE int mygetc (void);

static int number (const long long);
static int real (const double);
static int ident (const char *);
static int string (const char *);

static FILE *yyin;
static int lex_fatal;
static char **inc_list;
static int inc_list_size;


struct allocation_pool lex_allocations = EMPTY_ALLOCATION_POOL;


#define EXPANDMAX 25000
static int nexpands;

extern int s_flag;

#ifndef tolower
extern int tolower (int);
#endif

void yyerror(char *);
int yylex (void);

#define MAXLINE 1024
static char yytext[MAXLINE];
static int slast, lastchar;
static int num_incfiles, current_incfile, incdepth;

struct defn {
    struct defn *next;
    char *name;
    int undef;
    char *exps;
    int nargs;
};
struct defn *lookup_define(char *);

static struct ifstate {
    struct ifstate *next;
    int state;
} *iftop = 0;
#define EXPECT_ELSE 1
#define EXPECT_ENDIF 2

static struct incstate {
    struct incstate *next;
    FILE *yyin;
    int incfnum;
    int line;
    char *file;
    int slast, lastchar;
    int pragma_strict_types;
    int nbuf;
    char *outp;
} *inctop = 0;

/* DEFMAX must be even. We divide it by 2 in mygetc(). */
#define DEFMAX 20000
static char defbuf[DEFMAX];
static int nbuf;
static char *outp;

static struct {
    int token;
    int line;
    YYSTYPE lval;
} keep1, keep2, keep3, keep4;

static void
calculate_include_path(char *name, char *dest)
{
    char *current;

    if ( (current = strrchr(dest, '/')) == NULL)   /* strip filename */
    {
        /* current_file is in the root directory */
        current = dest;
    }
    *current = '\0';

    while (*name == '/')
    {
        name++;
        current = dest;
        *current = '\0';  /* absolute path */
    }

    while (*name)
    {
        if (strncmp(name, "../", 3) == 0)
        {
            if (*dest == '\0') /* including from above mudlib is NOT allowed */
                break;

            /* Remove previous path element */
            while (current > dest)
            {
                *current-- = '\0';
                if (*current == '/')
                    break;
            }
            if (current == dest)
            {
                *current = '\0';
            }

            name += 3;   /* skip "../" */
        }
        else if (strncmp(name, "./", 2) == 0)
        {
            name += 2;
        }
        else
        { /* append first component to dest */
            if (*dest)
                *current++ = '/';    /* only if dest is not empty !! */
            while (*name != '\0' && *name != '/')
                *current++ = *name++;
            if (*name == '/')
                name++;
            else
                *current = '\0'; /* Last element */
        }
    }
}

static INLINE int
mygetc(void)
{
    if (!nbuf)
    {
        char  buffer[(DEFMAX / 2) + 1];

        if (feof(yyin))
        {
            return EOF;
        }

        nbuf = (int)fread(buffer, sizeof(char), (DEFMAX / 2), yyin);
        if (!nbuf)
        {
            return EOF;
        }

        outp -= nbuf;
        memcpy(outp, buffer, nbuf);
    }

    lastchar = slast;
    slast = *outp;
    nbuf--;
    outp++;

    return slast;
}

static INLINE int
gobble(int c)
{
    int d;
    d = mygetc();
    if (c == d)
        return 1;
    *--outp = d;
    nbuf++;
    return 0;
}


__attribute__((format(printf, 1, 2)))
static void
lexerror(char *fmt, ...)
{
    char buffer[1024];
    va_list ap;

    va_start(ap, fmt);
    vsnprintf(buffer, sizeof(buffer), fmt, ap);
    yyerror(buffer);
    va_end(ap);
    lex_fatal++;
}

static void
lexwarning(char *str)
{
    (void)fprintf(stderr, "/%s: Warning: %s line %d\n", current_file, str,
          current_line);
    (void)fflush(stderr);
    smart_log(current_file, current_line, str);
}

static int
skip_to(char *token, char *atoken)
{
    char b[20], *p;
    int c;
    int nest;

    for (nest = 0;;)
    {
        c = mygetc();
        if (c == '#')
        {
            do
            {
                c = mygetc();
            } while (isspace(c));
            for (p = b; c != '\n' && c != EOF; )
            {
                if (p < b+sizeof b-1)
                    *p++ = c;
                c = mygetc();
            }
            *p++ = 0;
            for (p = b; *p && !isspace(*p); p++)
                ;
            *p = 0;
            /*(void)fprintf(stderr, "skip checks %s\n", b);*/
            if (strcmp(b, "if") == 0 || strcmp(b, "ifdef") == 0 ||
                strcmp(b, "ifndef") == 0)
            {
                nest++;
            }
            else if (nest > 0)
            {
                if (strcmp(b, "endif") == 0)
                    nest--;
            }
            else
            {
                if (strcmp(b, token) == 0)
                    return 1;
                else if (atoken && strcmp(b, atoken) == 0)
                    return 0;
            }
        }
        else
        {
            /*(void)fprintf(stderr, "skipping (%d) %c", c, c);*/
            while (c != '\n' && c != EOF)
            {
                c = mygetc();
                /*(void)fprintf(stderr, "%c", c);*/
            }
            if (c == EOF)
            {
                lexerror("Unexpected end of file while skipping");
                return 1;
            }
        }
        store_line_number_info(current_incfile, current_line);
        current_line++;
        total_lines++;
    }
}

static void
handle_cond(int c)
{
    struct ifstate *p;

    /*(void)fprintf(stderr, "cond %d\n", c);*/
    if (c || skip_to("else", "endif"))
    {
        p = (struct ifstate *)xalloc(sizeof(struct ifstate));
        p->next = iftop;
        iftop = p;
        p->state = c ? EXPECT_ELSE : EXPECT_ENDIF;
    }
    if (!c)
    {
        store_line_number_info(current_incfile, current_line);
        current_line++;
        total_lines++;
    }
}

/* Make sure the path does not have any ".." elements. */
char *
check_valid_compile_path(char *path, char *file_name, char *calling_function)
{
#if 0
    struct svalue *ret;
#endif
    char *p = path;

    while (*p)
    {
        if (p[0] == '.' && p[1] == '.')
            return NULL;
        p++;
    }
#if 0
    push_string(path, STRING_MSTRING);
    push_string(file_name, STRING_MSTRING);
    push_string(calling_function, STRING_MSTRING);
    ret = apply_master_ob(M_VALID_COMPILE_PATH, 3);
    if (ret)
        path = tmpstring_copy(ret->u.string);
#endif
    return path;
}

/* Try to load the file who's full path is specified in buf */
static INLINE FILE *
inc_try(char *buf)
{
    struct incstate *inc;
    char errbuf[1024];
    char *new_name;
    FILE *f;

    extern void remember_include(char *);
    extern char *current_loaded_file;

    new_name = check_valid_compile_path(buf, current_loaded_file, "include");
    if (!new_name)
    {
        lexerror("Invalid include.");
        return NULL;
    }
    if (new_name && (f = fopen(new_name, "r")) != NULL)
    {
#ifdef WARN_INCLUDES
        for (inc = inctop ; inc ; inc = inc->next)
            if (strcmp(inc->file, new_name) == 0)
            {
                (void)snprintf(errbuf, sizeof(errbuf), "File /%s already included,", buf);
                lexwarning(errbuf);
            }
#endif
        if (s_flag)
            num_fileread++;
        remember_include(new_name);
        return f;
    }
    return NULL;
}

/* Find and open a file that has been specified in a "#include <file>" */
static INLINE FILE *
inc_open(char *buf, size_t len, char *name)
{
    int i;
    FILE *f;

    if (incdepth >= MAX_INCLUDE)
    {
        lexerror("To deep recursion of includes.");
        return NULL;
    }
    (void)strcpy(buf, current_file);
    calculate_include_path(name, buf);
    if ((f = inc_try(buf)) != NULL)
        return f;
    /*
     * Search all include dirs specified.
     */
    for (i = 0; i < inc_list_size; i++)
    {
        (void)snprintf(buf, len, "%s%s", inc_list[i], name);
        if ((f = inc_try(buf)) != NULL)
            return f;
    }
    return NULL;
}

int
handle_include(char *name, int ignore_errors)
{
    char *p;
    char buf[1024];
    FILE *f;
    struct incstate *is;
    int delim;

    if (*name != '"' && *name != '<')
    {
        struct defn *d;
        if ((d = lookup_define(name)) && d->nargs == -1)
        {
            char *q;
            q = d->exps;
            while (isspace(*q))
                q++;
            return handle_include(q, ignore_errors);
        }
        else
        {
            if (!ignore_errors)
                lexerror("Missing leading \" or < in #include");
            return 0;
        }
    }
    delim = *name++ == '"' ? '"' : '>';
    for (p = name; *p && *p != delim; p++)
        ;
    if (!*p)
    {
        if (!ignore_errors)
            lexerror("Missing trailing \" or > in #include");
        return 0;
    }
    if (strlen(name) > sizeof(buf) - 100)
    {
        if (!ignore_errors)
            lexerror("Include name too long.");
        return 0;
    }
    *p = 0;

    if ((f = inc_open(buf, sizeof(buf), name)) == NULL)
    {
        if (!ignore_errors) {
            lexerror("Cannot #include %s\n", name);
        }

        return 0;
    }

    is = (struct incstate *)xalloc(sizeof(struct incstate));
    is->yyin = yyin;
    is->line = current_line;
    is->file = current_file;
    is->incfnum = current_incfile;
    is->slast = slast;
    is->lastchar = lastchar;
    is->next = inctop;
    is->pragma_strict_types = pragma_strict_types;

    if (nbuf)
    {
        memcpy(is->outp = (char *)xalloc(nbuf + 1), outp, nbuf);
        is->nbuf = nbuf;
        nbuf = 0;
        outp = defbuf + DEFMAX;
    }
    else
    {
        is->nbuf = 0;
        is->outp = NULL;
    }

    pragma_strict_types = 0;
    inctop = is;
    current_line = 1;
    current_file = xalloc(strlen(buf)+1);
    current_incfile = ++num_incfiles;
    (void)strcpy(current_file, buf);
    slast = lastchar = '\n';
    yyin = f;
    incdepth++;
    return 1;
}

static void
handle_exception(int action, char *message)
{
    char buf[1024];

    (void)strcpy(buf, "\"");

    if (strlen(message) < 2)
        (void)strcat(buf, "Unspecified condition");
    else
        (void)strcat(buf, message);
    (void)strcat(buf, "\"");

    push_number(action);
    push_string(buf, STRING_MSTRING);
    push_number(current_line);
    push_string(current_file, STRING_MSTRING);
    (void)apply_master_ob(M_PARSE_EXCEPTION, 4);

    if (action == ERROR)
        lexerror("Parse aborted on #error statement,");
}

static void
skip_comment(void)
{
    int c;

    for (;;)
    {
        while ((c = mygetc()) != '*')
        {
            if (c == EOF)
            {
                lexerror("End of file in a comment");
                return;
            }
            if (c == '\n')
            {
                nexpands=0;
                store_line_number_info(current_incfile, current_line);
                current_line++;
            }
        }
        do
        {
            if ((c = mygetc()) == '/')
                return;
            if (c == '\n')
            {
                nexpands=0;
                store_line_number_info(current_incfile, current_line);
                current_line++;
            }
        } while (c == '*');
    }
}

static void
skip_comment2(void)
{
    int c;

    while ((c = mygetc()) != '\n' && c != EOF)
        ;
    if (c == EOF) {
        lexerror("End of file in a // comment");
        return;
    }
    nexpands=0;
    store_line_number_info(current_incfile, current_line);
    current_line++;
}

#define TRY(c, t) if (gobble(c)) return t

static void
deltrail(char *ap)
{
    char *p = ap;
    if (!*p)
    {
        lexerror("Illegal # command");
    }
    else
    {
        while (*p && !isspace(*p))
            p++;
        *p = 0;
    }
}

#define SAVEC \
    if (yyp < yytext+MAXLINE-5)\
       *yyp++ = c;\
    else {\
       lexerror("Line too long");\
       break;\
    }

static void
handle_pragma(char *str)
{
    if (strcmp(str, "strict_types") == 0)
        pragma_strict_types = 1;
    else if (strcmp(str, "save_binary") == 0)
        ;
    else if (strcmp(str, "no_clone") == 0)
        pragma_no_clone = 1;
    else if (strcmp(str, "no_inherit") == 0)
        pragma_no_inherit = 1;
    else if (strcmp(str, "no_shadow") == 0)
        pragma_no_shadow = 1;
    else if (strcmp(str, "resident") == 0)
        pragma_resident = 1;
    else
        handle_exception(WARNING, "Unknown pragma");
}

static struct keyword {
    char *word;
    short  token;
    short min_args; /* Minimum number of arguments. */
    short max_args; /* Maximum number of arguments. */
    short ret_type; /* The return type used by the compiler. */
    unsigned char arg_type1;    /* Type of argument 1 */
    unsigned char arg_type2;    /* Type of argument 2 */
    unsigned char arg_index;
            /* Index pointing to where to find arg type */
    short Default;      /* an efun to use as default for last argument */
} predefs[] =
#include "efun_defs.c"

static struct keyword reswords[] = {
{ "break",      F_BREAK, },
{ "case",       F_CASE, },
{ "catch",      F_CATCH, },
{ "continue",       F_CONTINUE, },
{ "default",        F_DEFAULT, },
{ "do",         F_DO, },
{ "else",       F_ELSE, },
{ "float",      F_FLOAT, },
{ "for",        F_FOR, },
{ "foreach",    F_FOREACH, },
{ "function",       F_FUNCTION, },
{ "if",         F_IF, },
{ "inherit",        F_INHERIT, },
{ "int",        F_INT, },
{ "mapping",        F_MAPPING, },
{ "mixed",      F_MIXED, },
{ "nomask",     F_NO_MASK, },
{ "object",     F_OBJECT, },
{ "operator",       F_OPERATOR, },
{ "parse_command",  F_PARSE_COMMAND, },
{ "private",        F_PRIVATE, },
{ "public",     F_PUBLIC, },
{ "return",     F_RETURN, },
{ "sscanf",     F_SSCANF, },
{ "static",     F_STATIC, },
{ "status",     F_STATUS, },
{ "string",     F_STRING_DECL, },
{ "switch",     F_SWITCH, },
{ "throw",      F_THROW },
{ "try",        F_TRY, },
{ "varargs",        F_VARARGS, },
{ "void",       F_VOID, },
{ "while",      F_WHILE, },
};

struct instr instrs[EFUN_LAST - EFUN_FIRST + 1];

static int
lookupword(char *s, struct keyword *words, int h)
{
    int i, l, r;

    l = 0;
    for (;;)
    {
        i = (l + h) / 2;
        r = strcmp(s, words[i].word);
        if (r == 0)
            return words[i].token;
        else if (l == i)
            return -1;
        else if (r < 0)
            h = i;
        else
            l = i;
    }
}

static INLINE int
lookup_resword(char *s)
{
    return lookupword(s, reswords, NELEM(reswords));
}

static int
yylex1(void)
{
    register char *yyp;
    register int c;
    register int c1, c2;

    for (;;)
    {
        if (lex_fatal)
        {
            return -1;
        }
        switch(c = mygetc())
        {
        case EOF:
            if (inctop)
            {
                struct incstate *p;
                p = inctop;
                (void)fclose(yyin);
                /*(void)fprintf(stderr, "popping to %s\n", p->file);*/
                free(current_file);
                nexpands = 0;
                current_file = p->file;
                current_line = p->line + 1;
                current_incfile = p->incfnum;
                pragma_strict_types = p->pragma_strict_types;
                yyin = p->yyin;
                slast = p->slast;
                lastchar = p->lastchar;
                inctop = p->next;

                if (p->nbuf)
                {
                    nbuf = p->nbuf;
                    outp = defbuf + DEFMAX - nbuf;
                    memcpy(outp, p->outp, nbuf);
                    free((char *)p->outp);
                }
                else
                {
                    nbuf = 0;
                    outp = defbuf + DEFMAX;
                }

                store_line_number_info(current_incfile, current_line);
                incdepth--;

                free((char *)p);
                break;
            }
            if (iftop)
            {
                struct ifstate *p = iftop;
                lexerror(p->state == EXPECT_ENDIF ? "Missing #endif" : "Missing #else");
                while (iftop)
                {
                    p = iftop;
                    iftop = p->next;
                    free((char *)p);
                }
            }
            return -1;
        case '\n':
        {
            nexpands=0;
            store_line_number_info(current_incfile, current_line);
            current_line++;
            total_lines++;
        }
        /* FALLTHROUGH */
        case ' ':
        case '\t':
        case '\f':
        case '\v':
            break;
        case '+':
            TRY('+', F_INC);
            TRY('=', F_ADD_EQ);
            return c;
        case '-':
            TRY('>', F_ARROW);
            TRY('-', F_DEC);
            TRY('=', F_SUB_EQ);
            return c;
        case '&':
            TRY('&', F_LAND);
            TRY('=', F_AND_EQ);
            return c;
        case '|':
            TRY('|', F_LOR);
            TRY('=', F_OR_EQ);
            return c;
        case '^':
            TRY('=', F_XOR_EQ);
            return c;
        case '<':
            if (gobble('<')) {
                TRY('=', F_LSH_EQ);
                return F_LSH;
            }
            TRY('=', F_LE);
            return c;
        case '>':
            if (gobble('>'))
            {
                TRY('=', F_RSH_EQ);
                return F_RSH;
            }
            TRY('=', F_GE);
            return c;
        case '*':
            TRY('=', F_MULT_EQ);
            return c;
        case '%':
            TRY('=', F_MOD_EQ);
            return F_MOD;
        case '/':
            if (gobble('*'))
            {
                skip_comment();
                break;
            }
            else if (gobble('/'))
            {
                skip_comment2();
                break;
            }
            TRY('=', F_DIV_EQ);
            return c;
        case '=':
            TRY('=', F_EQ);
            return c;
        case ';':
        case '(':
        case ')':
        case ',':
        case '{':
        case '}':
        case '~':
        case '[':
        case ']':
        case '?':
        case '@':
            return c;
        case '!':
            TRY('=', F_NE);
            return F_NOT;
        case ':':
            TRY(':', F_COLON_COLON);
            return ':';
        case '.':
            if (gobble('.'))
            {
                if (gobble('.'))
                    return F_VARARG;
                else
                    return F_RANGE;
            }
            return c;
        case '#':
            if (lastchar == '\n')
            {
                char *ssp = 0;
                int quote;

                yyp = yytext;
                do
                {
                    c = mygetc();
                } while (isspace(c));

                for (quote = 0;;)
                {
                    if (c == '"')
                        quote ^= 1;

                    /*gc - handle comments cpp-like! 1.6.91 @@@*/
                    while (!quote && c == '/')
                    {
                        if (gobble('*'))
                        {
                            skip_comment();
                            c = mygetc();
                        }
                        else
                            break;
                    }

                    if (!ssp && isspace(c))
                        ssp = yyp;
                    if (c == '\n' || c == EOF)
                        break;
                    SAVEC;
                    c = mygetc();
                }
                if (ssp)
                {
                    *ssp++ = 0;
                    while (isspace(*ssp))
                        ssp++;
                }
                else
                {
                    ssp = yyp;
                }
                *yyp = 0;
                if (strcmp("define", yytext) == 0)
                {
                    handle_define(ssp);
                }
                else if (strcmp("if", yytext) == 0)
                {
#if 0
                    short int nega=0; /*@@@ allow #if !VAR gc 1.6.91*/
                    if (*ssp=='!'){ ssp++; nega=1;}
                    if (isdigit(*ssp))
                    {
                        char *p;
                        long l;
                        l = strtol(ssp, &p, 10);
                        while (isspace(*p))
                            p++;
                        if (*p)
                            lexerror("Condition too complex in #if");
                        else
                            handle_cond(nega ? !(int)l : (int)l);
                    }
                    else if (isalunum(*ssp))
                    {
                        char *p = ssp;
                        while (isalunum(*p))
                            p++;
                        if (*p)
                        {
                            *p++ = 0;
                            while (isspace(*p))
                                p++;
                        }
                        if (*p)
                            lexerror("Condition too complex in #if");
                        else
                        {
                            struct defn *d;
                            d = lookup_define(ssp);
                            if (d)
                            {
                                handle_cond(nega ? !atoi(d->exps) : atoi(d->exps));/* a hack! */
                            }
                            else
                            {
                                handle_cond(nega?1:0); /* cpp-like gc*/
                            }
                        }
                    }
                    else
                        lexerror("Condition too complex in #if");
#else
                    int cond;

                    myungetc(0);
                    add_input(ssp);
                    cond = cond_get_exp(0);
                    if (mygetc())
                    {
                        lexerror("Condition too complex in #if");
                        while (mygetc())
                            ;
                    }
                    else
                        handle_cond(cond);
#endif
                }
                else if (strcmp("ifdef", yytext) == 0)
                {
                    deltrail(ssp);
                    handle_cond(lookup_define(ssp) != 0);
                }
                else if (strcmp("ifndef", yytext) == 0)
                {
                    deltrail(ssp);
                    handle_cond(lookup_define(ssp) == 0);
                }
                else if (strcmp("else", yytext) == 0)
                {
                    if (iftop && iftop->state == EXPECT_ELSE)
                    {
                        struct ifstate *p = iftop;

                        /*(void)fprintf(stderr, "found else\n");*/
                        iftop = p->next;
                        free((char *)p);
                        (void)skip_to("endif", (char *)0);
                        store_line_number_info(current_incfile, current_line);
                        current_line++;
                        total_lines++;
                    }
                    else
                    {
                        lexerror("Unexpected #else");
                    }
                }
                else if (strcmp("endif", yytext) == 0)
                {
                    if (iftop && (iftop->state == EXPECT_ENDIF ||
                                  iftop->state == EXPECT_ELSE))
                    {
                        struct ifstate *p = iftop;

                        /*(void)fprintf(stderr, "found endif\n");*/
                        iftop = p->next;
                        free((char *)p);
                    }
                    else
                    {
                        lexerror("Unexpected #endif");
                    }
                }
                else if (strcmp("undef", yytext) == 0)
                {
                    struct defn *d;

                    deltrail(ssp);
                    if ((d = lookup_define(ssp)) != NULL )
                        d->undef++;
                }
                else if (strcmp("echo", yytext) == 0)
                {
                    (void)fprintf(stderr, "%s\n", ssp);
                }
                else if (strcmp("include", yytext) == 0)
                {
                    /*(void)fprintf(stderr, "including %s\n", ssp);     */
                    handle_include(ssp, 0);
                }
                else if (strcmp("pragma", yytext) == 0)
                {
                    deltrail(ssp);
                    handle_pragma(ssp);
                }
                else if (strcmp("error", yytext) == 0)
                {
                    handle_exception(ERROR, ssp);
                }
                else if (strcmp("warning", yytext) == 0)
                {
                    handle_exception(WARNING, ssp);
                }
                else
                {
                    lexerror("Unrecognised # directive");
                }
                myungetc('\n');
                break;
            }
            else
                goto badlex;
        case '\'':
            yylval.number = mygetc();
            if (yylval.number == '\\')
            {
                int tmp = mygetc();
                switch (tmp)
                {
                case 'n': yylval.number = '\n'; break;
                case 't': yylval.number = '\t'; break;
                case 'b': yylval.number = '\b'; break;
                case 'a': yylval.number = '\a'; break;
                case 'v': yylval.number = '\v'; break;
                case '\'':
                case '\\':
                case '"':
                    yylval.number = tmp; break;
                default:
                    lexwarning("Bad character escape sequence");
                    yylval.number = tmp;
                    break;
                }
            }
            if (!gobble('\''))
                lexerror("Illegal character constant");
            return F_NUMBER;
        case '"':
            yyp = yytext;
            *yyp++ = c;
            for (;;)
            {
                c = mygetc();
                if (c == EOF)
                {
                    lexerror("End of file in string");
                    return string("\"\"");
                }
                else if (c == '\n')
                {
                    lexerror("Newline in string");
                    return string("\"\"");
                }
                SAVEC;
                if (c == '"')
                    break;
                if (c == '\\')
                {
                    c = mygetc();
                    if ( c == '\n' )
                    {
                        yyp--;
                        store_line_number_info(current_incfile, current_line);
                        current_line++;
                        total_lines++;
                    }
                    else if ( c == EOF )
                    {
                        /* some operating systems give EOF only once */
                        myungetc(c);
                    }
                    else
                        *yyp++ = c;
                }
            }
            *yyp = 0;
            return string(yytext);

        case '0':
            c = mygetc();
            if ( c == 'X' || c == 'x' || c == 'o')
            {
                char *endptr;
                long long value;
                int base = 16;
                if (c == 'o')
                    base = 8;


                yyp = yytext;

                for (;;)
                {
                    c = mygetc();
                    if (!isxdigit(c))
                        break;
                    SAVEC;
                }
                myungetc(c);
                *yyp = '\0';

                value = strtoll(yytext, &endptr, base);
                if (*endptr != '\0')
                {
                    fprintf(stderr, "%s\n", yytext);
                    lexwarning("Invalid digits in octal number number");
                }

                return number(value);
            }
            myungetc(c);
            c = '0';
            /* FALLTHROUGH */
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
            yyp = yytext;
            *yyp++ = c;
            for (;;)
            {
                c = mygetc();
                if (!isdigit(c))
                    break;
                SAVEC;
            }
            if (c == '.')
            {
                if (isdigit(c1 = mygetc()))
                {
                    SAVEC;
                    c = c1;
                    SAVEC;
                    for (c = mygetc(); isdigit(c); c = mygetc())
                        SAVEC;
                    if (c == 'e' || c == 'E')
                    {
                        c1 = mygetc();
                        if (c1 == '-' || c1 == '+')
                        {
                            c2 = mygetc();
                            if (isdigit(c2))
                            {
                                SAVEC;
                                c = c1;
                                SAVEC;
                                c = c2;
                                SAVEC;
                                for (c = mygetc(); isdigit(c); c = mygetc())
                                    SAVEC;
                            }
                            else
                            {
                                myungetc(c2);
                                myungetc(c1);
                            }
                        }
                        else if (isdigit(c1))
                        {
                            SAVEC;
                            c = c1;
                            SAVEC;
                            for (c = mygetc(); isdigit(c); c = mygetc())
                                SAVEC;
                        }
                        else
                            myungetc(c1);
                    }
                    myungetc(c);
                    *yyp = 0;
                    return real(strtod(yytext, NULL));
                }
                myungetc(c1);
            }
            myungetc(c);
            *yyp = 0;
            if (*yytext == '0')
            {
                /* OCTALS */
                char *endptr;
                long long value;

                value = strtoll(yytext, &endptr, 010);

                if (*endptr != '\0')
                    lexwarning("Invalid digits in octal number");

                if (value != 0)
                    lexwarning("Obsolete octal format used. Use 0o111 syntax");

                return number(value);
            }
            return number(atoll(yytext));
        default:
            if (isalpha(c) || c == '_') {
                int r;

                yyp = yytext;
                *yyp++ = c;
                for (;;)
                {
                    c = mygetc();
                    if (!isalunum(c))
                        break;
                    SAVEC;
                }
                *yyp = 0;

                myungetc(c);
                if (!expand_define())
                {
                    r = lookup_resword(yytext);
                    if (r >= 0)
                    {
                        return r;
                    }
                    else
                        return ident(yytext);
                }
                break;
            }
            goto badlex;
        }
    }
  badlex:
    {
        lexerror("Illegal character (hex %02x) '%c'", c, c);
        return ' ';
    }
}

int
yylex(void)
{
    int r;

    if (keep1.token != -47)
    {
        /*
         * something in keep buffer. shift it out.
         */
        r = keep1.token;
        current_line = keep1.line;
        yylval = keep1.lval;
        keep1 = keep2;
        keep2 = keep3;
        keep3.token = -47;
        return r;
    }
    yytext[0] = 0;
    /*
     * see if the next token is a string
     */
    if ((r = yylex1()) == F_STRING)
    {
        keep4.lval = yylval;
        keep4.line = current_line;
        yytext[0] = 0;
        r = yylex1();
        for (;;)
        {
            keep1.line = current_line;
            keep1.lval = yylval;
            if (r != '+')
            {
                /*
                 * 1:string 2:non-'+'
                 *  save 2, return 1
                 */
                keep1.token = r;
                yylval = keep4.lval;
                current_line = keep4.line;
                return F_STRING;
            }
            yytext[0] = 0;
            r = yylex1();
            keep2.line = current_line;
            keep2.lval = yylval;
            if (r != F_STRING)
            {
                /*
                 * 1:string 2:'+' 3:non-string
                 *  save 2 and 3, return 1
                 */
                keep1.token = '+';
                keep2.token = r;
                current_line = keep4.line;
                yylval = keep4.lval;
                return F_STRING;
            }
            yytext[0] = 0;
            r = yylex1();
            keep3.line = current_line;
            keep3.lval = yylval;
            if (r == '[' || r == F_ARROW)
            {
                /*
                 * 1:string 2:'+' 3:string 4:[->
                 *  save 2, 3, 4, return 1
                 */
                keep1.token = '+';
                keep2.token = F_STRING;
                keep3.token = r;
                current_line = keep4.line;
                yylval = keep4.lval;
                return F_STRING;
            }
            /*
             * concatenate string constants
             */
            keep3.lval.string = pool_alloc(&lex_allocations, strlen(keep4.lval.string) +
                                         strlen(keep2.lval.string) + 1);
            (void)strcpy(keep3.lval.string, keep4.lval.string);
            (void)strcat(keep3.lval.string, keep2.lval.string);
            keep4.line = keep2.line;
            keep4.lval.string = keep3.lval.string;
        }
    }
    /*    (void)fprintf(stderr, "lex=%d(%s) ", r, yytext);*/
    return r;
}

extern YYSTYPE yylval;

static int
ident(const char *str)
{
    char *xp = pool_alloc(&lex_allocations, strlen(str) + 1);
    strcpy(xp, str);
    yylval.string = xp;
    return F_IDENTIFIER;
}

static int
string(const char *str)
{
    if (!*str)
    {
        str = "\"\"";
    }
    char *p = pool_alloc(&lex_allocations, strlen(str) + 1);
    yylval.string = p;

    for (str++; str[0] && str[1] ; str++, p++)
    {
        /* Copy the similar one to here /JH */
        if (str[0] == '\\') {
            if (str[1] == 'n') {
                *p = '\n';
            } else if (str[1] == 't') {
                *p = '\t';
            } else if (str[1] == 'r') {
                *p = '\r';
            } else if (str[1] == 'b') {
                *p = '\b';
            } else if (str[1] == 'a') {
                *p = '\a';
            } else if (str[1] == 'v') {
                *p = '\v';
            } else if (str[1] == '"' || str[1] == '\\' || str[1] == '\'') {
                *p = str[1];
            } else {
                lexwarning("Bad string escape sequence.");
                *p = str[1];
            }
            str++;
        } else
            *p = *str;
    }
    *p = '\0';
    return F_STRING;
}

static int
number(const long long i)
{
    yylval.number = i;
    return F_NUMBER;
}

static int
real(const double f)
{
    yylval.real = f;
    return F_FLOATC;
}

void
end_new_file(void)
{
    while (inctop)
    {
        struct incstate *p;
        p = inctop;
        (void)fclose(yyin);
        free(current_file);
        current_file = p->file;
        yyin = p->yyin;
        inctop = p->next;

        if (p->outp != NULL)
        {
            free((char *)p->outp);
        }

        free((char *)p);
    }
    while (iftop)
    {
        struct ifstate *p;

        p = iftop;
        iftop = p->next;
        free((char *)p);
    }
    free_defines();
    pool_free(&lex_allocations);
}

/*
 * Function name : ltoa
 * Description   : function converts integer into it's text representation
 * Arguments     : int       - the integer number to be converted
 * Returns       : char*     - the integer textual representation
 */
static inline char*
ltoa(long long intval)
{
    static char buffer[25];

    snprintf(buffer, sizeof(buffer), "%lld", intval);
    return buffer;
}

void
start_new_file(FILE *f)
{
    struct lpc_predef_s *tmpf;
    free_defines();
    add_define("_FUNCTION", -1, "");
    add_define("LPC4", -1, "");   /* Tell coders this is LPC ver 4.0 */
    add_define("CD_DRIVER", -1, "");
#ifdef DEBUG
    add_define("DEBUG_DRIVER", -1, "");
#endif
    add_define("T_INTEGER" , -1, ltoa(T_NUMBER));
    add_define("T_FLOAT"   , -1, ltoa(T_FLOAT));
    add_define("T_STRING"  , -1, ltoa(T_STRING));
    add_define("T_OBJECT"  , -1, ltoa(T_OBJECT));
    add_define("T_FUNCTION", -1, ltoa(T_FUNCTION));
    add_define("T_ARRAY"   , -1, ltoa(T_POINTER));
    add_define("T_MAPPING" , -1, ltoa(T_MAPPING));

    for (tmpf = lpc_predefs; tmpf; tmpf = tmpf->next)
    {
        char namebuf[NSIZE];
        char mtext[MLEN];

        *mtext='\0';
        (void)sscanf(tmpf->flag, "%[^=]=%[ -~=]", namebuf, mtext);
        if (strlen(namebuf) >= NSIZE)
            fatal("NSIZE exceeded\n");
        if (strlen(mtext) >= MLEN)
            fatal("MLEN exceeded\n");
        add_define(namebuf,-1,mtext);
    }
    keep1.token = keep2.token = keep3.token = -47;
    yyin = f;
    slast = '\n';
    lastchar = '\n';
    inctop = 0;         /* If not here, where? */
    num_incfiles = 0;
    current_incfile = 0;
    current_line = 1;
    lex_fatal = 0;
    incdepth = 0;
    nbuf = 0;
    outp = defbuf+DEFMAX;
    pragma_strict_types = 0;
    pragma_no_inherit = pragma_no_clone = pragma_no_shadow = pragma_resident = 0;
    nexpands = 0;
}

/*
 * The number of arguments stated below, are used by the compiler.
 * If min == max, then no information has to be coded about the
 * actual number of arguments. Otherwise, the actual number of arguments
 * will be stored in the byte after the instruction.
 * A maximum value of -1 means unlimited maximum value.
 *
 * If an argument has type 0 (T_INVALID) specified, then no checks will
 * be done at run time.
 *
 * The argument types are currently not checked by the compiler,
 * only by the runtime.
 */

static void
add_instr_name(char *name, int n)
{
    instrs[n - EFUN_FIRST].name = name;
}

#define T_ANY T_STRING|T_NUMBER|T_POINTER|T_OBJECT|T_MAPPING|T_FLOAT|T_FUNCTION
static void
add_instr_opname(char *name, int n, int ret, int arg1, int arg2)
{
    n -= EFUN_FIRST;
    instrs[n].name = name;
    instrs[n].min_arg = 2;
    instrs[n].max_arg = 2;
    instrs[n].type[0] = arg1;
    instrs[n].type[1] = arg2;
    instrs[n].ret_type = ret;
}

static void
add_instr_opname_prefix(char *name, int n, int ret, int arg)
{
    n -= EFUN_FIRST;
    instrs[n].name = name;
    instrs[n].min_arg = 1;
    instrs[n].max_arg = 1;
    instrs[n].type[0] = arg;
    instrs[n].type[1] = 0;
    instrs[n].ret_type = ret;
}

void
init_num_args(void)
{
    int i, n;

    for (i = 0; i<NELEM(predefs); i++)
    {
        n = predefs[i].token - EFUN_FIRST;
        if (n < 0 || n > NELEM(instrs))
            fatal("Token %s has illegal value %d.\n", predefs[i].word, n);
        instrs[n].min_arg = predefs[i].min_args;
        instrs[n].max_arg = predefs[i].max_args;
        instrs[n].name = predefs[i].word;
        instrs[n].type[0] = predefs[i].arg_type1;
        instrs[n].type[1] = predefs[i].arg_type2;
        instrs[n].Default = predefs[i].Default;
        instrs[n].ret_type = predefs[i].ret_type;
        instrs[n].arg_index = predefs[i].arg_index;
    }
    add_instr_opname("+", F_ADD, TYPE_ANY, T_ANY, T_ANY);
    add_instr_opname("-", F_SUBTRACT, TYPE_ANY, T_ANY, T_ANY);
    add_instr_opname("*", F_MULTIPLY, TYPE_ANY, T_ANY, T_ANY);
    add_instr_opname("/", F_DIVIDE, TYPE_ANY, T_ANY, T_ANY);
    add_instr_opname("%", F_MOD, TYPE_ANY, T_ANY, T_ANY);
    add_instr_opname("&", F_AND, TYPE_ANY, T_ANY, T_ANY);
    add_instr_opname("|", F_OR, TYPE_ANY, T_ANY, T_ANY);
    add_instr_opname("^", F_XOR, TYPE_NUMBER, T_NUMBER, T_NUMBER);
    add_instr_opname(">>", F_LSH, TYPE_NUMBER, T_NUMBER, T_NUMBER);
    add_instr_opname("<<", F_RSH, TYPE_NUMBER, T_NUMBER, T_NUMBER);
    add_instr_opname("<", F_LT, TYPE_NUMBER, T_ANY, T_ANY);
    add_instr_opname(">", F_GT, TYPE_NUMBER, T_ANY, T_ANY);
    add_instr_opname("<=", F_LE, TYPE_NUMBER, T_ANY, T_ANY);
    add_instr_opname(">=", F_GE, TYPE_NUMBER, T_ANY, T_ANY);
    add_instr_opname("==", F_EQ, TYPE_NUMBER, T_ANY, T_ANY);
    add_instr_opname("!=", F_NE, TYPE_NUMBER, T_ANY, T_ANY);
    add_instr_opname("index", F_INDEX, TYPE_ANY, T_ANY, T_ANY);
    add_instr_opname_prefix("!", F_NOT, TYPE_NUMBER, T_ANY);
    add_instr_opname_prefix("~", F_COMPL, TYPE_NUMBER, T_NUMBER);

    add_instr_name("+=", F_ADD_EQ);
    add_instr_name("-=", F_SUB_EQ);
    add_instr_name("/=", F_DIV_EQ);
    add_instr_name("*=", F_MULT_EQ);
    add_instr_name("%=", F_MOD_EQ);
    add_instr_name("&=", F_AND_EQ);
    add_instr_name("|=", F_OR_EQ);
    add_instr_name("^=", F_XOR_EQ);
    add_instr_name("<<=", F_LSH_EQ);
    add_instr_name(">>=", F_RSH_EQ);
    add_instr_name("push_indexed_lvalue", F_PUSH_INDEXED_LVALUE);
    add_instr_name("identifier", F_IDENTIFIER);
    add_instr_name("local", F_LOCAL_NAME);
    add_instr_name("indirect", F_INDIRECT);
    add_instr_name("number", F_NUMBER);
    add_instr_name("push_local_variable_lvalue", F_PUSH_LOCAL_VARIABLE_LVALUE);
    add_instr_name("const1", F_CONST1);
    add_instr_name("subtract", F_SUBTRACT);
    add_instr_name("assign", F_ASSIGN);
    add_instr_name("pop", F_POP_VALUE);
    add_instr_name("const0", F_CONST0);
    add_instr_name("floatc", F_FLOATC);
    add_instr_name("jump_when_zero", F_JUMP_WHEN_ZERO);
    add_instr_name("jump_when_non_zero", F_JUMP_WHEN_NON_ZERO);
    add_instr_name("||", F_LOR);
    add_instr_name("&&", F_LAND);
    add_instr_name("jump", F_JUMP);
    add_instr_name("return", F_RETURN);
    add_instr_name("sscanf", F_SSCANF);
    add_instr_name("string", F_STRING);
    add_instr_name("call_non_virtual", F_CALL_NON_VIRT);
    add_instr_name("call_virtual", F_CALL_VIRT);
    add_instr_name("call_var", F_CALL_VAR);
    add_instr_name("call_simul", F_CALL_SIMUL);
    add_instr_name("papply", F_PAPPLY);
    add_instr_name("build_closure", F_BUILD_CLOSURE);
    add_instr_name("aggregate", F_AGGREGATE);
    add_instr_name("m_aggregate", F_M_AGGREGATE);
    add_instr_name("push_identifier_lvalue", F_PUSH_IDENTIFIER_LVALUE);
    add_instr_name("dup", F_DUP);
    add_instr_name("catch", F_CATCH);
    add_instr_name("neg", F_NEGATE);
    add_instr_name("x++", F_POST_INC);
    add_instr_name("x--", F_POST_DEC);
    add_instr_name("++x", F_INC);
    add_instr_name("--x", F_DEC);
    add_instr_name("switch",F_SWITCH);
    add_instr_name("break",F_BREAK);
    add_instr_name("range",F_RANGE);
    add_instr_name("foreach", F_FOREACH);
    add_instr_name("foreach", F_FOREACH_M);
    add_instr_name("parse_command", F_PARSE_COMMAND);
    instrs[F_RANGE-EFUN_FIRST].type[0] = T_POINTER|T_STRING;
}
#undef T_ANY

char *
get_f_name(int n)
{
    if (instrs[n-EFUN_FIRST].name)
        return instrs[n-EFUN_FIRST].name;
    else
    {
        static char buf[30];
        (void)snprintf(buf, sizeof(buf), "<OTHER %d>", n);
        return buf;
    }
}



INLINE int lookup_predef(char *s)
{
    return lookupword(s, predefs, NELEM(predefs));
}

#define NARGS 25
#define MARKS '@'

#define SKIPWHITE while (isspace(*p)) p++
#define GETALPHA(p, q, m) \
    while (isalunum(*p)) {\
    *q = *p++;\
    if (q < (m))\
        q++;\
    else {\
        lexerror("Name too long");\
        return;\
    }\
    }\
    *q++ = 0

static int
cmygetc(void)
{
    int c;

    for (;;)
    {
        c = mygetc();
        if (c == '/')
        {
            if (gobble('*'))
                skip_comment();
            else
                return c;
        } else
            return c;
    }
}

static void
refill(void)
{
    char *p;
    int c;

    p = yytext;
    do
    {
        c = cmygetc();
        if (p < yytext+MAXLINE-5)
            *p++ = c;
        else
        {
            lexerror("Line too long");
            break;
        }
    } while (c != '\n' && c != EOF);
    p[-1] = ' ';
    *p = 0;
    nexpands=0;
    store_line_number_info(current_incfile, current_line);
    current_line++;
}

static void
handle_define(char *yyt)
{
    char namebuf[NSIZE];
    char args[NARGS][NSIZE];
    char mtext[MLEN];
    char *p, *q;

    p = yyt;
    (void)strcat(p, " ");
    q = namebuf;
    GETALPHA(p, q, namebuf+NSIZE-1);
    if (*p == '(')
    {       /* if "function macro" */
        int arg;
        int inid;
        char *ids = 0;
        p++;            /* skip '(' */
        SKIPWHITE;
        if (*p == ')')
        {
            arg = 0;
        }
        else
        {
            for (arg = 0; arg < NARGS; )
            {
                q = args[arg];
                GETALPHA(p, q, args[arg] + NSIZE - 1);
                arg++;
                SKIPWHITE;
                if (*p == ')')
                    break;
                if (*p++ != ',')
                {
                    lexerror("Missing ',' in #define parameter list");
                    return;
                }
                SKIPWHITE;
            }
            if (arg == NARGS)
            {
                lexerror("Too many macro arguments");
                return;
            }
        }
        p++;            /* skip ')' */
        for (inid = 0, q = mtext; *p; )
        {
            if (isalunum(*p))
            {
                if (!inid)
                {
                    inid++;
                    ids = p;
                }
            }
            else
            {
                if (inid)
                {
                    size_t l, idlen = p - ids;
                    int n;

                    for (n = 0; n < arg; n++)
                    {
                        l = strlen(args[n]);
                        if (l == idlen && strncmp(args[n], ids, l) == 0)
                        {
                            q -= idlen;
                            *q++ = MARKS;
                            *q++ = n+MARKS+1;
                            break;
                        }
                    }
                    inid = 0;
                }
            }
            *q = *p;
            if (*p++ == MARKS)
                *++q = MARKS;
            if (q < mtext + MLEN - 2)
                q++;
            else
            {
                lexerror("Macro text too long");
                return;
            }
            if (!*p && strlen(yytext) >= 2 && p[-2] == '\\')
            {
                q -= 2;
                refill();
                p = yytext;
            }
        }

        *--q = 0;
        add_define(namebuf, arg, mtext);
    }
    else
    {
        for (q = mtext; *p; )
        {
            *q = *p++;
            if (q < mtext + MLEN - 2)
                q++;
            else
            {
                lexerror("Macro text too long");
                return;
            }
            if (!*p && strlen(yytext) >= 2 && p[-2] == '\\')
            {
                q -= 2;
                refill();
                p = yytext;
            }
        }

        *--q = 0;
        add_define(namebuf, -1, mtext);
    }
    return;
}

static void
myungetc(int c)
{
    *--outp = c;
    nbuf++;
}

static void
add_input(char *p)
{
    size_t l = strlen(p);

    if (nbuf+l >= DEFMAX-10)
    {
        lexerror("Macro expansion buffer overflow");
        return;
    }
    outp -= l;
    nbuf += l;
    memcpy(outp, p, l);
}

#define DEFHASH 1999
struct defn *defns[DEFHASH];
#define defhash(s) (hash_string(s) % DEFHASH)

void
add_pre_define(char *define)
{
    struct lpc_predef_s *tmp;

    tmp = (struct lpc_predef_s *)xalloc(sizeof(struct lpc_predef_s));

    tmp->flag = string_copy(define);
    tmp->next = lpc_predefs;
    lpc_predefs = tmp;
}

static void
add_define(char *name, int nargs, char *exps)
{
    struct defn *p;
    unsigned int h;

    if ((p = lookup_define(name)) != NULL)
    {
        if (nargs != p->nargs || strcmp(exps, p->exps) != 0)
        {
            lexerror("Redefinition of #define %s", name);
        }
        return;
    }
    p = (struct defn *)xalloc(sizeof(struct defn));
    p->name = xalloc(strlen(name)+1);
    (void)strcpy(p->name, name);
    p->undef = 0;
    p->nargs = nargs;
    p->exps = xalloc(strlen(exps)+1);
    (void)strcpy(p->exps, exps);
    h = defhash(name);
    p->next = defns[h];
    defns[h] = p;
    /*(void)fprintf(stderr, "define '%s' %d '%s'\n", name, nargs, exps);*/
}

static void
free_defines(void)
{
    struct defn *p, *q;
    int i;

    for (i = 0; i < DEFHASH; i++)
    {
        for (p = defns[i]; p; p = q)
        {
            q = p->next;
            free(p->name);
            free(p->exps);
            free((char *)p);
        }
        defns[i] = 0;
    }
    nexpands = 0;
}

struct defn *
lookup_define(char *s)
{
    struct defn *p;
    int h;

    h = defhash(s);
    for (p = defns[h]; p; p = p->next)
        if (!p->undef && strcmp(s, p->name) == 0)
            return p;
    return 0;
}

#define SKIPW \
        do {\
        c = cmygetc();\
    } while (isspace(c));


/* Check if yytext is a macro and expand if it is. */
static int
expand_define(void)
{
    struct defn *p;
    char expbuf[DEFMAX];
    char *args[NARGS];
    char buf[DEFMAX];
    char *q, *e, *b;

    if (nexpands++ > EXPANDMAX)
    {
        lexerror("Too many macro expansions");
        return 0;
    }
    p = lookup_define(yytext);
    if (!p)
    {
        return 0;
    }
    if (p->nargs == -1)
    {
        add_input(p->exps);
    }
    else
    {
        int c, parcnt = 0, dquote = 0, squote = 0;
        int n;
        SKIPW;
        if (c != '(')
        {
            lexerror("Missing '(' in macro call");
            return 0;
        }
        SKIPW;
        if (c == ')')
            n = 0;
        else
        {
            q = expbuf;
            args[0] = q;
            for (n = 0; n < NARGS; )
            {
                switch(c)
                {
                case '"':
                    if (!squote)
                        dquote ^= 1;
                    break;
                case '\'':
                    if (!dquote)
                        squote ^= 1;
                    break;
                case '(':
                    if (!squote && !dquote)
                        parcnt++;
                    break;
                case ')':
                    if (!squote && !dquote)
                        parcnt--;
                    break;
                case '\\':
                    if (squote || dquote)
                    {
                        *q++ = c;
                        c = mygetc();}
                    break;
                case '\n':
                    if (squote || dquote)
                    {
                        lexerror("Newline in string");
                        return 0;
                    }
                    break;
                }
                if (c == ',' && !parcnt && !dquote && !squote)
                {
                    *q++ = 0;
                    args[++n] = q;
                }
                else if (parcnt < 0)
                {
                    *q++ = 0;
                    n++;
                    break;
                }
                else
                {
                    if (c == EOF)
                    {
                        lexerror("Unexpected end of file");
                        return 0;
                    }
                    if (q >= expbuf + DEFMAX - 5)
                    {
                        lexerror("Macro argument overflow");
                        return 0;
                    }
                    else
                    {
                        *q++ = c;
                    }
                }
                if (!squote && ! dquote)
                    c = cmygetc();
                else
                    c = mygetc();
            }
            if (n == NARGS)
            {
                lexerror("Maximum macro argument count exceeded");
                return 0;
            }
        }
        if (n != p->nargs)
        {
            lexerror("Wrong number of macro arguments");
            return 0;
        }
        /* Do expansion */
        b = buf;
        e = p->exps;
        while (*e)
        {
            if (*e == MARKS)
            {
                if (*++e == MARKS)
                    *b++ = *e++;
                else
                {
                    for (q = args[*e++ - MARKS - 1]; *q; )
                    {
                        *b++ = *q++;
                        if (b >= buf+DEFMAX)
                        {
                            lexerror("Macro expansion overflow");
                            return 0;
                        }
                    }
                }
            }
            else
            {
                *b++ = *e++;
                if (b >= buf+DEFMAX)
                {
                    lexerror("Macro expansion overflow");
                    return 0;
                }
            }
        }
        *b++ = 0;
        add_input(buf);
    }
    return 1;
}

/* Stuff to evaluate expression.  I havn't really checked it. /LA
** Written by "J\"orn Rennecke" <amylaar@cs.tu-berlin.de>
*/
static int
exgetc(void)
{
    register char c, *yyp;

    c = mygetc();
    while (isalpha(c) || c == '_')
    {
        yyp = yytext;
        do
        {
            SAVEC;
            c = mygetc();
        } while (isalunum(c));
        myungetc(c);
        *yyp = '\0';
        if (strcmp(yytext, "defined") == 0)
        {
            /* handle the defined "function" in #if */
            do
                c = mygetc();
            while (isspace(c));

            if (c != '(')
            {
                lexerror("Missing ( in defined");
                continue;
            }
            do
                c = mygetc();
            while (isspace(c));

            yyp = yytext;
            while (isalunum(c))
            {
                SAVEC;
                c = mygetc();
            }
            *yyp = '\0';
            while (isspace(c))
                c = mygetc();
            if (c != ')')
            {
                lexerror("Missing ) in defined");
                continue;
            }

            /* Skip whitespace */
            do
                c = mygetc();
            while (isspace(c));
            myungetc(c);

            if (lookup_define(yytext))
                add_input(" 1 ");
            else
                add_input(" 0 ");
        }
        else
        {
            if (!expand_define()) add_input(" 0 ");
        }
        c = mygetc();
    }
    return c;
}

#define BNOT   1
#define LNOT   2
#define UMINUS 3
#define UPLUS  4

#define MULT   1
#define DIV    2
#define MOD    3
#define BPLUS  4
#define BMINUS 5
#define LSHIFT 6
#define RSHIFT 7
#define LESS   8
#define LEQ    9
#define GREAT 10
#define GEQ   11
#define EQ    12
#define NEQ   13
#define BAND  14
#define XOR   15
#define BOR   16
#define LAND  17
#define LOR   18
#define QMARK 19

static char _optab[]=
{0,4,0,0,0,26,56,0,0,0,18,14,0,10,0,22,0,0,0,0,0,0,0,0,0,0,0,0,30,50,40,74,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,70,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,1};
static char optab2[]=
{BNOT,0,0,LNOT,'=',NEQ,7,0,0,UMINUS,0,BMINUS,10,UPLUS,0,BPLUS,10,
0,0,MULT,11,0,0,DIV,11,0,0,MOD,11,
0,'<',LSHIFT,9,'=',LEQ,8,0,LESS,8,0,'>',RSHIFT,9,'=',GEQ,8,0,GREAT,8,
0,'=',EQ,7,0,0,0,'&',LAND,3,0,BAND,6,0,'|',LOR,2,0,BOR,4,
0,0,XOR,5,0,0,QMARK,1};

static int
cond_get_exp(int priority)
{
    int c;
    int value, value2, x;

    do
        c = exgetc();
    while (isspace(c));

    if (c == '(')
    {
        value = cond_get_exp(0);
        do
            c = exgetc();
        while (isspace(c));
        if (c != ')')
        {
            lexerror("bracket not paired in #if");
            if (!c)
                myungetc('\0');
        }
    }
    else if (ispunct(c))
    {
        x = (_optab-' ')[c];
        if (!x)
        {
            lexerror("illegal character in #if");
            return 0;
        }
        value = cond_get_exp(12);
        switch ( optab2[x-1] )
        {
        case BNOT  : value = ~value; break;
        case LNOT  : value = !value; break;
        case UMINUS: value = -value; break;
        case UPLUS : /* value =  value; */ break;
        default :
            lexerror("illegal unary operator in #if");
            return 0;
        }
    }
    else
    {
        int base;

        if (!isdigit(c))
        {
            if (!c)
            {
                lexerror("missing expression in #if");
                myungetc('\0');
            }
            else
                lexerror("illegal character in #if");
            return 0;
        }
        value = 0;
        if (c!='0')
            base = 10;
        else
        {
            c = mygetc();
            if ( c == 'x' || c == 'X' )
            {
                base = 16;
                c = mygetc();
            }
            else
                base=8;
        }
        for (;;)
        {
            if ( isdigit(c) )
                x = -'0';
            else if (isupper(c))
                x = -'A' + 10;
            else if (islower(c))
                x = -'a' + 10;
            else
                break;
            x += c;
            if (x > base)
                break;
            value = value*base + x;
            c = mygetc();
        }
        myungetc(c);
    }
    for (;;)
    {
        do
            c = exgetc();
        while (isspace(c));

        if (!ispunct(c))
            break;
        x = (_optab-' ')[c];
        if (!x)
            break;
        value2 = mygetc();
        for (;;x += 3)
        {
            if (!optab2[x])
            {
                myungetc(value2);
                if (!optab2[x + 1])
                {
                    lexerror("illegal operator use in #if");
                    return 0;
                }
                break;
            }
            if (value2 == optab2[x])
                break;
        }
        if (priority >= optab2[x + 2])
        {
            if (optab2[x])
                myungetc(value2);
            break;
        }
        value2 = cond_get_exp(optab2[x + 2]);
        switch ( optab2[x + 1] )
        {
        case MULT   : value *=  value2;                    break;
        case BPLUS  : value +=  value2;                    break;
        case BMINUS : value -=  value2;                    break;
        case LSHIFT : value <<= value2;                    break;
        case RSHIFT : value =   (unsigned)value >> value2; break;
        case LESS   : value =   value <  value2;           break;
        case LEQ    : value =   value <= value2;           break;
        case GREAT  : value =   value >  value2;           break;
        case GEQ    : value =   value >= value2;           break;
        case EQ     : value =   value == value2;           break;
        case NEQ    : value =   value != value2;           break;
        case BAND   : value &=  value2;                    break;
        case XOR    : value ^=  value2;                    break;
        case BOR    : value |=  value2;                    break;
        case LAND   : value =  value && value2;            break;
        case LOR    : value =  value || value2;            break;
        case MOD:
            if (!value2) {
                lexerror("Modulo by zero in #if");
                return 0;
            }
            value %= value2;
            break;
        case DIV:
            if (!value2) {
                lexerror("Division by zero in #if");
                return 0;
            }
            value /= value2;
            break;
        case QMARK  :
            do
                c = exgetc();
            while (isspace(c));
            if (c != ':')
            {
                lexerror("'?' without ':' in #if");
                myungetc(c);
                return 0;
            }
            if (value)
            {
                (void)cond_get_exp(1);
                value = value2;
            }
            else
                value = cond_get_exp(1);
            break;
        }
    }
    myungetc(c);
    return value;
}

/* Free the global list of include directories.
 */
void
free_inc_list(void)
{
    int i;

    for (i = 0; i < inc_list_size; i++)
        free(inc_list[i]);
    if (inc_list)
        free(inc_list);

}

/* Set the global list of include directories.
   Affects globals inc_list and inc_list_size */
void
set_inc_list(struct svalue *sv)
{
    int i;
    struct vector *v;
    char *p, *end;
    char **tmp_inc_list;

    free_inc_list();
    if (sv == 0)
    {
        inc_list_size = 0;
        inc_list = NULL;
        return;
    }
    if (sv->type != T_POINTER)
    {
        (void)fprintf(stderr, "'define_include_dirs' in master.c did not return an array.\n");
        exit(1);
        inc_list_size = 0;
        inc_list = NULL;
        return;
    }
    v = sv->u.vec;
    if (v->size == 0) {
        (void)fprintf(stderr, "'define_include_dirs' returned an empty array\n");
        inc_list_size = 0;
        inc_list = NULL;
        return;
    }

    tmp_inc_list = (char **) xalloc(v->size * sizeof (char *));
    inc_list_size = 0;
    for (i = 0; i < v->size; i++)
    {
        if (v->item[i].type != T_STRING)
        {
            (void)fprintf(stderr, "Illegal value returned from 'define_include_dirs' in master.c\n");
            continue;
        }
        p = v->item[i].u.string;
        if (*p == '/')
            p++;
        /*
         * Even make sure that the game administrator has not made an error.
         */
        if (!legal_path(p))
        {
            (void)fprintf(stderr, "'define_include_dirs' must give paths without any '..'\n");
            continue;
        }
        if ((end = strstr(p, "%s"))) {
            if (end != p + strlen(p) - 2) {
                (void)fprintf(stderr, "'define_include_dirs' may only contain %%s last.");
                continue;
            }
        }
        else
            end = p + strlen(p);
        if (end != p && end[-1] != '/') {
            tmp_inc_list[inc_list_size] = xalloc(end - p + 2);
            strncpy(tmp_inc_list[inc_list_size], p, end - p);
            tmp_inc_list[inc_list_size][end - p] = '/';
            tmp_inc_list[inc_list_size][end - p + 1] = '\0';
        } else {
            tmp_inc_list[inc_list_size] = xalloc(end - p + 1);
            strncpy(tmp_inc_list[inc_list_size], p, end - p);
            tmp_inc_list[inc_list_size][end - p] = '\0';
        }
        inc_list_size++;
    }
    if (inc_list_size == 0) {
        inc_list = NULL;
        free(tmp_inc_list);
    } else if (inc_list_size != v->size) {
        inc_list = (char **) xalloc(inc_list_size * sizeof (char *));
        for (i = 0; i < inc_list_size; i++)
            inc_list[i] = tmp_inc_list[i];
        free(tmp_inc_list);
    } else
        inc_list = tmp_inc_list;
}