/*
 * GAS-compatible parser
 *
 *  Copyright (C) 2005-2007  Peter Johnson
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the author nor the names of other contributors
 *    may be used to endorse or promote products derived from this
 *    software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND OTHER CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR OTHER CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
#include <util.h>
RCSID("$Id: gas-parse.c,v 1.1.1.1 2012/03/29 17:20:59 uid42307 Exp $");

#include <libyasm.h>

#include <limits.h>
#include <math.h>

#include "modules/parsers/gas/gas-parser.h"

typedef struct dir_lookup {
    const char *name;
    yasm_bytecode * (*handler) (yasm_parser_gas *, unsigned int);
    unsigned int param;
    enum gas_parser_state newstate;
} dir_lookup;

static yasm_bytecode * cpp_line_marker(yasm_parser_gas *parser_gas);
static yasm_bytecode *parse_instr(yasm_parser_gas *parser_gas);
static int parse_dirvals(yasm_parser_gas *parser_gas, yasm_valparamhead *vps);
static int parse_datavals(yasm_parser_gas *parser_gas, yasm_datavalhead *dvs);
static int parse_strvals(yasm_parser_gas *parser_gas, yasm_datavalhead *dvs);
static yasm_effaddr *parse_memaddr(yasm_parser_gas *parser_gas);
static yasm_insn_operand *parse_operand(yasm_parser_gas *parser_gas);
static yasm_expr *parse_expr(yasm_parser_gas *parser_gas);
static yasm_expr *parse_expr0(yasm_parser_gas *parser_gas);
static yasm_expr *parse_expr1(yasm_parser_gas *parser_gas);
static yasm_expr *parse_expr2(yasm_parser_gas *parser_gas);

static void define_label(yasm_parser_gas *parser_gas, char *name, int local);
static void define_lcomm(yasm_parser_gas *parser_gas, /*@only@*/ char *name,
                         yasm_expr *size, /*@null@*/ yasm_expr *align);
static yasm_section *gas_get_section
    (yasm_parser_gas *parser_gas, /*@only@*/ char *name, /*@null@*/ char *flags,
     /*@null@*/ char *type, /*@null@*/ yasm_valparamhead *objext_valparams,
     int builtin);
static void gas_switch_section
    (yasm_parser_gas *parser_gas, /*@only@*/ const char *name,
     /*@null@*/ char *flags, /*@null@*/ char *type,
     /*@null@*/ yasm_valparamhead *objext_valparams, int builtin);
static yasm_bytecode *gas_parser_align
    (yasm_parser_gas *parser_gas, yasm_section *sect, yasm_expr *boundval,
     /*@null@*/ yasm_expr *fillval, /*@null@*/ yasm_expr *maxskipval,
     int power2);
static yasm_bytecode *gas_parser_dir_fill
    (yasm_parser_gas *parser_gas, /*@only@*/ yasm_expr *repeat,
     /*@only@*/ /*@null@*/ yasm_expr *size,
     /*@only@*/ /*@null@*/ yasm_expr *value);

#define is_eol_tok(tok) ((tok) == '\n' || (tok) == ';' || (tok) == 0)
#define is_eol()        is_eol_tok(curtok)

#define get_next_token()    (curtok = gas_parser_lex(&curval, parser_gas))

static void
get_peek_token(yasm_parser_gas *parser_gas)
{
    char savech = parser_gas->tokch;
    if (parser_gas->peek_token != NONE)
        yasm_internal_error(N_("can only have one token of lookahead"));
    parser_gas->peek_token =
        gas_parser_lex(&parser_gas->peek_tokval, parser_gas);
    parser_gas->peek_tokch = parser_gas->tokch;
    parser_gas->tokch = savech;
}

static void
destroy_curtok_(yasm_parser_gas *parser_gas)
{
    if (curtok < 256)
        ;
    else switch ((enum tokentype)curtok) {
        case INTNUM:
            yasm_intnum_destroy(curval.intn);
            break;
        case FLTNUM:
            yasm_floatnum_destroy(curval.flt);
            break;
        case ID:
        case LABEL:
            yasm_xfree(curval.str_val);
            break;
        case STRING:
            yasm_xfree(curval.str.contents);
            break;
        case INSN:
            yasm_bc_destroy(curval.bc);
            break;
        default:
            break;
    }
    curtok = NONE;          /* sanity */
}
#define destroy_curtok()    destroy_curtok_(parser_gas)

/* Eat all remaining tokens to EOL, discarding all of them.  If there's any
 * intervening tokens, generates an error (junk at end of line).
 */
static void
demand_eol_(yasm_parser_gas *parser_gas)
{
    if (is_eol())
        return;

    yasm_error_set(YASM_ERROR_SYNTAX,
        N_("junk at end of line, first unrecognized character is `%c'"),
        parser_gas->tokch);

    do {
        destroy_curtok();
        get_next_token();
    } while (!is_eol());
}
#define demand_eol() demand_eol_(parser_gas)

static int
expect_(yasm_parser_gas *parser_gas, int token)
{
    static char strch[] = "` '";
    const char *str;

    if (curtok == token)
        return 1;

    switch (token) {
        case INTNUM:            str = "integer"; break;
        case FLTNUM:            str = "floating point value"; break;
        case STRING:            str = "string"; break;
        case INSN:              str = "instruction"; break;
        case PREFIX:            str = "instruction prefix"; break;
        case REG:               str = "register"; break;
        case REGGROUP:          str = "register group"; break;
        case SEGREG:            str = "segment register"; break;
        case TARGETMOD:         str = "target modifier"; break;
        case LEFT_OP:           str = "<<"; break;
        case RIGHT_OP:          str = ">>"; break;
        case ID:                str = "identifier"; break;
        case LABEL:             str = "label"; break;
        default:
            strch[1] = token;
            str = strch;
            break;
    }
    yasm_error_set(YASM_ERROR_PARSE, "expected %s", str);
    destroy_curtok();
    return 0;
}
#define expect(token) expect_(parser_gas, token)

static yasm_bytecode *
parse_line(yasm_parser_gas *parser_gas)
{
    yasm_bytecode *bc;
    yasm_expr *e;
    yasm_valparamhead vps;
    char *id;
    const dir_lookup *dir;

    if (is_eol())
        return NULL;

    bc = parse_instr(parser_gas);
    if (bc)
        return bc;

    switch (curtok) {
        case ID:
            id = ID_val;

            /* See if it's a gas-specific directive */
            dir = (const dir_lookup *)HAMT_search(parser_gas->dirs, id);
            if (dir) {
                parser_gas->state = dir->newstate;
                get_next_token(); /* ID */
                return dir->handler(parser_gas, dir->param);
            }

            parser_gas->state = INSTDIR;
            get_next_token(); /* ID */
            if (curtok == ':') {
                /* Label */
                parser_gas->state = INITIAL;
                get_next_token(); /* : */
                define_label(parser_gas, id, 0);
                return parse_line(parser_gas);
            } else if (curtok == '=') {
                /* EQU */
                /* TODO: allow redefinition, assigning to . (same as .org) */
                parser_gas->state = INITIAL;
                get_next_token(); /* = */
                e = parse_expr(parser_gas);
                if (e)
                    yasm_symtab_define_equ(p_symtab, id, e, cur_line);
                else
                    yasm_error_set(YASM_ERROR_SYNTAX,
                                   N_("expression expected after `%s'"), "=");
                yasm_xfree(id);
                return NULL;
            }

            /* possibly a directive; try to parse it */
            parse_dirvals(parser_gas, &vps);
            if (!yasm_object_directive(p_object, id, "gas", &vps, NULL,
                                       cur_line)) {
                yasm_vps_delete(&vps);
                yasm_xfree(id);
                return NULL;
            }
            yasm_vps_delete(&vps);
            if (id[0] == '.')
                yasm_warn_set(YASM_WARN_GENERAL,
                              N_("directive `%s' not recognized"), id);
            else
                yasm_error_set(YASM_ERROR_SYNTAX,
                               N_("instruction not recognized: `%s'"), id);
            yasm_xfree(id);
            return NULL;
        case LABEL:
            define_label(parser_gas, LABEL_val, 0);
            get_next_token(); /* LABEL */
            return parse_line(parser_gas);
        case LINE_MARKER:
            get_next_token();
            return cpp_line_marker(parser_gas);
        default:
            yasm_error_set(YASM_ERROR_SYNTAX,
                N_("label or instruction expected at start of line"));
            return NULL;
    }
}

/*
    Handle line markers generated by cpp.

    We expect a positive integer (line) followed by a string (filename). If we
    fail to find either of these, we treat the line as a comment. There is a
    possibility of false positives (mistaking a comment for a line marker, when
    the comment is not intended as a line marker) but this cannot be avoided
    without adding a filter to the input before passing it to cpp.

    This function is only called if the preprocessor was 'cpp', since the
    LINE_MARKER token isn't generated for any other preprocessor. With any other
    preprocessor, anything after a '#' is always treated as a comment.
*/
static yasm_bytecode *
cpp_line_marker(yasm_parser_gas *parser_gas)
{
    yasm_valparamhead vps;
    yasm_valparam *vp;
    unsigned long line;
    char *filename;

    /* Line number. */
    if (curtok != INTNUM) {
        /* Skip over a comment. */
        while (curtok != '\n')
            get_next_token();

        return NULL;
    }

    if (yasm_intnum_sign(INTNUM_val) < 0) {
        get_next_token(); /* INTNUM */
        yasm_error_set(YASM_ERROR_SYNTAX,
                       N_("line number is negative"));
        return NULL;
    }

    line = yasm_intnum_get_uint(INTNUM_val);

    /*
        Set to (line - 1) since the directive indicates that the *next* line
        will have the number given.

        cpp should never produce line=0, but the if keeps us safe just incase.
    */
    if (line != 0)
        line--;

    yasm_intnum_destroy(INTNUM_val);
    get_next_token(); /* INTNUM */

    /* File name, in quotes. */
    if (curtok != STRING) {
        /* Skip over a comment. */
        while (curtok != '\n')
            get_next_token();

        return NULL;
    }

    filename = STRING_val.contents;
    get_next_token();

    /* Set linemap. */
    yasm_linemap_set(parser_gas->linemap, filename, line, 1);

    /*
        The first line marker in the file (which should be on the first line
        of the file) will give us the name of the source file. This information
        needs to be passed on to the debug format module.
    */
    if (parser_gas->seen_line_marker == 0) {
        parser_gas->seen_line_marker = 1;

        yasm_vps_initialize(&vps);
        vp = yasm_vp_create_string(NULL, filename);
        yasm_vps_append(&vps, vp);

        yasm_object_directive(p_object, ".file", "gas", &vps, NULL, cur_line);

        yasm_vps_delete(&vps);
    }

    /* Skip flags. */
    while (1) {
        switch (curtok) {
            case INTNUM:
                break;

            case '\n':
                return NULL;

            default:
                yasm_error_set(YASM_ERROR_SYNTAX,
                    N_("junk at end of cpp line marker"));
                return NULL;
        }
        get_next_token();
    }

    /* Never reached. */
    return NULL;
}

/* Line directive */
static yasm_bytecode *
dir_line(yasm_parser_gas *parser_gas, unsigned int param)
{
    if (!expect(INTNUM)) return NULL;
    if (yasm_intnum_sign(INTNUM_val) < 0) {
        get_next_token(); /* INTNUM */
        yasm_error_set(YASM_ERROR_SYNTAX,
                       N_("line number is negative"));
        return NULL;
    }

    parser_gas->dir_line = yasm_intnum_get_uint(INTNUM_val);
    yasm_intnum_destroy(INTNUM_val);
    get_next_token(); /* INTNUM */

    if (parser_gas->dir_fileline == 3) {
        /* Have both file and line */
        yasm_linemap_set(parser_gas->linemap, NULL,
                         parser_gas->dir_line, 1);
    } else if (parser_gas->dir_fileline == 1) {
        /* Had previous file directive only */
        parser_gas->dir_fileline = 3;
        yasm_linemap_set(parser_gas->linemap, parser_gas->dir_file,
                         parser_gas->dir_line, 1);
    } else {
        /* Didn't see file yet */
        parser_gas->dir_fileline = 2;
    }
    return NULL;
}

/* Macro directives */

static yasm_bytecode *
dir_rept(yasm_parser_gas *parser_gas, unsigned int param)
{
    yasm_intnum *intn;
    yasm_expr *e = parse_expr(parser_gas);

    if (!e) {
        yasm_error_set(YASM_ERROR_SYNTAX,
                       N_("expression expected after `%s'"),
                       ".rept");
        return NULL;
    }
    intn = yasm_expr_get_intnum(&e, 0);

    if (!intn) {
        yasm_error_set(YASM_ERROR_NOT_ABSOLUTE,
                       N_("rept expression not absolute"));
    } else if (yasm_intnum_sign(intn) < 0) {
        yasm_error_set(YASM_ERROR_VALUE,
                       N_("rept expression is negative"));
    } else {
        gas_rept *rept = yasm_xmalloc(sizeof(gas_rept));
        STAILQ_INIT(&rept->lines);
        rept->startline = cur_line;
        rept->numrept = yasm_intnum_get_uint(intn);
        rept->numdone = 0;
        rept->line = NULL;
        rept->linepos = 0;
        rept->ended = 0;
        rept->oldbuf = NULL;
        rept->oldbuflen = 0;
        rept->oldbufpos = 0;
        parser_gas->rept = rept;
    }
    return NULL;
}

static yasm_bytecode *
dir_endr(yasm_parser_gas *parser_gas, unsigned int param)
{
    /* Shouldn't ever get here unless we didn't get a DIR_REPT first */
    yasm_error_set(YASM_ERROR_SYNTAX, N_("endr without matching rept"));
    return NULL;
}

/* Alignment directives */

static yasm_bytecode *
dir_align(yasm_parser_gas *parser_gas, unsigned int param)
{
    yasm_expr *bound, *fill=NULL, *maxskip=NULL;

    bound = parse_expr(parser_gas);
    if (!bound) {
        yasm_error_set(YASM_ERROR_SYNTAX,
                       N_(".align directive must specify alignment"));
        return NULL;
    }

    if (curtok == ',') {
        get_next_token(); /* ',' */
        fill = parse_expr(parser_gas);
        if (curtok == ',') {
            get_next_token(); /* ',' */
            maxskip = parse_expr(parser_gas);
        }
    }

    return gas_parser_align(parser_gas, cursect, bound, fill, maxskip,
                            (int)param);
}

static yasm_bytecode *
dir_org(yasm_parser_gas *parser_gas, unsigned int param)
{
    yasm_intnum *start, *value=NULL;
    yasm_bytecode *bc;

    /* TODO: support expr instead of intnum */
    if (!expect(INTNUM)) return NULL;
    start = INTNUM_val;
    get_next_token(); /* INTNUM */

    if (curtok == ',') {
        get_next_token(); /* ',' */
        /* TODO: support expr instead of intnum */
        if (!expect(INTNUM)) return NULL;
        value = INTNUM_val;
        get_next_token(); /* INTNUM */
    }
    if (value) {
        bc = yasm_bc_create_org(yasm_intnum_get_uint(start),
                                yasm_intnum_get_uint(value), cur_line);
        yasm_intnum_destroy(value);
    } else
        bc = yasm_bc_create_org(yasm_intnum_get_uint(start), 0,
                                cur_line);
    yasm_intnum_destroy(start);
    return bc;
}

/* Data visibility directives */

static yasm_bytecode *
dir_local(yasm_parser_gas *parser_gas, unsigned int param)
{
    if (!expect(ID)) return NULL;
    yasm_symtab_declare(p_symtab, ID_val, YASM_SYM_DLOCAL, cur_line);
    yasm_xfree(ID_val);
    get_next_token(); /* ID */
    return NULL;
}

static yasm_bytecode *
dir_comm(yasm_parser_gas *parser_gas, unsigned int is_lcomm)
{
    yasm_expr *align = NULL;
    /*@null@*/ /*@dependent@*/ yasm_symrec *sym;
    char *id;
    yasm_expr *e;

    if (!expect(ID)) return NULL;
    id = ID_val;
    get_next_token(); /* ID */
    if (!expect(',')) {
        yasm_xfree(id);
        return NULL;
    }
    get_next_token(); /* , */
    e = parse_expr(parser_gas);
    if (!e) {
        yasm_error_set(YASM_ERROR_SYNTAX, N_("size expected for `%s'"),
                       ".COMM");
        return NULL;
    }
    if (curtok == ',') {
        /* Optional alignment expression */
        get_next_token(); /* ',' */
        align = parse_expr(parser_gas);
    }
    /* If already explicitly declared local, treat like LCOMM */
    if (is_lcomm
        || ((sym = yasm_symtab_get(p_symtab, id))
            && yasm_symrec_get_visibility(sym) == YASM_SYM_DLOCAL)) {
        define_lcomm(parser_gas, id, e, align);
    } else if (align) {
        /* Give third parameter as objext valparam */
        yasm_valparamhead *extvps = yasm_vps_create();
        yasm_valparam *vp = yasm_vp_create_expr(NULL, align);
        yasm_vps_append(extvps, vp);

        sym = yasm_symtab_declare(p_symtab, id, YASM_SYM_COMMON,
                                  cur_line);
        yasm_symrec_set_common_size(sym, e);
        yasm_symrec_set_objext_valparams(sym, extvps);

        yasm_xfree(id);
    } else {
        sym = yasm_symtab_declare(p_symtab, id, YASM_SYM_COMMON,
                                  cur_line);
        yasm_symrec_set_common_size(sym, e);
        yasm_xfree(id);
    }
    return NULL;
}

/* Integer data definition directives */

static yasm_bytecode *
dir_ascii(yasm_parser_gas *parser_gas, unsigned int withzero)
{
    yasm_datavalhead dvs;
    if (!parse_strvals(parser_gas, &dvs))
        return NULL;
    return yasm_bc_create_data(&dvs, 1, (int)withzero, p_object->arch,
                               cur_line);
}

static yasm_bytecode *
dir_data(yasm_parser_gas *parser_gas, unsigned int size)
{
    yasm_datavalhead dvs;
    if (!parse_datavals(parser_gas, &dvs))
        return NULL;
    return yasm_bc_create_data(&dvs, size, 0, p_object->arch, cur_line);
}

static yasm_bytecode *
dir_leb128(yasm_parser_gas *parser_gas, unsigned int sign)
{
    yasm_datavalhead dvs;
    if (!parse_datavals(parser_gas, &dvs))
        return NULL;
    return yasm_bc_create_leb128(&dvs, (int)sign, cur_line);
}

/* Empty space / fill data definition directives */

static yasm_bytecode *
dir_zero(yasm_parser_gas *parser_gas, unsigned int param)
{
    yasm_bytecode *bc;
    yasm_datavalhead dvs;
    yasm_expr *e = parse_expr(parser_gas);
    if (!e) {
        yasm_error_set(YASM_ERROR_SYNTAX,
                       N_("expression expected after `%s'"), ".ZERO");
        return NULL;
    }

    yasm_dvs_initialize(&dvs);
    yasm_dvs_append(&dvs, yasm_dv_create_expr(
        p_expr_new_ident(yasm_expr_int(yasm_intnum_create_uint(0)))));
    bc = yasm_bc_create_data(&dvs, 1, 0, p_object->arch, cur_line);
    yasm_bc_set_multiple(bc, e);
    return bc;
}

static yasm_bytecode *
dir_skip(yasm_parser_gas *parser_gas, unsigned int param)
{
    yasm_expr *e, *e_val;
    yasm_bytecode *bc;
    yasm_datavalhead dvs;

    e = parse_expr(parser_gas);
    if (!e) {
        yasm_error_set(YASM_ERROR_SYNTAX,
                       N_("expression expected after `%s'"), ".SKIP");
        return NULL;
    }
    if (curtok != ',')
        return yasm_bc_create_reserve(e, 1, cur_line);
    get_next_token(); /* ',' */
    e_val = parse_expr(parser_gas);
    yasm_dvs_initialize(&dvs);
    yasm_dvs_append(&dvs, yasm_dv_create_expr(e_val));
    bc = yasm_bc_create_data(&dvs, 1, 0, p_object->arch, cur_line);

    yasm_bc_set_multiple(bc, e);
    return bc;
}

/* fill data definition directive */
static yasm_bytecode *
dir_fill(yasm_parser_gas *parser_gas, unsigned int param)
{
    yasm_expr *sz=NULL, *val=NULL;
    yasm_expr *e = parse_expr(parser_gas);
    if (!e) {
        yasm_error_set(YASM_ERROR_SYNTAX,
                       N_("expression expected after `%s'"), ".FILL");
        return NULL;
    }
    if (curtok == ',') {
        get_next_token(); /* ',' */
        sz = parse_expr(parser_gas);
        if (curtok == ',') {
            get_next_token(); /* ',' */
            val = parse_expr(parser_gas);
        }
    }
    return gas_parser_dir_fill(parser_gas, e, sz, val);
}

/* Section directives */

static yasm_bytecode *
dir_bss_section(yasm_parser_gas *parser_gas, unsigned int param)
{
    gas_switch_section(parser_gas, ".bss", NULL, NULL, NULL, 1);
    return NULL;
}

static yasm_bytecode *
dir_data_section(yasm_parser_gas *parser_gas, unsigned int param)
{
    gas_switch_section(parser_gas, ".data", NULL, NULL, NULL, 1);
    return NULL;
}

static yasm_bytecode *
dir_text_section(yasm_parser_gas *parser_gas, unsigned int param)
{
    gas_switch_section(parser_gas, ".text", NULL, NULL, NULL, 1);
    return NULL;
}

static yasm_bytecode *
dir_section(yasm_parser_gas *parser_gas, unsigned int param)
{
    /* DIR_SECTION ID ',' STRING ',' '@' ID ',' dirvals */
    char *sectname, *flags = NULL, *type = NULL;
    yasm_valparamhead vps;
    int have_vps = 0;

    if (!expect(ID)) return NULL;
    sectname = ID_val;
    get_next_token(); /* ID */

    if (curtok == ',') {
        get_next_token(); /* ',' */
        if (!expect(STRING)) {
            yasm_error_set(YASM_ERROR_SYNTAX,
                           N_("flag string expected"));
            yasm_xfree(sectname);
            return NULL;
        }
        flags = STRING_val.contents;
        get_next_token(); /* STRING */
    }

    if (curtok == ',') {
        get_next_token(); /* ',' */
        if (!expect('@')) {
            yasm_xfree(sectname);
            yasm_xfree(flags);
            return NULL;
        }
        get_next_token(); /* '@' */
        if (!expect(ID)) {
            yasm_xfree(sectname);
            yasm_xfree(flags);
            return NULL;
        }
        type = ID_val;
        get_next_token(); /* ID */
    }

    if (curtok == ',') {
        get_next_token(); /* ',' */
        if (parse_dirvals(parser_gas, &vps))
            have_vps = 1;
    }

    gas_switch_section(parser_gas, sectname, flags, type,
                       have_vps ? &vps : NULL, 0);
    yasm_xfree(sectname);
    yasm_xfree(flags);
    return NULL;
}

/* Other directives */

static yasm_bytecode *
dir_equ(yasm_parser_gas *parser_gas, unsigned int param)
{
    yasm_expr *e;
    char *id;

    /* ID ',' expr */
    if (!expect(ID)) return NULL;
    id = ID_val;
    get_next_token(); /* ID */
    if (!expect(',')) {
        yasm_xfree(id);
        return NULL;
    }
    get_next_token(); /* ',' */
    e = parse_expr(parser_gas);
    if (e)
        yasm_symtab_define_equ(p_symtab, id, e, cur_line);
    else
        yasm_error_set(YASM_ERROR_SYNTAX,
                       N_("expression expected after `%s'"), ",");
    yasm_xfree(id);
    return NULL;
}

static yasm_bytecode *
dir_file(yasm_parser_gas *parser_gas, unsigned int param)
{
    yasm_valparamhead vps;
    yasm_valparam *vp;

    if (curtok == STRING) {
        /* No file number; this form also sets the assembler's
         * internal line number.
         */
        char *filename = STRING_val.contents;

        get_next_token(); /* STRING */
        if (parser_gas->dir_fileline == 3) {
            /* Have both file and line */
            const char *old_fn;
            unsigned long old_line;

            yasm_linemap_lookup(parser_gas->linemap, cur_line, &old_fn,
                                &old_line);
            yasm_linemap_set(parser_gas->linemap, filename, old_line,
                             1);
        } else if (parser_gas->dir_fileline == 2) {
            /* Had previous line directive only */
            parser_gas->dir_fileline = 3;
            yasm_linemap_set(parser_gas->linemap, filename,
                             parser_gas->dir_line, 1);
        } else {
            /* Didn't see line yet, save file */
            parser_gas->dir_fileline = 1;
            if (parser_gas->dir_file)
                yasm_xfree(parser_gas->dir_file);
            parser_gas->dir_file = yasm__xstrdup(filename);
        }

        /* Pass change along to debug format */
        yasm_vps_initialize(&vps);
        vp = yasm_vp_create_string(NULL, filename);
        yasm_vps_append(&vps, vp);

        yasm_object_directive(p_object, ".file", "gas", &vps, NULL,
                              cur_line);

        yasm_vps_delete(&vps);
        return NULL;
    }

    /* fileno filename form */
    yasm_vps_initialize(&vps);

    if (!expect(INTNUM)) return NULL;
    vp = yasm_vp_create_expr(NULL,
        p_expr_new_ident(yasm_expr_int(INTNUM_val)));
    yasm_vps_append(&vps, vp);
    get_next_token(); /* INTNUM */

    if (!expect(STRING)) {
        yasm_vps_delete(&vps);
        return NULL;
    }
    vp = yasm_vp_create_string(NULL, STRING_val.contents);
    yasm_vps_append(&vps, vp);
    get_next_token(); /* STRING */

    yasm_object_directive(p_object, ".file", "gas", &vps, NULL,
                          cur_line);

    yasm_vps_delete(&vps);
    return NULL;
}

static yasm_bytecode *
parse_instr(yasm_parser_gas *parser_gas)
{
    yasm_bytecode *bc;

    switch (curtok) {
        case INSN:
        {
            yasm_insn *insn;
            bc = INSN_val;
            insn = yasm_bc_get_insn(bc);

            get_next_token();
            if (is_eol())
                return bc;      /* no operands */

            /* parse operands */
            for (;;) {
                yasm_insn_operand *op = parse_operand(parser_gas);
                if (!op) {
                    yasm_error_set(YASM_ERROR_SYNTAX,
                                   N_("expression syntax error"));
                    yasm_bc_destroy(bc);
                    return NULL;
                }
                yasm_insn_ops_append(insn, op);

                if (is_eol())
                    break;
                if (!expect(',')) {
                    yasm_bc_destroy(bc);
                    return NULL;
                }
                get_next_token();
            }
            return bc;
        }
        case PREFIX:
        {
            uintptr_t prefix = PREFIX_val;
            get_next_token(); /* PREFIX */
            bc = parse_instr(parser_gas);
            if (!bc)
                bc = yasm_arch_create_empty_insn(p_object->arch, cur_line);
            yasm_insn_add_prefix(yasm_bc_get_insn(bc), prefix);
            return bc;
        }
        case SEGREG:
        {
            uintptr_t segreg = SEGREG_val;
            get_next_token(); /* SEGREG */
            bc = parse_instr(parser_gas);
            if (!bc)
                bc = yasm_arch_create_empty_insn(p_object->arch, cur_line);
            yasm_insn_add_seg_prefix(yasm_bc_get_insn(bc), segreg);
        }
        default:
            return NULL;
    }
}

static int
parse_dirvals(yasm_parser_gas *parser_gas, yasm_valparamhead *vps)
{
    yasm_valparam *vp;
    yasm_expr *e;
    int num = 0;

    yasm_vps_initialize(vps);

    for (;;) {
        switch (curtok) {
            case ID:
                get_peek_token(parser_gas);
                switch (parser_gas->peek_token) {
                    case '+': case '-':
                    case '|': case '^': case '&': case '!':
                    case '*': case '/': case '%': case LEFT_OP: case RIGHT_OP:
                        e = parse_expr(parser_gas);
                        vp = yasm_vp_create_expr(NULL, e);
                        break;
                    default:
                        /* Just an ID */
                        vp = yasm_vp_create_id(NULL, ID_val, '\0');
                        get_next_token(); /* ID */
                        break;
                }
                break;
            case STRING:
                vp = yasm_vp_create_string(NULL, STRING_val.contents);
                get_next_token(); /* STRING */
                break;
            case '@':
                /* XXX: is throwing it away *really* the right thing? */
                get_next_token(); /* @ */
                continue;
            default:
                e = parse_expr(parser_gas);
                if (!e)
                    return num;
                vp = yasm_vp_create_expr(NULL, e);
                break;
        }
        yasm_vps_append(vps, vp);
        num++;
        if (curtok == ',')
            get_next_token(); /* ',' */
    }
    return num;
}

static int
parse_datavals(yasm_parser_gas *parser_gas, yasm_datavalhead *dvs)
{
    yasm_expr *e;
    yasm_dataval *dv;
    int num = 0;

    yasm_dvs_initialize(dvs);

    for (;;) {
        e = parse_expr(parser_gas);
        if (!e) {
            yasm_dvs_delete(dvs);
            yasm_dvs_initialize(dvs);
            return 0;
        }
        dv = yasm_dv_create_expr(e);
        yasm_dvs_append(dvs, dv);
        num++;
        if (curtok != ',')
            break;
        get_next_token(); /* ',' */
    }
    return num;
}

static int
parse_strvals(yasm_parser_gas *parser_gas, yasm_datavalhead *dvs)
{
    yasm_dataval *dv;
    int num = 0;

    yasm_dvs_initialize(dvs);

    for (;;) {
        if (!expect(STRING)) {
            yasm_dvs_delete(dvs);
            yasm_dvs_initialize(dvs);
            return 0;
        }
        dv = yasm_dv_create_string(STRING_val.contents, STRING_val.len);
        yasm_dvs_append(dvs, dv);
        get_next_token(); /* STRING */
        num++;
        if (curtok != ',')
            break;
        get_next_token(); /* ',' */
    }
    return num;
}

/* instruction operands */
/* memory addresses */
static yasm_effaddr *
parse_memaddr(yasm_parser_gas *parser_gas)
{
    yasm_effaddr *ea = NULL;
    yasm_expr *e1, *e2;
    int strong = 0;

    if (curtok == SEGREG) {
        uintptr_t segreg = SEGREG_val;
        get_next_token(); /* SEGREG */
        if (!expect(':')) return NULL;
        get_next_token(); /* ':' */
        ea = parse_memaddr(parser_gas);
        if (!ea)
            return NULL;
        yasm_ea_set_segreg(ea, segreg);
        return ea;
    }

    /* We want to parse a leading expression, except when it's actually
     * just a memory address (with no preceding expression) such as
     * (REG...) or (,...).
     */
    get_peek_token(parser_gas);
    if (curtok != '(' || (parser_gas->peek_token != REG
                          && parser_gas->peek_token != ','))
        e1 = parse_expr(parser_gas);
    else
        e1 = NULL;

    if (curtok == '(') {
        int havereg = 0;
        uintptr_t reg = 0;
        yasm_intnum *scale = NULL;

        get_next_token(); /* '(' */

        /* base register */
        if (curtok == REG) {
            e2 = p_expr_new_ident(yasm_expr_reg(REG_val));
            get_next_token(); /* REG */
        } else
            e2 = p_expr_new_ident(yasm_expr_int(yasm_intnum_create_uint(0)));

        if (curtok == ')')
            goto done;

        if (!expect(',')) {
            yasm_error_set(YASM_ERROR_SYNTAX, N_("invalid memory expression"));
            if (e1) yasm_expr_destroy(e1);
            yasm_expr_destroy(e2);
            return NULL;
        }
        get_next_token(); /* ',' */

        if (curtok == ')')
            goto done;

        /* index register */
        if (curtok == REG) {
            reg = REG_val;
            havereg = 1;
            get_next_token(); /* REG */
            if (curtok != ',') {
                scale = yasm_intnum_create_uint(1);
                goto done;
            }
            get_next_token(); /* ',' */
        }

        /* scale */
        if (!expect(INTNUM)) {
            yasm_error_set(YASM_ERROR_SYNTAX, N_("non-integer scale"));
            if (e1) yasm_expr_destroy(e1);
            yasm_expr_destroy(e2);
            return NULL;
        }
        scale = INTNUM_val;
        get_next_token(); /* INTNUM */

done:
        if (!expect(')')) {
            yasm_error_set(YASM_ERROR_SYNTAX, N_("invalid memory expression"));
            if (scale) yasm_intnum_destroy(scale);
            if (e1) yasm_expr_destroy(e1);
            yasm_expr_destroy(e2);
            return NULL;
        }
        get_next_token(); /* ')' */

        if (scale) {
            if (!havereg) {
                if (yasm_intnum_get_uint(scale) != 1)
                    yasm_warn_set(YASM_WARN_GENERAL,
                        N_("scale factor of %u without an index register"),
                        yasm_intnum_get_uint(scale));
                yasm_intnum_destroy(scale);
            } else
                e2 = p_expr_new(yasm_expr_expr(e2), YASM_EXPR_ADD,
                    yasm_expr_expr(p_expr_new(yasm_expr_reg(reg), YASM_EXPR_MUL,
                                              yasm_expr_int(scale))));
        }

        if (e1) {
            /* Ordering is critical here to correctly detecting presence of
             * RIP in RIP-relative expressions.
             */
            e1 = p_expr_new_tree(e2, YASM_EXPR_ADD, e1);
        } else
            e1 = e2;
        strong = 1;
    }

    if (!e1)
        return NULL;
    ea = yasm_arch_ea_create(p_object->arch, e1);
    if (strong)
        ea->strong = 1;
    return ea;
}

static yasm_insn_operand *
parse_operand(yasm_parser_gas *parser_gas)
{
    yasm_effaddr *ea;
    yasm_insn_operand *op;
    uintptr_t reg;

    switch (curtok) {
        case REG:
            reg = REG_val;
            get_next_token(); /* REG */
            return yasm_operand_create_reg(reg);
        case SEGREG:
            /* need to see if it's really a memory address */
            get_peek_token(parser_gas);
            if (parser_gas->peek_token == ':') {
                ea = parse_memaddr(parser_gas);
                if (!ea)
                    return NULL;
                return yasm_operand_create_mem(ea);
            }
            reg = SEGREG_val;
            get_next_token(); /* SEGREG */
            return yasm_operand_create_segreg(reg);
        case REGGROUP:
        {
            unsigned long regindex;
            reg = REGGROUP_val;
            get_next_token(); /* REGGROUP */
            if (curtok != '(')
                return yasm_operand_create_reg(reg);
            get_next_token(); /* '(' */
            if (!expect(INTNUM)) {
                yasm_error_set(YASM_ERROR_SYNTAX,
                               N_("integer register index expected"));
                return NULL;
            }
            regindex = yasm_intnum_get_uint(INTNUM_val);
            get_next_token(); /* INTNUM */
            if (!expect(')')) {
                yasm_error_set(YASM_ERROR_SYNTAX,
                    N_("missing closing parenthesis for register index"));
                return NULL;
            }
            get_next_token(); /* ')' */
            reg = yasm_arch_reggroup_get_reg(p_object->arch, reg, regindex);
            if (reg == 0) {
                yasm_error_set(YASM_ERROR_SYNTAX, N_("bad register index `%u'"),
                               regindex);
                return NULL;
            }
            return yasm_operand_create_reg(reg);
        }
        case '$':
        {
            yasm_expr *e;
            get_next_token(); /* '$' */
            e = parse_expr(parser_gas);
            if (!e) {
                yasm_error_set(YASM_ERROR_SYNTAX,
                               N_("expression missing after `%s'"), "$");
                return NULL;
            }
            return yasm_operand_create_imm(e);
        }
        case '*':
            get_next_token(); /* '*' */
            if (curtok == REG) {
                op = yasm_operand_create_reg(REG_val);
                get_next_token(); /* REG */
            } else {
                ea = parse_memaddr(parser_gas);
                if (!ea) {
                    yasm_error_set(YASM_ERROR_SYNTAX,
                                   N_("expression missing after `%s'"), "*");
                    return NULL;
                }
                op = yasm_operand_create_mem(ea);
            }
            op->deref = 1;
            return op;
        default:
            ea = parse_memaddr(parser_gas);
            if (!ea)
                return NULL;
            return yasm_operand_create_mem(ea);
    }
}

/* Expression grammar parsed is:
 *
 * expr  : expr0 [ {+,-} expr0...]
 * expr0 : expr1 [ {|,^,&,!} expr1...]
 * expr1 : expr2 [ {*,/,%,<<,>>} expr2...]
 * expr2 : { ~,+,- } expr2
 *       | (expr)
 *       | symbol
 *       | number
 */

static yasm_expr *
parse_expr(yasm_parser_gas *parser_gas)
{
    yasm_expr *e, *f;
    e = parse_expr0(parser_gas);
    if (!e)
        return NULL;

    while (curtok == '+' || curtok == '-') {
        int op = curtok;
        get_next_token();
        f = parse_expr0(parser_gas);
        if (!f) {
            yasm_expr_destroy(e);
            return NULL;
        }

        switch (op) {
            case '+': e = p_expr_new_tree(e, YASM_EXPR_ADD, f); break;
            case '-': e = p_expr_new_tree(e, YASM_EXPR_SUB, f); break;
        }
    }
    return e;
}

static yasm_expr *
parse_expr0(yasm_parser_gas *parser_gas)
{
    yasm_expr *e, *f;
    e = parse_expr1(parser_gas);
    if (!e)
        return NULL;

    while (curtok == '|' || curtok == '^' || curtok == '&' || curtok == '!') {
        int op = curtok;
        get_next_token();
        f = parse_expr1(parser_gas);
        if (!f) {
            yasm_expr_destroy(e);
            return NULL;
        }

        switch (op) {
            case '|': e = p_expr_new_tree(e, YASM_EXPR_OR, f); break;
            case '^': e = p_expr_new_tree(e, YASM_EXPR_XOR, f); break;
            case '&': e = p_expr_new_tree(e, YASM_EXPR_AND, f); break;
            case '!': e = p_expr_new_tree(e, YASM_EXPR_NOR, f); break;
        }
    }
    return e;
}

static yasm_expr *
parse_expr1(yasm_parser_gas *parser_gas)
{
    yasm_expr *e, *f;
    e = parse_expr2(parser_gas);
    if (!e)
        return NULL;

    while (curtok == '*' || curtok == '/' || curtok == '%' || curtok == LEFT_OP
           || curtok == RIGHT_OP) {
        int op = curtok;
        get_next_token();
        f = parse_expr2(parser_gas);
        if (!f) {
            yasm_expr_destroy(e);
            return NULL;
        }

        switch (op) {
            case '*': e = p_expr_new_tree(e, YASM_EXPR_MUL, f); break;
            case '/': e = p_expr_new_tree(e, YASM_EXPR_DIV, f); break;
            case '%': e = p_expr_new_tree(e, YASM_EXPR_MOD, f); break;
            case LEFT_OP: e = p_expr_new_tree(e, YASM_EXPR_SHL, f); break;
            case RIGHT_OP: e = p_expr_new_tree(e, YASM_EXPR_SHR, f); break;
        }
    }
    return e;
}

static yasm_expr *
parse_expr2(yasm_parser_gas *parser_gas)
{
    yasm_expr *e;
    yasm_symrec *sym;

    switch (curtok) {
        case '+':
            get_next_token();
            return parse_expr2(parser_gas);
        case '-':
            get_next_token();
            e = parse_expr2(parser_gas);
            if (!e)
                return NULL;
            return p_expr_new_branch(YASM_EXPR_NEG, e);
        case '~':
            get_next_token();
            e = parse_expr2(parser_gas);
            if (!e)
                return NULL;
            return p_expr_new_branch(YASM_EXPR_NOT, e);
        case '(':
            get_next_token();
            e = parse_expr(parser_gas);
            if (!e)
                return NULL;
            if (!expect(')')) {
                yasm_error_set(YASM_ERROR_SYNTAX, N_("missing parenthesis"));
                return NULL;
            }
            get_next_token();
            return e;
        case INTNUM:
            e = p_expr_new_ident(yasm_expr_int(INTNUM_val));
            get_next_token();
            return e;
        case FLTNUM:
            e = p_expr_new_ident(yasm_expr_float(FLTNUM_val));
            get_next_token();
            return e;
        case ID:
        {
            char *name = ID_val;
            get_next_token(); /* ID */

            /* "." references the current assembly position */
            if (name[1] == '\0' && name[0] == '.')
                sym = yasm_symtab_define_curpos(p_symtab, ".",
                                                parser_gas->prev_bc, cur_line);
            else
                sym = yasm_symtab_use(p_symtab, name, cur_line);
            yasm_xfree(name);

            if (curtok == '@') {
                yasm_symrec *wrt;
                /* TODO: this is needed for shared objects, e.g. sym@PLT */
                get_next_token(); /* '@' */
                if (!expect(ID)) {
                    yasm_error_set(YASM_ERROR_SYNTAX,
                                   N_("expected identifier after `@'"));
                    yasm_xfree(name);
                    return NULL;
                }
                wrt = yasm_objfmt_get_special_sym(p_object, ID_val, "gas");
                yasm_xfree(ID_val);
                get_next_token(); /* ID */
                if (!wrt) {
                    yasm_warn_set(YASM_WARN_GENERAL,
                                  N_("unrecognized identifier after `@'"));
                    return p_expr_new_ident(yasm_expr_sym(sym));
                }
                return p_expr_new(yasm_expr_sym(sym), YASM_EXPR_WRT,
                                  yasm_expr_sym(wrt));
            }

            return p_expr_new_ident(yasm_expr_sym(sym));
        }
        default:
            return NULL;
    }
}

static void
define_label(yasm_parser_gas *parser_gas, char *name, int local)
{
    if (!local) {
        if (parser_gas->locallabel_base)
            yasm_xfree(parser_gas->locallabel_base);
        parser_gas->locallabel_base_len = strlen(name);
        parser_gas->locallabel_base =
            yasm_xmalloc(parser_gas->locallabel_base_len+1);
        strcpy(parser_gas->locallabel_base, name);
    }

    yasm_symtab_define_label(p_symtab, name, parser_gas->prev_bc, 1,
                             cur_line);
    yasm_xfree(name);
}

static void
define_lcomm(yasm_parser_gas *parser_gas, /*@only@*/ char *name,
             yasm_expr *size, /*@null@*/ yasm_expr *align)
{
    /* Put into .bss section. */
    /*@dependent@*/ yasm_section *bss =
        gas_get_section(parser_gas, yasm__xstrdup(".bss"), NULL, NULL, NULL, 1);

    if (align) {
        /* XXX: assume alignment is in bytes, not power-of-two */
        yasm_section_bcs_append(bss, gas_parser_align(parser_gas, bss, align,
                                NULL, NULL, 0));
    }

    yasm_symtab_define_label(p_symtab, name, yasm_section_bcs_last(bss), 1,
                             cur_line);
    yasm_section_bcs_append(bss, yasm_bc_create_reserve(size, 1, cur_line));
    yasm_xfree(name);
}

static yasm_section *
gas_get_section(yasm_parser_gas *parser_gas, char *name,
                /*@null@*/ char *flags, /*@null@*/ char *type,
                /*@null@*/ yasm_valparamhead *objext_valparams,
                int builtin)
{
    yasm_valparamhead vps;
    yasm_valparam *vp;
    char *gasflags;
    yasm_section *new_section;

    yasm_vps_initialize(&vps);
    vp = yasm_vp_create_id(NULL, name, '\0');
    yasm_vps_append(&vps, vp);

    if (!builtin) {
        if (flags)
            gasflags = yasm__xstrdup(flags);
        else
            gasflags = yasm__xstrdup("");
        vp = yasm_vp_create_string(yasm__xstrdup("gasflags"), gasflags);
        yasm_vps_append(&vps, vp);
        if (type) {
            vp = yasm_vp_create_id(NULL, type, '\0');
            yasm_vps_append(&vps, vp);
        }
    }

    new_section = yasm_objfmt_section_switch(p_object, &vps, objext_valparams,
                                             cur_line);

    yasm_vps_delete(&vps);
    return new_section;
}

static void
gas_switch_section(yasm_parser_gas *parser_gas, const char *name,
                   /*@null@*/ char *flags, /*@null@*/ char *type,
                   /*@null@*/ yasm_valparamhead *objext_valparams,
                   int builtin)
{
    yasm_section *new_section;

    new_section = gas_get_section(parser_gas, yasm__xstrdup(name), flags, type,
                                  objext_valparams, builtin);
    if (new_section) {
        cursect = new_section;
        parser_gas->prev_bc = yasm_section_bcs_last(new_section);
    } else
        yasm_error_set(YASM_ERROR_GENERAL, N_("invalid section name `%s'"),
                       name);

    if (objext_valparams)
        yasm_vps_delete(objext_valparams);
}

static yasm_bytecode *
gas_parser_align(yasm_parser_gas *parser_gas, yasm_section *sect,
                 yasm_expr *boundval, /*@null@*/ yasm_expr *fillval,
                 /*@null@*/ yasm_expr *maxskipval, int power2)
{
    yasm_intnum *boundintn;

    /* Convert power of two to number of bytes if necessary */
    if (power2)
        boundval = yasm_expr_create(YASM_EXPR_SHL,
                                    yasm_expr_int(yasm_intnum_create_uint(1)),
                                    yasm_expr_expr(boundval), cur_line);

    /* Largest .align in the section specifies section alignment. */
    boundintn = yasm_expr_get_intnum(&boundval, 0);
    if (boundintn) {
        unsigned long boundint = yasm_intnum_get_uint(boundintn);

        /* Alignments must be a power of two. */
        if (is_exp2(boundint)) {
            if (boundint > yasm_section_get_align(sect))
                yasm_section_set_align(sect, boundint, cur_line);
        }
    }

    return yasm_bc_create_align(boundval, fillval, maxskipval,
                                yasm_section_is_code(sect) ?
                                    yasm_arch_get_fill(p_object->arch) : NULL,
                                cur_line);
}

static yasm_bytecode *
gas_parser_dir_fill(yasm_parser_gas *parser_gas, /*@only@*/ yasm_expr *repeat,
                    /*@only@*/ /*@null@*/ yasm_expr *size,
                    /*@only@*/ /*@null@*/ yasm_expr *value)
{
    yasm_datavalhead dvs;
    yasm_bytecode *bc;
    unsigned int ssize;

    if (size) {
        /*@dependent@*/ /*@null@*/ yasm_intnum *intn;
        intn = yasm_expr_get_intnum(&size, 0);
        if (!intn) {
            yasm_error_set(YASM_ERROR_NOT_ABSOLUTE,
                           N_("size must be an absolute expression"));
            yasm_expr_destroy(repeat);
            yasm_expr_destroy(size);
            if (value)
                yasm_expr_destroy(value);
            return NULL;
        }
        ssize = yasm_intnum_get_uint(intn);
    } else
        ssize = 1;

    if (!value)
        value = yasm_expr_create_ident(
            yasm_expr_int(yasm_intnum_create_uint(0)), cur_line);

    yasm_dvs_initialize(&dvs);
    yasm_dvs_append(&dvs, yasm_dv_create_expr(value));
    bc = yasm_bc_create_data(&dvs, ssize, 0, p_object->arch, cur_line);

    yasm_bc_set_multiple(bc, repeat);

    return bc;
}

static dir_lookup dirs_static[] = {
    /* FIXME: Whether this is power-of-two or not depends on arch and objfmt. */
    {".align",      dir_align,  0,  INSTDIR},
    {".p2align",    dir_align,  1,  INSTDIR},
    {".balign",     dir_align,  0,  INSTDIR},
    {".org",        dir_org,    0,  INSTDIR},
    /* data visibility directives */
    {".local",      dir_local,  0,  INSTDIR},
    {".comm",       dir_comm,   0,  INSTDIR},
    {".lcomm",      dir_comm,   1,  INSTDIR},
    /* integer data declaration directives */
    {".byte",       dir_data,   1,  INSTDIR},
    {".2byte",      dir_data,   2,  INSTDIR},
    {".4byte",      dir_data,   4,  INSTDIR},
    {".8byte",      dir_data,   8,  INSTDIR},
    {".16byte",     dir_data,   16, INSTDIR},
    /* TODO: These should depend on arch */
    {".short",      dir_data,   2,  INSTDIR},
    {".int",        dir_data,   4,  INSTDIR},
    {".long",       dir_data,   4,  INSTDIR},
    {".hword",      dir_data,   2,  INSTDIR},
    {".quad",       dir_data,   8,  INSTDIR},
    {".octa",       dir_data,   16, INSTDIR},
    /* XXX: At least on x86, this is 2 bytes */
    {".value",      dir_data,   2,  INSTDIR},
    /* ASCII data declaration directives */
    {".ascii",      dir_ascii,  0,  INSTDIR},   /* no terminating zero */
    {".asciz",      dir_ascii,  1,  INSTDIR},   /* add terminating zero */
    {".string",     dir_ascii,  1,  INSTDIR},   /* add terminating zero */
    /* LEB128 integer data declaration directives */
    {".sleb128",    dir_leb128, 1,  INSTDIR},   /* signed */
    {".uleb128",    dir_leb128, 0,  INSTDIR},   /* unsigned */
    /* floating point data declaration directives */
    {".float",      dir_data,   4,  INSTDIR},
    {".single",     dir_data,   4,  INSTDIR},
    {".double",     dir_data,   8,  INSTDIR},
    {".tfloat",     dir_data,   10, INSTDIR},
    /* section directives */
    {".bss",        dir_bss_section,    0,  INITIAL},
    {".data",       dir_data_section,   0,  INITIAL},
    {".text",       dir_text_section,   0,  INITIAL},
    {".section",    dir_section,        0, SECTION_DIRECTIVE},
    /* macro directives */
    {".rept",       dir_rept,   0,  INSTDIR},
    {".endr",       dir_endr,   0,  INSTDIR},
    /* empty space/fill directives */
    {".skip",       dir_skip,   0,  INSTDIR},
    {".space",      dir_skip,   0,  INSTDIR},
    {".fill",       dir_fill,   0,  INSTDIR},
    {".zero",       dir_zero,   0,  INSTDIR},
    /* other directives */
    {".equ",        dir_equ,    0,  INSTDIR},
    {".file",       dir_file,   0,  INSTDIR},
    {".line",       dir_line,   0,  INSTDIR},
    {".set",        dir_equ,    0,  INSTDIR}
};

static void
no_delete(void *data)
{
}

void
gas_parser_parse(yasm_parser_gas *parser_gas)
{
    dir_lookup word;
    unsigned int i;
    int replace = 1;

    word.name = ".word";
    word.handler = dir_data;
    word.param = yasm_arch_wordsize(p_object->arch)/8;
    word.newstate = INSTDIR;

    /* Create directive lookup */
    parser_gas->dirs = HAMT_create(1, yasm_internal_error_);
    HAMT_insert(parser_gas->dirs, word.name, &word, &replace, no_delete);
    for (i=0; i<NELEMS(dirs_static); i++) {
        replace = 1;
        HAMT_insert(parser_gas->dirs, dirs_static[i].name,
                    &dirs_static[i], &replace, no_delete);
    }

    while (get_next_token() != 0) {
        yasm_bytecode *bc = NULL, *temp_bc;

        if (!is_eol()) {
            bc = parse_line(parser_gas);
            demand_eol();
        }

        yasm_errwarn_propagate(parser_gas->errwarns, cur_line);

        temp_bc = yasm_section_bcs_append(cursect, bc);
        if (temp_bc)
            parser_gas->prev_bc = temp_bc;
        if (curtok == ';')
            continue;       /* don't advance line number until \n */
        if (parser_gas->save_input)
            yasm_linemap_add_source(parser_gas->linemap,
                temp_bc,
                (char *)parser_gas->save_line[parser_gas->save_last ^ 1]);
        yasm_linemap_goto_next(parser_gas->linemap);
        parser_gas->dir_line++; /* keep track for .line followed by .file */
    }

    HAMT_destroy(parser_gas->dirs, no_delete);
}
