source: trunk/minix/commands/i386/asmconv/tokenize.c@ 9

/*      tokenize.c - split input into tokens            Author: Kees J. Bot
 *                                                              13 Dec 1993
 */
#define nil 0
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include "asmconv.h"
#include "token.h"

static FILE *tf;
static char *tfile;
static char *orig_tfile;
static int tcomment;
static int tc;
static long tline;
static token_t *tq;

static void readtc(void)
/* Read one character from the input file and put it in the global 'tc'. */
{
        static int nl= 0;

        if (nl) tline++;
        if ((tc= getc(tf)) == EOF && ferror(tf)) fatal(orig_tfile);
        nl= (tc == '\n');
}

void set_file(char *file, long line)
/* Set file name and line number, changed by a preprocessor trick. */
{
        deallocate(tfile);
        tfile= allocate(nil, (strlen(file) + 1) * sizeof(tfile[0]));
        strcpy(tfile, file);
        tline= line;
}

void get_file(char **file, long *line)
/* Get file name and line number. */
{
        *file= tfile;
        *line= tline;
}

void parse_err(int err, token_t *t, const char *fmt, ...)
/* Report a parsing error. */
{
        va_list ap;

        fprintf(stderr, "\"%s\", line %ld: ", tfile,
                                                t == nil ? tline : t->line);
        va_start(ap, fmt);
        vfprintf(stderr, fmt, ap);
        va_end(ap);
        if (err) set_error();
}

void tok_init(char *file, int comment)
/* Open the file to tokenize and initialize the tokenizer. */
{
        if (file == nil) {
                file= "stdin";
                tf= stdin;
        } else {
                if ((tf= fopen(file, "r")) == nil) fatal(file);
        }
        orig_tfile= file;
        set_file(file, 1);
        readtc();
        tcomment= comment;
}

static int isspace(int c)
{
        return between('\0', c, ' ') && c != '\n';
}

#define iscomment(c)    ((c) == tcomment)

static int isidentchar(int c)
{
        return between('a', c, 'z')
                || between('A', c, 'Z')
                || between('0', c, '9')
                || c == '.'
                || c == '_'
                ;
}

static token_t *new_token(void)
{
        token_t *new;

        new= allocate(nil, sizeof(*new));
        new->next= nil;
        new->line= tline;
        new->name= nil;
        new->symbol= -1;
        return new;
}

static token_t *get_word(void)
/* Read one word, an identifier, a number, a label, or a mnemonic. */
{
        token_t *w;
        char *name;
        size_t i, len;

        i= 0;
        len= 16;
        name= allocate(nil, len * sizeof(name[0]));

        while (isidentchar(tc)) {
                name[i++]= tc;
                readtc();
                if (i == len) name= allocate(name, (len*= 2) * sizeof(name[0]));
        }
        name[i]= 0;
        name= allocate(name, (i+1) * sizeof(name[0]));
        w= new_token();
        w->type= T_WORD;
        w->name= name;
        w->len= i;
        return w;
}

static token_t *get_string(void)
/* Read a single or double quotes delimited string. */
{
        token_t *s;
        int quote;
        char *str;
        size_t i, len;
        int n, j;
        int seen;

        quote= tc;
        readtc();

        i= 0;
        len= 16;
        str= allocate(nil, len * sizeof(str[0]));

        while (tc != quote && tc != '\n' && tc != EOF) {
                seen= -1;
                if (tc == '\\') {
                        readtc();
                        if (tc == '\n' || tc == EOF) break;

                        switch (tc) {
                        case 'a':       tc= '\a'; break;
                        case 'b':       tc= '\b'; break;
                        case 'f':       tc= '\f'; break;
                        case 'n':       tc= '\n'; break;
                        case 'r':       tc= '\r'; break;
                        case 't':       tc= '\t'; break;
                        case 'v':       tc= '\v'; break;
                        case 'x':
                                n= 0;
                                for (j= 0; j < 3; j++) {
                                        readtc();
                                        if (between('0', tc, '9'))
                                                tc-= '0' + 0x0;
                                        else
                                        if (between('A', tc, 'A'))
                                                tc-= 'A' + 0xA;
                                        else
                                        if (between('a', tc, 'a'))
                                                tc-= 'a' + 0xa;
                                        else {
                                                seen= tc;
                                                break;
                                        }
                                        n= n*0x10 + tc;
                                }
                                tc= n;
                                break;
                        default:
                                if (!between('0', tc, '9')) break;
                                n= 0;
                                for (j= 0; j < 3; j++) {
                                        if (between('0', tc, '9'))
                                                tc-= '0';
                                        else {
                                                seen= tc;
                                                break;
                                        }
                                        n= n*010 + tc;
                                        readtc();
                                }
                                tc= n;
                        }
                }
                str[i++]= tc;
                if (i == len) str= allocate(str, (len*= 2) * sizeof(str[0]));

                if (seen < 0) readtc(); else tc= seen;
        }

        if (tc == quote) {
                readtc();
        } else {
                parse_err(1, nil, "string contains newline\n");
        }
        str[i]= 0;
        str= allocate(str, (i+1) * sizeof(str[0]));
        s= new_token();
        s->type= T_STRING;
        s->name= str;
        s->len= i;
        return s;
}

static int old_n= 0;            /* To speed up n, n+1, n+2, ... accesses. */
static token_t **old_ptq= &tq;

token_t *get_token(int n)
/* Return the n-th token on the input queue. */
{
        token_t *t, **ptq;

        assert(n >= 0);

        if (0 && n >= old_n) {
                /* Go forward from the previous point. */
                n-= old_n;
                old_n+= n;
                ptq= old_ptq;
        } else {
                /* Restart from the head of the queue. */
                old_n= n;
                ptq= &tq;
        }

        for (;;) {
                if ((t= *ptq) == nil) {
                        /* Token queue doesn't have element <n>, read a
                         * new token from the input stream.
                         */
                        while (isspace(tc) || iscomment(tc)) {
                                if (iscomment(tc)) {
                                        while (tc != '\n' && tc != EOF)
                                                readtc();
                                } else {
                                        readtc();
                                }
                        }

                        if (tc == EOF) {
                                t= new_token();
                                t->type= T_EOF;
                        } else
                        if (isidentchar(tc)) {
                                t= get_word();
                        } else
                        if (tc == '\'' || tc == '"') {
                                t= get_string();
                        } else {
                                if (tc == '\n') tc= ';';
                                t= new_token();
                                t->type= T_CHAR;
                                t->symbol= tc;
                                readtc();
                                if (t->symbol == '<' && tc == '<') {
                                        t->symbol= S_LEFTSHIFT;
                                        readtc();
                                } else
                                if (t->symbol == '>' && tc == '>') {
                                        t->symbol= S_RIGHTSHIFT;
                                        readtc();
                                }
                        }
                        *ptq= t;
                }
                if (n == 0) break;
                n--;
                ptq= &t->next;
        }
        old_ptq= ptq;
        return t;
}

void skip_token(int n)
/* Remove n tokens from the input queue.  One is not allowed to skip unread
 * tokens.
 */
{
        token_t *junk;

        assert(n >= 0);

        while (n > 0) {
                assert(tq != nil);

                junk= tq;
                tq= tq->next;
                deallocate(junk->name);
                deallocate(junk);
                n--;
        }
        /* Reset the old reference. */
        old_n= 0;
        old_ptq= &tq;
}