tools/ndrgen/ndr_lex.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <errno.h>
#include <stdarg.h>
#include "ndrgen.h"
#include "y.tab.h"

/*
 * C-like lexical analysis.
 *
 * 1. Define a "struct node"
 * 2. Define a "struct symbol" that encapsulates a struct node.
 * 3. Define a "struct integer" that encapsulates a struct node.
 * 4. Set the YACC stack type in the grammar:
 *      %{
 *      #define YYSTYPE struct node *
 *      %}
 * 5. Define %token's in the grammer for IDENTIFIER, STRING and INTEGER.
 *    Using "_KW" as a suffix for keyword tokens, i.e. "struct" is
 *    "%token STRUCT_KW":
 *  // atomic values
 *  %token INTEGER STRING IDENTIFIER
 *  // keywords
 *  %token STRUCT_KW CASE_KW
 *  // operators
 *  %token PLUS MINUS ASSIGN ARROW
 *  // overloaded tokens (++ --, < > <= >=, == !=, += -= *= ...)
 *  %token INCOP RELOP EQUOP ASSOP
 * 6. It's easiest to use the yacc(1) generated token numbers for node
 *    labels.  For node labels that are not actually part of the grammer,
 *    use a %token with an L_ prefix:
 *  // node labels (can't be generated by lex)
 *  %token L_LT L_LTE L_GT L_GTE L_EQU L_NEQ
 * 7. Call set_lex_input() before parsing.
 */

#define SQ  '\''
#define DQ  '"'

#define isquote(c) ((c) == SQ || (c) == DQ)
#define iswhite(c) ((c) == ' ' || (c) == '\t' || (c) == '\n' || (c) == '\f')

#define is_between(c, l, u)  ((l) <= (c) && (c) <= (u))
#define is_white(c) ((c) == ' ' || c == '\r' || c == '\t' || c == '\f')
#define is_lower(c) is_between((c), 'a', 'z')
#define is_upper(c) is_between((c), 'A', 'Z')
#define is_alpha(c) (is_lower(c) || is_upper(c))
#define is_digit(c) is_between((c), '0', '9')
#define is_sstart(c)    (is_alpha(c) || (c) == '_')
#define is_sfollow(c)   (is_sstart(c) || is_digit(c))
#define is_xdigit(c)    \
    (is_digit(c) || is_between((c), 'A', 'F') || is_between((c), 'a', 'f'))

ndr_symbol_t        *symbol_list;
static ndr_integer_t    *integer_list;
static FILE     *lex_infp;
static ndr_symbol_t *file_name;
int         line_number;
int         n_compile_error;

static int      lex_at_bol;

/* In yacc(1) generated parser */
extern struct node  *yylval;

/*
 * The keywtab[] and optable[] could be external to this lex
 * and it would all still work.
 */
static ndr_keyword_t keywtable[] = {
    { "struct", STRUCT_KW,  0 },
    { "union",  UNION_KW,   0 },
    { "typedef",    TYPEDEF_KW, 0 },

    { "interface",  INTERFACE_KW,   0 },
    { "uuid",   UUID_KW,    0 },
    { "_no_reorder", _NO_REORDER_KW, 0 },
    { "extern", EXTERN_KW,  0 },
    { "reference",  REFERENCE_KW,   0 },

    { "align",  ALIGN_KW,   0 },
    { "operation",  OPERATION_KW,   0 },
    { "in",     IN_KW,      0 },
    { "out",    OUT_KW,     0 },

    { "string", STRING_KW,  0 },
    { "size_is",    SIZE_IS_KW, 0 },
    { "length_is",  LENGTH_IS_KW,   0 },

    { "switch_is",  SWITCH_IS_KW,   0 },
    { "case",   CASE_KW,    0 },
    { "default",    DEFAULT_KW, 0 },

    { "transmit_as", TRANSMIT_AS_KW, 0 },
    { "arg_is", ARG_IS_KW,  0 },

    { "char",   BASIC_TYPE, 1 },
    { "uchar",  BASIC_TYPE, 1 },
    { "wchar",  BASIC_TYPE, 2 },
    { "short",  BASIC_TYPE, 2 },
    { "ushort", BASIC_TYPE, 2 },
    { "long",   BASIC_TYPE, 4 },
    { "ulong",  BASIC_TYPE, 4 },
    {0}
};

static ndr_keyword_t optable[] = {
    { "{",      LC,     0 },
    { "}",      RC,     0 },
    { "(",      LP,     0 },
    { ")",      RP,     0 },
    { "[",      LB,     0 },
    { "]",      RB,     0 },
    { "*",      STAR,       0 },
    { "/",      DIV,        0 },
    { "%",      MOD,        0 },
    { "-",      MINUS,      0 },
    { "+",      PLUS,       0 },
    { "&",      AND,        0 },
    { "|",      OR,     0 },
    { "^",      XOR,        0 },
    { ";",      SEMI,       0 },
    {0}
};

static int getch(FILE *fp);
static ndr_integer_t *int_enter(long);
static ndr_symbol_t *sym_enter(char *);
static ndr_symbol_t *sym_find(char *);
static int str_to_sv(char *, char *sv[]);

/*
 * Enter the symbols for keyword.
 */
static void
keyw_tab_init(ndr_keyword_t kwtable[])
{
    int         i;
    ndr_keyword_t       *kw;
    ndr_symbol_t        *sym;

    for (i = 0; kwtable[i].name; i++) {
        kw = &kwtable[i];

        sym = sym_enter(kw->name);
        sym->kw = kw;
    }
}

void
set_lex_input(FILE *fp, char *name)
{
    keyw_tab_init(keywtable);
    keyw_tab_init(optable);

    lex_infp = fp;
    file_name = sym_enter(name);
    line_number = 1;
    lex_at_bol = 1;
}

static int
getch(FILE *fp)
{
    return (getc(fp));
}

int
yylex(void)
{
    char        lexeme[512];
    char        *p = lexeme;
    FILE        *fp = lex_infp;
    int     c, xc;
    ndr_symbol_t    *sym;
    ndr_integer_t   *intg;

top:
    p = lexeme;

    c = getch(fp);
    if (c == EOF)
        return (EOF);

    if (c == '\n') {
        line_number++;
        lex_at_bol = 1;
        goto top;
    }

    /*
     * Handle preprocessor lines. This just notes
     * which file we're processing.
     */
    if (c == '#' && lex_at_bol) {
        char        *sv[10];
        int     sc;

        while ((c = getch(fp)) != EOF && c != '\n')
            *p++ = c;

        *p = 0;
        /* note: no ungetc() of newline, we don't want to count it */

        if (*lexeme != ' ') {
            /* not a line we know */
            goto top;
        }

        sc = str_to_sv(lexeme, sv);
        if (sc < 2)
            goto top;

        file_name = sym_enter(sv[1]);
        line_number = atoi(sv[0]);  /* for next input line */
        lex_at_bol = 1;
        goto top;
    }

    lex_at_bol = 0;

    /*
     * Skip white space
     */
    if (is_white(c))
        goto top;

    /*
     * Symbol? Might be a keyword or just an identifier
     */
    if (is_sstart(c)) {
        /* we got a symbol */
        do {
            *p++ = c;
            c = getch(fp);
        } while (is_sfollow(c));
        (void) ungetc(c, fp);
        *p = 0;

        sym = sym_enter(lexeme);

        yylval = &sym->s_node;

        if (sym->kw) {
            return (sym->kw->token);
        } else {
            return (IDENTIFIER);
        }
    }

    /*
     * Integer constant?
     */
    if (is_digit(c)) {
        /* we got a number */
        *p++ = c;
        if (c == '0') {
            c = getch(fp);
            if (c == 'x' || c == 'X') {
                /* handle hex specially */
                do {
                    *p++ = c;
                    c = getch(fp);
                } while (is_xdigit(c));
                goto convert_icon;
            } else if (c == 'b' || c == 'B' ||
                c == 'd' || c == 'D' ||
                c == 'o' || c == 'O') {
                do {
                    *p++ = c;
                    c = getch(fp);
                } while (is_digit(c));
                goto convert_icon;
            }
            (void) ungetc(c, fp);
        }
        /* could be anything */
        c = getch(fp);
        while (is_digit(c)) {
            *p++ = c;
            c = getch(fp);
        }

convert_icon:
        *p = 0;
        (void) ungetc(c, fp);

        intg = int_enter(strtol(lexeme, 0, 0));
        yylval = &intg->s_node;

        return (INTEGER);
    }

    /* Could handle strings. We don't seem to need them yet */

    yylval = 0;     /* operator tokens have no value */
    xc = getch(fp);     /* get look-ahead for two-char lexemes */

    lexeme[0] = c;
    lexeme[1] = xc;
    lexeme[2] = 0;

    /*
     * Look for to-end-of-line comment
     */
    if (c == '/' && xc == '/') {
        /* eat the comment */
        while ((c = getch(fp)) != EOF && c != '\n')
            ;
        (void) ungetc(c, fp);       /* put back newline */
        goto top;
    }

    /*
     * Look for multi-line comment
     */
    if (c == '/' && xc == '*') {
        /* eat the comment */
        xc = -1;
        while ((c = getch(fp)) != EOF) {
            if (xc == '*' && c == '/') {
                /* that's it */
                break;
            }
            xc = c;
            if (c == '\n')
                line_number++;
        }
        goto top;
    }

    /*
     * Use symbol table lookup for two-character and
     * one character operator tokens.
     */
    sym = sym_find(lexeme);
    if (sym) {
        /* there better be a keyword attached */
        yylval = &sym->s_node;
        return (sym->kw->token);
    }

    /* Try a one-character form */
    (void) ungetc(xc, fp);
    lexeme[1] = 0;
    sym = sym_find(lexeme);
    if (sym) {
        /* there better be a keyword attached */
        yylval = &sym->s_node;
        return (sym->kw->token);
    }

    if (is_between(c, ' ', '~'))
        compile_error("unrecognized character: 0x%02x (%c)", c, c);
    else
        compile_error("unrecognized character: 0x%02x", c);
    goto top;
}

static ndr_symbol_t *
sym_find(char *name)
{
    ndr_symbol_t        **pp;
    ndr_symbol_t        *p;

    for (pp = &symbol_list; (p = *pp) != 0; pp = &p->next) {
        if (strcmp(p->name, name) == 0)
            return (p);
    }

    return (0);
}

static ndr_symbol_t *
sym_enter(char *name)
{
    ndr_symbol_t        **pp;
    ndr_symbol_t        *p;

    for (pp = &symbol_list; (p = *pp) != 0; pp = &p->next) {
        if (strcmp(p->name, name) == 0)
            return (p);
    }

    p = ndr_alloc(1, sizeof (ndr_symbol_t));

    if ((p->name = strdup(name)) == NULL)
        fatal_error("%s", strerror(ENOMEM));

    p->s_node.label = IDENTIFIER;
    p->s_node.n_sym = p;

    *pp = p;

    return (p);
}

static ndr_integer_t *
int_enter(long value)
{
    ndr_integer_t       **pp;
    ndr_integer_t       *p;

    for (pp = &integer_list; (p = *pp) != 0; pp = &p->next) {
        if (p->value == value)
            return (p);
    }

    p = ndr_alloc(1, sizeof (ndr_integer_t));

    p->value = value;
    p->s_node.label = INTEGER;
    p->s_node.n_int = value;

    *pp = p;

    return (p);
}

void *
ndr_alloc(size_t nelem, size_t elsize)
{
    void *p;

    if ((p = calloc(nelem, elsize)) == NULL) {
        fatal_error("%s", strerror(ENOMEM));
        /* NOTREACHED */
    }

    return (p);
}

/*
 * The input context (filename, line number) is maintained by the
 * lexical analysis, and we generally want such info reported for
 * errors in a consistent manner.
 */
void
compile_error(const char *fmt, ...)
{
    char    buf[NDLBUFSZ];
    va_list ap;

    va_start(ap, fmt);
    (void) vsnprintf(buf, NDLBUFSZ, fmt, ap);
    va_end(ap);

    (void) fprintf(stderr, "ndrgen: compile error: %s:%d: %s\n",
        file_name->name, line_number, buf);

    n_compile_error++;
}

void
fatal_error(const char *fmt, ...)
{
    char    buf[NDLBUFSZ];
    va_list ap;

    va_start(ap, fmt);
    (void) vsnprintf(buf, NDLBUFSZ, fmt, ap);
    va_end(ap);

    (void) fprintf(stderr, "ndrgen: fatal error: %s\n", buf);
    exit(1);
}

/*
 * Setup nodes for the lexical analyzer.
 */
struct node *
n_cons(int label, ...)
{
    ndr_node_t      *np;
    va_list ap;

    np = ndr_alloc(1, sizeof (ndr_node_t));

    va_start(ap, label);
    np->label = label;
    np->n_arg[0] = va_arg(ap, void *);
    np->n_arg[1] = va_arg(ap, void *);
    np->n_arg[2] = va_arg(ap, void *);
    va_end(ap);

    np->line_number = line_number;
    np->file_name = file_name;

    return (np);
}

/*
 *  list:   item
 *  |   list item   ={ n_splice($1, $2); }
 *  ;
 */
void
n_splice(struct node *np1, struct node *np2)
{
    while (np1->n_next)
        np1 = np1->n_next;

    np1->n_next = np2;
}

/*
 * Convert a string of words to a vector of strings.
 * Returns the number of words.
 */
static int
str_to_sv(char *buf, char *sv[])
{
    char        **pp = sv;
    char        *p = buf;
    char        *q = buf;
    int     in_word = 0;
    int     c;

    for (;;) {
        c = *p++;
        if (c == 0)
            break;

        if (!in_word) {
            if (iswhite(c))
                continue;

            *pp++ = q;
            in_word = 1;
        }

        if (isquote(c)) {
            int     qc = c;

            while (((c = *p++) != 0) && (c != qc))
                *q++ = c;
            if (c == 0)
                break;
        } else if (iswhite(c)) {
            /* end of word */
            *q++ = 0;
            in_word = 0;
        } else {
            /* still inside word */
            *q++ = c;
        }
    }

    if (in_word)
        *q++ = 0;

    *pp = (char *)0;
    return (pp - sv);
}