static expression_t *gnu_get_oplist(asm86_t * a, int *pn, int deref)
/* Get a comma (or colon for jmpf and callf) separated list of instruction
* operands.
*/
{
expression_t *e, *o1, *o2;
token_t *t;
int sreg;
if ((e= gnu_get_operand(a, pn, deref)) == nil) return nil;
t = get_token(*pn);
if (t->symbol == ':' && IS_REGSEG(sreg = isregister(e->name))) {
a->seg = segreg2seg(sreg);
del_expr(e);
(*pn)++;
e = gnu_get_oplist(a, pn, deref);
}
else if (t->symbol == ',' || t->symbol == ':') {
o1= e;
(*pn)++;
if ((o2= gnu_get_oplist(a, pn, deref)) == nil) {
del_expr(o1);
return nil;
}
e= new_expr();
e->operator= ',';
e->left= o2;
e->right= o1;
}
return e;
}
void del_expr(expression_t *e)
/* Delete an expression tree. */
{
if (e != nil) {
assert(e->magic == 31624);
e->magic= 0;
deallocate(e->name);
del_expr(e->left);
del_expr(e->middle);
del_expr(e->right);
deallocate(e);
}
}
static void
unary_float(expr_t *expr, expr_t *uexp)
{
int iexp;
long ival;
double dval = uexp->data._unary.d;
switch (expr->token) {
case tok_plus: iexp = 0; break;
case tok_neg: iexp = 0; dval = -dval; break;
case tok_not: iexp = 1; ival = !dval; break;
case tok_com: error(expr, "not an integer");
default: error(expr, "internal error");
}
del_expr(uexp);
if (iexp) {
expr->data._unary.i = ival;
expr->token = tok_int;
}
else {
expr->data._unary.d = dval;
expr->token = tok_float;
}
}
static void
unary_sizeof(expr_t *expr)
{
tag_t *tag;
int size;
expr_t *uexp;
eval(expr->data._unary.expr);
uexp = expr->data._unary.expr;
switch (uexp->token) {
case tok_type:
tag = uexp->data._unary.vp;
size = tag->size;
break;
case tok_int:
size = sizeof(int);
break;
case tok_float:
size = sizeof(double);
break;
case tok_string:
size = strlen(uexp->data._unary.cp) + 1;
break;
default:
tag = eval_type(uexp);
size = tag->size;
break;
}
del_expr(uexp);
expr->token = tok_int;
expr->data._unary.i = size;
}
static void
binary_int(expr_t *expr, expr_t *lexp, expr_t *rexp)
{
long lval = lexp->data._unary.i;
long rval = rexp->data._unary.i;
switch (expr->token) {
case tok_andand: lval = lval && rval; break;
case tok_oror: lval = lval || rval; break;
case tok_lt: lval = lval < rval; break;
case tok_le: lval = lval <= rval; break;
case tok_eq: lval = lval == rval; break;
case tok_ge: lval = lval >= rval; break;
case tok_gt: lval = lval > rval; break;
case tok_ne: lval = lval != rval; break;
case tok_and: lval = lval & rval; break;
case tok_or: lval = lval | rval; break;
case tok_xor: lval = lval ^ rval; break;
case tok_lsh: lval = lval << rval; break;
case tok_rsh: lval = lval >> rval; break;
case tok_add: lval = lval + rval; break;
case tok_sub: lval = lval - rval; break;
case tok_mul: lval = lval * rval; break;
case tok_div:
if (rval == 0) {
warn(expr, "divide by zero");
return;
}
lval = lval / rval;
break;
case tok_rem:
if (rval == 0) {
warn(expr, "divide by zero");
return;
}
lval = lval % rval;
break;
default:
error(expr, "internal error");
}
del_expr(lexp);
del_expr(rexp);
expr->data._unary.i = lval;
expr->token = tok_int;
}
void
discard(void)
{
expr_t *expr = pop_expr();
if (expr)
del_expr(expr);
}
static void
binary_float(expr_t *expr, expr_t *lexp, expr_t *rexp)
{
int iexp;
long ival;
double lval = lexp->data._unary.d;
double rval = rexp->data._unary.d;
switch (expr->token) {
case tok_andand: iexp = 1; ival = lval && rval; break;
case tok_oror: iexp = 1; ival = lval || rval; break;
case tok_lt: iexp = 1; ival = lval < rval; break;
case tok_le: iexp = 1; ival = lval <= rval; break;
case tok_eq: iexp = 1; ival = lval == rval; break;
case tok_ge: iexp = 1; ival = lval >= rval; break;
case tok_gt: iexp = 1; ival = lval > rval; break;
case tok_ne: iexp = 1; ival = lval != rval; break;
case tok_and: case tok_or: case tok_xor:
case tok_lsh: case tok_rsh: case tok_rem:
error(expr, "not an integer");
case tok_add: iexp = 0; lval = lval + rval; break;
case tok_sub: iexp = 0; lval = lval - rval; break;
case tok_mul: iexp = 0; lval = lval * rval; break;
case tok_div:
if (rval == 0.0) {
warn(expr, "divide by zero");
return;
}
lval = lval / rval;
break;
default:
error(expr, "internal error");
}
del_expr(expr->data._binary.lvalue);
del_expr(expr->data._binary.rvalue);
if (iexp) {
expr->data._unary.i = ival;
expr->token = tok_int;
}
else {
expr->data._unary.d = lval;
expr->token = tok_float;
}
}
void del_asm86(asm86_t *a)
/* Delete an 80X86 instruction. */
{
assert(a != nil);
assert(a->magic == 37937);
a->magic= 0;
del_expr(a->args);
deallocate(a);
}
void
consume(void)
{
if (ahead) {
del_expr(ahead);
ahead = NULL;
}
else
error(NULL, "internal error");
}
void
del_stat(expr_t *expr)
{
expr_t *next;
while (expr) {
next = expr->next;
del_expr(expr);
expr = next;
}
}
static void
unary_int(expr_t *expr, expr_t *uexp)
{
long uval = uexp->data._unary.i;
switch (expr->token) {
case tok_plus: break;
case tok_neg: uval = -uval; break;
case tok_not: uval = !uval; break;
case tok_com: uval = ~uval; break;
default: error(expr, "internal error");
}
del_expr(uexp);
expr->data._unary.i = uval;
expr->token = tok_int;
}
static expression_t *ack_get_oplist(int *pn, int deref)
/* Get a comma (or colon for jmpf and callf) separated list of instruction
* operands.
*/
{
expression_t *e, *o1, *o2;
token_t *t;
if ((e= ack_get_operand(pn, deref)) == nil) return nil;
if ((t= get_token(*pn))->symbol == ',' || t->symbol == ':') {
o1= e;
(*pn)++;
if ((o2= ack_get_oplist(pn, deref)) == nil) {
del_expr(o1);
return nil;
}
e= new_expr();
e->operator= ',';
e->left= o1;
e->right= o2;
}
return e;
}
static expression_t *gnu_get_operand(asm86_t * a, int *pn, int deref)
/* Get something like: $immed, memory, offset(%base,%index,scale), or simpler. */
{
expression_t *e, *offset, *base, *index;
token_t *t;
int c;
if (get_token(*pn)->symbol == '$') {
/* An immediate value. */
(*pn)++;
return gnu_get_C_expression(pn);
}
if (get_token(*pn)->symbol == '*') {
(*pn)++;
deref = 1;
#if 0
if ((offset= gnu_get_operand(a, pn, deref)) == nil) return nil;
#if 0
e= new_expr();
e->operator= '(';
e->middle= offset;
return e;
#endif
return offset;
#endif
}
if ((get_token(*pn)->symbol == '%')
&& (t= get_token(*pn + 1))->type == T_WORD
&& isregister(t->name)
) {
/* A register operand. */
(*pn)+= 2;
e= new_expr();
e->operator= 'W';
e->name= copystr(t->name);
return e;
}
/* Offset? */
if (get_token(*pn)->symbol != '('
|| get_token(*pn + 1)->symbol != '%') {
/* There is an offset. */
if ((offset= gnu_get_C_expression(pn)) == nil) return nil;
} else {
/* No offset. */
offset= nil;
}
/* (%base,%index,scale) ? */
base= index= nil;
if (get_token(*pn)->symbol == '(') {
(*pn)++;
/* %base ? */
if (get_token(*pn)->symbol == '%'
&& (t= get_token(*pn + 1))->type == T_WORD
&& isregister(t->name)
) {
/* A base register expression. */
base= new_expr();
base->operator= 'B';
base->name= copystr(t->name);
(*pn)+= 2;
}
if (get_token(*pn)->symbol == ',') (*pn)++;
/* %index ? */
if (get_token(*pn)->symbol == '%'
&& (t= get_token(*pn + 1))->type == T_WORD
&& isregister(t->name)
) {
/* A index register expression. */
index= new_expr();
index->operator= '1'; /* for now */
index->name= copystr(t->name);
(*pn)+= 2;
}
if (get_token(*pn)->symbol == ',') (*pn)++;
/* scale ? */
if ((base != nil || index != nil)
&& (t= get_token(*pn))->type == T_WORD
&& strchr("1248", t->name[0]) != nil
&& t->name[1] == 0
) {
if (index == nil) {
/* Base is really an index register. */
index= base;
base= nil;
}
index->operator= t->name[0];
(*pn)++;
}
if (get_token(*pn)->symbol == ')') {
/* Ending paren. */
(*pn)++;
} else {
/* Alas. */
parse_err(1, t, "operand syntax error\n");
del_expr(offset);
del_expr(base);
del_expr(index);
return nil;
}
}
if (base == nil && index == nil) {
if (deref) {
/* Return a lone offset as (offset). */
e= new_expr();
e->operator= '(';
e->middle= offset;
} else {
/* Return a lone offset as is. */
e= offset;
}
} else {
e= new_expr();
e->operator= 'O';
e->left= offset;
e->middle= base;
e->right= index;
}
return e;
}
/*
* Implementation
*/
int
eval(expr_t *expr)
{
int test;
expr_t *prev;
expr_t *temp;
symbol_t *symbol;
switch (expr->token) {
case tok_set: case tok_andset:
case tok_orset: case tok_xorset:
case tok_lshset: case tok_rshset:
case tok_addset: case tok_subset:
case tok_mulset: case tok_divset:
case tok_remset: case tok_dot:
case tok_arrow:
eval(expr->data._binary.lvalue);
eval(expr->data._binary.rvalue);
break;
case tok_vector:
eval(expr->data._binary.lvalue);
if (expr->data._binary.rvalue)
eval(expr->data._binary.rvalue);
break;
case tok_andand: case tok_oror:
case tok_lt: case tok_le:
case tok_eq: case tok_ge:
case tok_gt: case tok_ne:
case tok_and: case tok_or:
case tok_xor: case tok_lsh:
case tok_rsh: case tok_add:
case tok_sub: case tok_mul:
case tok_div: case tok_rem:
binary(expr);
break;
case tok_inc: case tok_dec:
case tok_postinc: case tok_postdec:
case tok_pointer: case tok_elemref:
case tok_fieldref:
eval(expr->data._unary.expr);
break;
case tok_address:
eval(expr->data._unary.expr);
/* Remember address was taken, and only useful if argument
* is a register, otherwise, unused information */
/* FIXME if a symbol is declared as register, this should
* be an error, but register keyword not yet implemented */
temp = expr->data._unary.expr;
if (temp->token == tok_symbol) {
symbol = get_symbol(temp->data._unary.cp);
if (symbol && symbol->arg)
symbol->mem = 1;
}
break;
case tok_plus: case tok_neg:
case tok_not: case tok_com:
unary(expr);
break;
case tok_sizeof:
unary_sizeof(expr);
break;
case tok_question: case tok_if:
eval_stat(expr->data._if.test);
eval_stat(expr->data._if.tcode);
eval_stat(expr->data._if.fcode);
temp = prev = expr->data._if.test;
for (; temp->next; prev = temp, temp = temp->next)
;
switch (temp->token) {
case tok_int:
test = temp->data._unary.i != 0;
break;
case tok_float:
test = temp->data._unary.d != 0.0;
break;
default:
return (0);
}
if (test) {
del_expr(expr->data._if.fcode);
expr->data._if.fcode = NULL;
}
else {
del_expr(expr->data._if.tcode);
expr->data._if.tcode = expr->data._if.fcode;
expr->data._if.fcode = NULL;
}
if (prev != temp) {
prev->next = expr->data._if.tcode;
expr->data._unary.expr = expr->data._if.test;
}
else
expr->data._unary.expr = expr->data._if.tcode;
del_expr(temp);
expr->token = tok_stat;
break;
case tok_return:
if (expr->data._unary.expr)
eval(expr->data._unary.expr);
break;
case tok_switch:
eval_stat(expr->data._switch.test);
eval_stat(expr->data._switch.code);
break;
case tok_for:
eval_stat(expr->data._for.init);
eval_stat(expr->data._for.test);
eval_stat(expr->data._for.incr);
eval_stat(expr->data._for.code);
temp = prev = expr->data._do.test;
for (; temp->next; prev = temp, temp = temp->next)
;
switch (temp->token) {
case tok_int:
test = temp->data._unary.i != 0;
break;
case tok_float:
test = temp->data._unary.d != 0.0;
break;
default:
return (0);
}
if (test == 0) {
del_expr(expr->data._for.incr);
del_expr(expr->data._for.code);
if ((temp = expr->data._for.init)) {
for (; temp->next; temp = temp->next)
;
temp->next = expr->data._for.test;
expr->data._unary.expr = expr->data._for.init;
}
else
expr->data._unary.expr = expr->data._for.test;
expr->token = tok_stat;
}
break;
case tok_do:
eval_stat(expr->data._do.code);
eval_stat(expr->data._do.test);
temp = prev = expr->data._do.test;
for (; temp->next; prev = temp, temp = temp->next)
;
switch (temp->token) {
case tok_int:
test = temp->data._unary.i != 0;
break;
case tok_float:
test = temp->data._unary.d != 0.0;
break;
default:
return (0);
}
if (test == 0) {
for (temp = expr->data._do.code; temp->next; temp = temp->next)
;
temp->next = expr->data._do.test;
expr->data._unary.expr = expr->data._do.code;
expr->token = tok_stat;
}
break;
case tok_while:
eval_stat(expr->data._while.test);
eval_stat(expr->data._while.code);
temp = prev = expr->data._while.test;
for (; temp->next; prev = temp, temp = temp->next)
;
switch (temp->token) {
case tok_int:
test = temp->data._unary.i != 0;
break;
case tok_float:
test = temp->data._unary.d != 0.0;
break;
default:
return (0);
}
if (test == 0) {
del_expr(expr->data._while.code);
expr->data._unary.expr = expr->data._while.test;
expr->token = tok_stat;
}
break;
case tok_list:
temp = expr->data._unary.expr;
eval_stat(temp);
if (temp->next == NULL) {
memcpy(expr, temp, sizeof(expr_t));
temp->token = tok_none;
del_expr(temp);
}
break;
case tok_stat:
eval_stat(expr->data._unary.expr);
break;
case tok_call:
eval(expr->data._binary.lvalue);
eval_stat(expr->data._binary.rvalue);
break;
case tok_code: case tok_data:
eval_stat(expr->data._unary.expr);
break;
case tok_decl:
eval(expr->data._binary.lvalue);
eval_stat(expr->data._binary.rvalue);
break;
case tok_function:
current = expr->data._function.function->table;
eval(expr->data._function.type);
eval(expr->data._function.call);
eval(expr->data._function.body);
current = globals;
break;
default:
break;
}
return (0);
}
static asm86_t *ack_get_statement(void)
/* Get a pseudo op or machine instruction with arguments. */
{
token_t *t= get_token(0);
asm86_t *a;
mnemonic_t *m;
int n;
int prefix_seen;
int oaz_prefix;
int deref;
assert(t->type == T_WORD);
if (strcmp(t->name, ".sect") == 0) {
/* .sect .text etc. Accept only four segment names. */
skip_token(1);
t= get_token(0);
if (t->type != T_WORD || (
strcmp(t->name, ".text") != 0
&& strcmp(t->name, ".rom") != 0
&& strcmp(t->name, ".data") != 0
&& strcmp(t->name, ".bss") != 0
&& strcmp(t->name, ".end") != 0
)) {
parse_err(1, t, "weird section name to .sect\n");
return nil;
}
}
a= new_asm86();
/* Process instruction prefixes. */
oaz_prefix= 0;
for (prefix_seen= 0;; prefix_seen= 1) {
if (strcmp(t->name, "o16") == 0) {
if (use16()) {
parse_err(1, t, "o16 in an 8086 section\n");
}
oaz_prefix|= OPZ;
} else
if (strcmp(t->name, "o32") == 0) {
if (use32()) {
parse_err(1, t, "o32 in an 80386 section\n");
}
oaz_prefix|= OPZ;
} else
if (strcmp(t->name, "a16") == 0) {
if (use16()) {
parse_err(1, t, "a16 in an 8086 section\n");
}
oaz_prefix|= ADZ;
} else
if (strcmp(t->name, "a32") == 0) {
if (use32()) {
parse_err(1, t, "a32 in an 80386 section\n");
}
oaz_prefix|= ADZ;
} else
if (strcmp(t->name, "rep") == 0
|| strcmp(t->name, "repe") == 0
|| strcmp(t->name, "repne") == 0
|| strcmp(t->name, "repz") == 0
|| strcmp(t->name, "repnz") == 0
) {
if (a->rep != ONCE) {
parse_err(1, t,
"can't have more than one rep\n");
}
switch (t->name[3]) {
case 0: a->rep= REP; break;
case 'e':
case 'z': a->rep= REPE; break;
case 'n': a->rep= REPNE; break;
}
} else
if (strchr("cdefgs", t->name[0]) != nil
&& strcmp(t->name+1, "seg") == 0) {
if (a->seg != DEFSEG) {
parse_err(1, t,
"can't have more than one segment prefix\n");
}
switch (t->name[0]) {
case 'c': a->seg= CSEG; break;
case 'd': a->seg= DSEG; break;
case 'e': a->seg= ESEG; break;
case 'f': a->seg= FSEG; break;
case 'g': a->seg= GSEG; break;
case 's': a->seg= SSEG; break;
}
} else
if (!prefix_seen) {
/* No prefix here, get out! */
break;
} else {
/* No more prefixes, next must be an instruction. */
if (t->type != T_WORD
|| (m= search_mnem(t->name)) == nil
|| m->optype == PSEUDO
) {
parse_err(1, t,
"machine instruction expected after instruction prefix\n");
del_asm86(a);
return nil;
}
if (oaz_prefix != 0 && m->optype != JUMP
&& m->optype != WORD) {
parse_err(1, t,
"'%s' can't have an operand size prefix\n", m->name);
}
break;
}
/* Skip the prefix and extra newlines. */
do {
skip_token(1);
} while ((t= get_token(0))->symbol == ';');
}
/* All the readahead being done upsets the line counter. */
a->line= t->line;
/* Read a machine instruction or pseudo op. */
if ((m= search_mnem(t->name)) == nil) {
parse_err(1, t, "unknown instruction '%s'\n", t->name);
del_asm86(a);
return nil;
}
a->opcode= m->opcode;
a->optype= m->optype;
a->oaz= oaz_prefix;
switch (a->opcode) {
case IN:
case OUT:
case INT:
deref= 0;
break;
default:
deref= (a->optype >= BYTE);
}
n= 1;
if (get_token(1)->symbol != ';'
&& (a->args= ack_get_oplist(&n, deref)) == nil) {
del_asm86(a);
return nil;
}
if (get_token(n)->symbol != ';') {
parse_err(1, t, "garbage at end of instruction\n");
del_asm86(a);
return nil;
}
switch (a->opcode) {
case DOT_ALIGN:
/* Restrict .align to have a single numeric argument, some
* assemblers think of the argument as a power of two, so
* we need to be able to change the value.
*/
if (a->args == nil || a->args->operator != 'W'
|| !isanumber(a->args->name)) {
parse_err(1, t,
".align is restricted to one numeric argument\n");
del_asm86(a);
return nil;
}
break;
case JMPF:
case CALLF:
/* NCC jmpf off,seg -> ACK jmpf seg:off */
if (dialect == NCC && a->args != nil
&& a->args->operator == ',') {
expression_t *t;
t= a->args->left;
a->args->left= a->args->right;
a->args->right= t;
break;
}
/*FALL THROUGH*/
case JMP:
case CALL:
/* NCC jmp @(reg) -> ACK jmp (reg) */
if (dialect == NCC && a->args != nil && (
(a->args->operator == '('
&& a->args->middle != nil
&& a->args->middle->operator == 'O')
|| (a->args->operator == 'O'
&& a->args->left == nil
&& a->args->middle != nil
&& a->args->right == nil)
)) {
expression_t *t;
t= a->args;
a->args= a->args->middle;
t->middle= nil;
del_expr(t);
if (a->args->operator == 'B') a->args->operator= 'W';
}
break;
default:;
}
skip_token(n+1);
return a;
}
static expression_t *ack_get_operand(int *pn, int deref)
/* Get something like: (memory), offset(base)(index*scale), or simpler. */
{
expression_t *e, *offset, *base, *index;
token_t *t;
int c;
/* Is it (memory)? */
if (get_token(*pn)->symbol == '('
&& ((t= get_token(*pn + 1))->type != T_WORD
|| !isregister(t->name))
) {
/* A memory dereference. */
(*pn)++;
if ((offset= ack_get_C_expression(pn)) == nil) return nil;
if (get_token(*pn)->symbol != ')') {
parse_err(1, t, "operand syntax error\n");
del_expr(offset);
return nil;
}
(*pn)++;
e= new_expr();
e->operator= '(';
e->middle= offset;
return e;
}
/* #constant? */
if (dialect == NCC && deref
&& ((c= get_token(*pn)->symbol) == '#' || c == '*')) {
/* NCC: mov ax,#constant -> ACK: mov ax,constant */
(*pn)++;
return ack_get_C_expression(pn);
}
/* @address? */
if (dialect == NCC && get_token(*pn)->symbol == '@') {
/* NCC: jmp @address -> ACK: jmp (address) */
(*pn)++;
if ((offset= ack_get_operand(pn, deref)) == nil) return nil;
e= new_expr();
e->operator= '(';
e->middle= offset;
return e;
}
/* Offset? */
if (get_token(*pn)->symbol != '(') {
/* There is an offset. */
if ((offset= ack_get_C_expression(pn)) == nil) return nil;
} else {
/* No offset. */
offset= nil;
}
/* (base)? */
if (get_token(*pn)->symbol == '('
&& (t= get_token(*pn + 1))->type == T_WORD
&& isregister(t->name)
&& get_token(*pn + 2)->symbol == ')'
) {
/* A base register expression. */
base= new_expr();
base->operator= 'B';
base->name= copystr(t->name);
(*pn)+= 3;
} else {
/* No base register expression. */
base= nil;
}
/* (index*scale)? */
if (get_token(*pn)->symbol == '(') {
/* An index most likely. */
token_t *m= nil;
if (!( /* This must be true: */
(t= get_token(*pn + 1))->type == T_WORD
&& isregister(t->name)
&& (get_token(*pn + 2)->symbol == ')' || (
get_token(*pn + 2)->symbol == '*'
&& (m= get_token(*pn + 3))->type == T_WORD
&& strchr("1248", m->name[0]) != nil
&& m->name[1] == 0
&& get_token(*pn + 4)->symbol == ')'
))
)) {
/* Alas it isn't */
parse_err(1, t, "operand syntax error\n");
del_expr(offset);
del_expr(base);
return nil;
}
/* Found an index. */
index= new_expr();
index->operator= m == nil ? '1' : m->name[0];
index->name= copystr(t->name);
(*pn)+= (m == nil ? 3 : 5);
} else {
/* No index. */
index= nil;
}
if (dialect == NCC && deref && base == nil && index == nil
&& !(offset != nil && offset->operator == 'W'
&& isregister(offset->name))
) {
/* NCC: mov ax,thing -> ACK mov ax,(thing) */
e= new_expr();
e->operator= '(';
e->middle= offset;
return e;
}
if (base == nil && index == nil) {
/* Return a lone offset as is. */
e= offset;
} else {
e= new_expr();
e->operator= 'O';
e->left= offset;
e->middle= base;
e->right= index;
}
return e;
}
static expression_t *ack_get_C_expression(int *pn)
/* Read a "C-like" expression. Note that we don't worry about precedence,
* the expression is printed later like it is read. If the target language
* does not have all the operators (like ~) then this has to be repaired by
* changing the source file. (No problem, you still have one source file
* to maintain, not two.)
*/
{
expression_t *e, *a1, *a2;
token_t *t;
if ((t= get_token(*pn))->symbol == '[') {
/* [ expr ]: grouping. */
(*pn)++;
if ((a1= ack_get_C_expression(pn)) == nil) return nil;
if (get_token(*pn)->symbol != ']') {
parse_err(1, t, "missing ]\n");
del_expr(a1);
return nil;
}
(*pn)++;
e= new_expr();
e->operator= '[';
e->middle= a1;
} else
if (t->type == T_WORD || t->type == T_STRING) {
/* Label, number, or string. */
e= new_expr();
e->operator= t->type == T_WORD ? 'W' : 'S';
e->name= allocate(nil, (t->len+1) * sizeof(e->name[0]));
memcpy(e->name, t->name, t->len+1);
e->len= t->len;
(*pn)++;
} else
if (t->symbol == '+' || t->symbol == '-' || t->symbol == '~') {
/* Unary operator. */
(*pn)++;
if ((a1= ack_get_C_expression(pn)) == nil) return nil;
e= new_expr();
e->operator= t->symbol;
e->middle= a1;
} else {
parse_err(1, t, "expression syntax error\n");
return nil;
}
switch ((t= get_token(*pn))->symbol) {
case '+':
case '-':
case '*':
case '/':
case '%':
case '&':
case '|':
case '^':
case S_LEFTSHIFT:
case S_RIGHTSHIFT:
(*pn)++;
a1= e;
if ((a2= ack_get_C_expression(pn)) == nil) {
del_expr(a1);
return nil;
}
e= new_expr();
e->operator= t->symbol;
e->left= a1;
e->right= a2;
}
return e;
}
