-/* $Id: yasm.c,v 1.6 2001/08/19 02:15:18 peter Exp $
+/* $Id: yasm.c,v 1.7 2001/08/19 03:52:58 peter Exp $
* Program entry point, command line parsing
*
* Copyright (C) 2001 Peter Johnson
unsigned int mode_bits = 32;
int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
{
FILE *in;
- if(argc==2) {
+ if (argc == 2) {
in = fopen(argv[1], "rt");
- if(!in) {
+ if (!in) {
fprintf(stderr, "could not open file `%s'\n", argv[1]);
return EXIT_FAILURE;
}
nasm_parser.doparse(&raw_preproc, &dbg_outfmt, in);
- if(filename)
+ if (filename)
free(filename);
return EXIT_SUCCESS;
}
-
-/* $Id: bytecode.c,v 1.15 2001/08/18 22:15:12 peter Exp $
+/* $Id: bytecode.c,v 1.16 2001/08/19 03:52:58 peter Exp $
* Bytecode utility functions
*
* Copyright (C) 2001 Peter Johnson
/* Static structures for when NULL is passed to conversion functions. */
/* for Convert*ToEA() */
static effaddr eff_static;
+
/* for Convert*ToImm() */
static immval im_static;
+
/* for Convert*ToBytes() */
unsigned char bytes_static[16];
static void BuildBC_Common(bytecode *bc);
effaddr *
-ConvertRegToEA (effaddr *ptr, unsigned long reg)
+ConvertRegToEA(effaddr *ptr, unsigned long reg)
{
- if(!ptr)
+ if (!ptr)
ptr = &eff_static;
ptr->len = 0;
ptr->segment = 0;
- ptr->modrm = 0xC0 | (reg & 0x07); /* Mod=11, R/M=Reg, Reg=0 */
+ ptr->modrm = 0xC0 | (reg & 0x07); /* Mod=11, R/M=Reg, Reg=0 */
ptr->valid_modrm = 1;
ptr->need_modrm = 1;
ptr->valid_sib = 0;
}
effaddr *
-ConvertExprToEA (effaddr *ptr, expr *expr_ptr)
+ConvertExprToEA(effaddr *ptr, expr *expr_ptr)
{
- if(!ptr)
+ if (!ptr)
ptr = &eff_static;
ptr->segment = 0;
}
effaddr *
-ConvertImmToEA (effaddr *ptr, immval *im_ptr, unsigned char im_len)
+ConvertImmToEA(effaddr *ptr, immval *im_ptr, unsigned char im_len)
{
- if(!ptr)
+ if (!ptr)
ptr = &eff_static;
ptr->disp = im_ptr->val;
- if(im_ptr->len > im_len)
+ if (im_ptr->len > im_len)
Warning(WARN_VALUE_EXCEEDS_BOUNDS, (char *)NULL, "word");
ptr->len = im_len;
ptr->segment = 0;
}
immval *
-ConvertIntToImm (immval *ptr, unsigned long int_val)
+ConvertIntToImm(immval *ptr, unsigned long int_val)
{
- if(!ptr)
+ if (!ptr)
ptr = &im_static;
/* FIXME: this will leak expr's if static is used */
ptr->val = expr_new_ident(EXPR_NUM, ExprNum(int_val));
- if((int_val & 0xFF) == int_val)
+ if ((int_val & 0xFF) == int_val)
ptr->len = 1;
- else if((int_val & 0xFFFF) == int_val)
+ else if ((int_val & 0xFFFF) == int_val)
ptr->len = 2;
else
ptr->len = 4;
}
immval *
-ConvertExprToImm (immval *ptr, expr *expr_ptr)
+ConvertExprToImm(immval *ptr, expr *expr_ptr)
{
- if(!ptr)
+ if (!ptr)
ptr = &im_static;
ptr->val = expr_ptr;
}
void
-SetEASegment (effaddr *ptr, unsigned char segment)
+SetEASegment(effaddr *ptr, unsigned char segment)
{
- if(!ptr)
+ if (!ptr)
return;
- if(ptr->segment != 0)
+ if (ptr->segment != 0)
Warning(WARN_MULT_SEG_OVERRIDE, (char *)NULL);
ptr->segment = segment;
}
void
-SetEALen (effaddr *ptr, unsigned char len)
+SetEALen(effaddr *ptr, unsigned char len)
{
- if(!ptr)
+ if (!ptr)
return;
/* Currently don't warn if length truncated, as this is called only from
}
void
-SetInsnOperSizeOverride (bytecode *bc, unsigned char opersize)
+SetInsnOperSizeOverride(bytecode *bc, unsigned char opersize)
{
- if(!bc)
+ if (!bc)
return;
- switch(bc->type) {
+ switch (bc->type) {
case BC_INSN:
bc->data.insn.opersize = opersize;
break;
break;
default:
InternalError(__LINE__, __FILE__,
- "OperSize override applied to non-instruction");
+ "OperSize override applied to non-instruction");
return;
}
}
void
-SetInsnAddrSizeOverride (bytecode *bc, unsigned char addrsize)
+SetInsnAddrSizeOverride(bytecode *bc, unsigned char addrsize)
{
- if(!bc)
+ if (!bc)
return;
- switch(bc->type) {
+ switch (bc->type) {
case BC_INSN:
bc->data.insn.addrsize = addrsize;
break;
break;
default:
InternalError(__LINE__, __FILE__,
- "AddrSize override applied to non-instruction");
+ "AddrSize override applied to non-instruction");
return;
}
}
void
-SetInsnLockRepPrefix (bytecode *bc, unsigned char prefix)
+SetInsnLockRepPrefix(bytecode *bc, unsigned char prefix)
{
unsigned char *lockrep_pre = (unsigned char *)NULL;
- if(!bc)
+ if (!bc)
return;
- switch(bc->type) {
+ switch (bc->type) {
case BC_INSN:
lockrep_pre = &bc->data.insn.lockrep_pre;
break;
break;
default:
InternalError(__LINE__, __FILE__,
- "LockRep prefix applied to non-instruction");
+ "LockRep prefix applied to non-instruction");
return;
}
- if(*lockrep_pre != 0)
+ if (*lockrep_pre != 0)
Warning(WARN_MULT_LOCKREP_PREFIX, (char *)NULL);
*lockrep_pre = prefix;
}
void
-SetOpcodeSel (jmprel_opcode_sel *old_sel, jmprel_opcode_sel new_sel)
+SetOpcodeSel(jmprel_opcode_sel *old_sel, jmprel_opcode_sel new_sel)
{
- if(!old_sel)
+ if (!old_sel)
return;
- if((*old_sel == JR_SHORT_FORCED) || (*old_sel == JR_NEAR_FORCED))
+ if ((*old_sel == JR_SHORT_FORCED) || (*old_sel == JR_NEAR_FORCED))
Warning(WARN_MULT_SHORTNEAR, (char *)NULL);
*old_sel = new_sel;
}
static void
-BuildBC_Common (bytecode *bc)
+BuildBC_Common(bytecode *bc)
{
bc->len = 0;
}
void
-BuildBC_Insn (bytecode *bc,
- unsigned char opersize,
- unsigned char opcode_len,
- unsigned char op0,
- unsigned char op1,
- unsigned char op2,
- effaddr *ea_ptr,
- unsigned char spare,
- immval *im_ptr,
- unsigned char im_len,
- unsigned char im_sign)
+BuildBC_Insn(bytecode *bc,
+ unsigned char opersize,
+ unsigned char opcode_len,
+ unsigned char op0,
+ unsigned char op1,
+ unsigned char op2,
+ effaddr *ea_ptr,
+ unsigned char spare,
+ immval *im_ptr,
+ unsigned char im_len,
+ unsigned char im_sign)
{
bc->next = (bytecode *)NULL;
bc->type = BC_INSN;
- if(ea_ptr) {
+ if (ea_ptr) {
bc->data.insn.ea = *ea_ptr;
- bc->data.insn.ea.modrm &= 0xC7; /* zero spare/reg bits */
+ bc->data.insn.ea.modrm &= 0xC7; /* zero spare/reg bits */
bc->data.insn.ea.modrm |= (spare << 3) & 0x38; /* plug in provided bits */
} else {
bc->data.insn.ea.len = 0;
bc->data.insn.ea.need_sib = 0;
}
- if(im_ptr) {
+ if (im_ptr) {
bc->data.insn.imm = *im_ptr;
bc->data.insn.imm.f_sign = im_sign;
bc->data.insn.imm.f_len = im_len;
}
void
-BuildBC_JmpRel (bytecode *bc,
- targetval *target,
- unsigned char short_valid,
- unsigned char short_opcode_len,
- unsigned char short_op0,
- unsigned char short_op1,
- unsigned char short_op2,
- unsigned char near_valid,
- unsigned char near_opcode_len,
- unsigned char near_op0,
- unsigned char near_op1,
- unsigned char near_op2,
- unsigned char addrsize)
+BuildBC_JmpRel(bytecode *bc,
+ targetval *target,
+ unsigned char short_valid,
+ unsigned char short_opcode_len,
+ unsigned char short_op0,
+ unsigned char short_op1,
+ unsigned char short_op2,
+ unsigned char near_valid,
+ unsigned char near_opcode_len,
+ unsigned char near_op0,
+ unsigned char near_op1,
+ unsigned char near_op2,
+ unsigned char addrsize)
{
bc->next = (bytecode *)NULL;
bc->type = BC_JMPREL;
bc->data.jmprel.target = target->val;
bc->data.jmprel.op_sel = target->op_sel;
- if((target->op_sel == JR_SHORT_FORCED) && (!short_valid))
+ if ((target->op_sel == JR_SHORT_FORCED) && (!short_valid))
Error(ERR_NO_JMPREL_FORM, (char *)NULL, "SHORT");
- if((target->op_sel == JR_NEAR_FORCED) && (!near_valid))
+ if ((target->op_sel == JR_NEAR_FORCED) && (!near_valid))
Error(ERR_NO_JMPREL_FORM, (char *)NULL, "NEAR");
bc->data.jmprel.shortop.valid = short_valid;
- if(short_valid) {
+ if (short_valid) {
bc->data.jmprel.shortop.opcode[0] = short_op0;
bc->data.jmprel.shortop.opcode[1] = short_op1;
bc->data.jmprel.shortop.opcode[2] = short_op2;
}
bc->data.jmprel.nearop.valid = near_valid;
- if(near_valid) {
+ if (near_valid) {
bc->data.jmprel.nearop.opcode[0] = near_op0;
bc->data.jmprel.nearop.opcode[1] = near_op1;
bc->data.jmprel.nearop.opcode[2] = near_op2;
}
void
-BuildBC_Data (bytecode *bc,
- dataval *data,
- unsigned long size)
+BuildBC_Data(bytecode *bc, dataval *data, unsigned long size)
{
dataval *cur = data;
* constants (equ's) should always be legal, but labels should raise
* warnings when used in db or dq context at the minimum).
*/
- while(cur) {
- switch(cur->type) {
+ while (cur) {
+ switch (cur->type) {
case DV_EMPTY:
case DV_STRING:
/* string is valid in every size */
break;
case DV_FLOAT:
- if(size == 1)
+ if (size == 1)
Error(ERR_DECLDATA_FLOAT, (char *)NULL, "DB");
- else if(size == 2)
+ else if (size == 2)
Error(ERR_DECLDATA_FLOAT, (char *)NULL, "DW");
break;
case DV_EXPR:
- if(size == 10)
+ if (size == 10)
Error(ERR_DECLDATA_EXPR, (char *)NULL, "DT");
break;
}
}
void
-BuildBC_Reserve (bytecode *bc,
- expr *numitems,
- unsigned long itemsize)
+BuildBC_Reserve(bytecode *bc, expr *numitems, unsigned long itemsize)
{
bc->next = (bytecode *)NULL;
bc->type = BC_RESERVE;
}
void
-DebugPrintBC (bytecode *bc)
+DebugPrintBC(bytecode *bc)
{
- switch(bc->type) {
+ switch (bc->type) {
case BC_EMPTY:
printf("_Empty_\n");
break;
else
expr_print(bc->data.insn.ea.disp);
printf("\n");
- printf (" Len=%u SegmentOv=%2x\n",
- (unsigned int)bc->data.insn.ea.len,
- (unsigned int)bc->data.insn.ea.segment);
+ printf(" Len=%u SegmentOv=%2x\n",
+ (unsigned int)bc->data.insn.ea.len,
+ (unsigned int)bc->data.insn.ea.segment);
printf(" ModRM=%2x ValidRM=%u NeedRM=%u\n",
- (unsigned int)bc->data.insn.ea.modrm,
- (unsigned int)bc->data.insn.ea.valid_modrm,
- (unsigned int)bc->data.insn.ea.need_modrm);
+ (unsigned int)bc->data.insn.ea.modrm,
+ (unsigned int)bc->data.insn.ea.valid_modrm,
+ (unsigned int)bc->data.insn.ea.need_modrm);
printf(" SIB=%2x ValidSIB=%u NeedSIB=%u\n",
- (unsigned int)bc->data.insn.ea.sib,
- (unsigned int)bc->data.insn.ea.valid_sib,
- (unsigned int)bc->data.insn.ea.need_sib);
+ (unsigned int)bc->data.insn.ea.sib,
+ (unsigned int)bc->data.insn.ea.valid_sib,
+ (unsigned int)bc->data.insn.ea.need_sib);
printf("Immediate Value:\n");
printf(" Val=");
if (!bc->data.insn.imm.val)
expr_print(bc->data.insn.imm.val);
printf("\n");
printf(" Len=%u, IsNeg=%u\n",
- (unsigned int)bc->data.insn.imm.len,
- (unsigned int)bc->data.insn.imm.isneg);
+ (unsigned int)bc->data.insn.imm.len,
+ (unsigned int)bc->data.insn.imm.isneg);
printf(" FLen=%u, FSign=%u\n",
- (unsigned int)bc->data.insn.imm.f_len,
- (unsigned int)bc->data.insn.imm.f_sign);
+ (unsigned int)bc->data.insn.imm.f_len,
+ (unsigned int)bc->data.insn.imm.f_sign);
printf("Opcode: %2x %2x %2x OpLen=%u\n",
- (unsigned int)bc->data.insn.opcode[0],
- (unsigned int)bc->data.insn.opcode[1],
- (unsigned int)bc->data.insn.opcode[2],
- (unsigned int)bc->data.insn.opcode_len);
+ (unsigned int)bc->data.insn.opcode[0],
+ (unsigned int)bc->data.insn.opcode[1],
+ (unsigned int)bc->data.insn.opcode[2],
+ (unsigned int)bc->data.insn.opcode_len);
printf("AddrSize=%u OperSize=%u LockRepPre=%2x\n",
- (unsigned int)bc->data.insn.addrsize,
- (unsigned int)bc->data.insn.opersize,
- (unsigned int)bc->data.insn.lockrep_pre);
+ (unsigned int)bc->data.insn.addrsize,
+ (unsigned int)bc->data.insn.opersize,
+ (unsigned int)bc->data.insn.lockrep_pre);
break;
case BC_JMPREL:
printf("_Relative Jump_\n");
printf("Target=");
expr_print(bc->data.jmprel.target);
printf("\nShort Form:\n");
- if(!bc->data.jmprel.shortop.valid)
+ if (!bc->data.jmprel.shortop.valid)
printf(" None\n");
else
printf(" Opcode: %2x %2x %2x OpLen=%u\n",
- (unsigned int)bc->data.jmprel.shortop.opcode[0],
- (unsigned int)bc->data.jmprel.shortop.opcode[1],
- (unsigned int)bc->data.jmprel.shortop.opcode[2],
- (unsigned int)bc->data.jmprel.shortop.opcode_len);
- if(!bc->data.jmprel.nearop.valid)
+ (unsigned int)bc->data.jmprel.shortop.opcode[0],
+ (unsigned int)bc->data.jmprel.shortop.opcode[1],
+ (unsigned int)bc->data.jmprel.shortop.opcode[2],
+ (unsigned int)bc->data.jmprel.shortop.opcode_len);
+ if (!bc->data.jmprel.nearop.valid)
printf(" None\n");
else
printf(" Opcode: %2x %2x %2x OpLen=%u\n",
- (unsigned int)bc->data.jmprel.nearop.opcode[0],
- (unsigned int)bc->data.jmprel.nearop.opcode[1],
- (unsigned int)bc->data.jmprel.nearop.opcode[2],
- (unsigned int)bc->data.jmprel.nearop.opcode_len);
+ (unsigned int)bc->data.jmprel.nearop.opcode[0],
+ (unsigned int)bc->data.jmprel.nearop.opcode[1],
+ (unsigned int)bc->data.jmprel.nearop.opcode[2],
+ (unsigned int)bc->data.jmprel.nearop.opcode_len);
printf("OpSel=");
- switch(bc->data.jmprel.op_sel) {
- case JR_NONE: printf("None"); break;
- case JR_SHORT: printf("Short"); break;
- case JR_NEAR: printf("Near"); break;
- case JR_SHORT_FORCED: printf("Forced Short"); break;
- case JR_NEAR_FORCED: printf("Forced Near"); break;
- default: printf("UNKNOWN!!"); break;
+ switch (bc->data.jmprel.op_sel) {
+ case JR_NONE:
+ printf("None");
+ break;
+ case JR_SHORT:
+ printf("Short");
+ break;
+ case JR_NEAR:
+ printf("Near");
+ break;
+ case JR_SHORT_FORCED:
+ printf("Forced Short");
+ break;
+ case JR_NEAR_FORCED:
+ printf("Forced Near");
+ break;
+ default:
+ printf("UNKNOWN!!");
+ break;
}
printf("\nAddrSize=%u OperSize=%u LockRepPre=%2x\n",
- (unsigned int)bc->data.jmprel.addrsize,
- (unsigned int)bc->data.jmprel.opersize,
- (unsigned int)bc->data.jmprel.lockrep_pre);
+ (unsigned int)bc->data.jmprel.addrsize,
+ (unsigned int)bc->data.jmprel.opersize,
+ (unsigned int)bc->data.jmprel.lockrep_pre);
break;
case BC_DATA:
printf("_Data_\n");
printf("Final Element Size=%u\n",
- (unsigned int)bc->data.data.size);
+ (unsigned int)bc->data.data.size);
printf("Elements:\n");
dataval_print(bc->data.data.data);
break;
printf("Num Items=");
expr_print(bc->data.reserve.numitems);
printf("\nItem Size=%u\n",
- (unsigned int)bc->data.reserve.itemsize);
+ (unsigned int)bc->data.reserve.itemsize);
break;
default:
printf("_Unknown_\n");
}
printf("Length=%lu\n", bc->len);
printf("Filename=\"%s\" Line Number=%u\n",
- bc->filename ? bc->filename : "<UNKNOWN>", bc->lineno);
+ bc->filename ? bc->filename : "<UNKNOWN>", bc->lineno);
printf("Offset=%lx BITS=%u\n", bc->offset, bc->mode_bits);
}
dataval *
-dataval_new_expr (expr *exp)
+dataval_new_expr(expr *exp)
{
dataval *retval = malloc(sizeof(dataval));
- if(!retval)
+ if (!retval)
Fatal(FATAL_NOMEM);
retval->next = (dataval *)NULL;
}
dataval *
-dataval_new_float (double float_val)
+dataval_new_float(double float_val)
{
dataval *retval = malloc(sizeof(dataval));
- if(!retval)
+ if (!retval)
Fatal(FATAL_NOMEM);
retval->next = (dataval *)NULL;
}
dataval *
-dataval_new_string (char *str_val)
+dataval_new_string(char *str_val)
{
dataval *retval = malloc(sizeof(dataval));
- if(!retval)
+ if (!retval)
Fatal(FATAL_NOMEM);
retval->next = (dataval *)NULL;
}
dataval *
-dataval_append (dataval *list, dataval *item)
+dataval_append(dataval *list, dataval *item)
{
- if(item)
+ if (item)
item->next = (dataval *)NULL;
- if(!list) {
+ if (!list) {
item->last = item;
return item;
} else {
- if(item) {
+ if (item) {
list->last->next = item;
list->last = item;
item->last = (dataval *)NULL;
}
void
-dataval_print (dataval *start)
+dataval_print(dataval *start)
{
dataval *cur = start;
- while(cur) {
- switch(cur->type) {
+ while (cur) {
+ switch (cur->type) {
case DV_EMPTY:
printf(" Empty\n");
break;
cur = cur->next;
}
}
-
-/* $Id: bytecode.h,v 1.15 2001/07/25 00:33:10 peter Exp $
+/* $Id: bytecode.h,v 1.16 2001/08/19 03:52:58 peter Exp $
* Bytecode utility functions header file
*
* Copyright (C) 2001 Peter Johnson
union {
struct {
- effaddr ea; /* effective address */
+ effaddr ea; /* effective address */
- immval imm; /* immediate or relative value */
+ immval imm; /* immediate or relative value */
unsigned char opcode[3]; /* opcode */
unsigned char opcode_len;
unsigned char lockrep_pre; /* 0 indicates no prefix */
} jmprel;
struct {
- dataval *data; /* non-converted data (linked list) */
+ dataval *data; /* non-converted data (linked list) */
/* final (converted) size of each element (in bytes) */
unsigned char size;
} reserve;
} data;
- unsigned long len; /* total length of entire bytecode */
+ unsigned long len; /* total length of entire bytecode */
/* where it came from */
char *filename;
unsigned char near_op2,
unsigned char addrsize);
-void BuildBC_Data(bytecode *bc,
- dataval *data,
- unsigned long size);
+void BuildBC_Data(bytecode *bc, dataval *data, unsigned long size);
void BuildBC_Reserve(bytecode *bc,
struct expr_s *numitems,
-/* $Id: errwarn.c,v 1.19 2001/08/18 23:05:37 peter Exp $
+/* $Id: errwarn.c,v 1.20 2001/08/19 03:52:58 peter Exp $
* Error and warning reporting and related functions.
*
* Copyright (C) 2001 Peter Johnson
/* Convert a possibly unprintable character into a printable string, using
* standard cat(1) convention for unprintable characters. */
char *
-conv_unprint (char ch)
+conv_unprint(char ch)
{
- int pos=0;
+ int pos = 0;
- if(((ch & ~0x7F) != 0)/*!isascii(ch)*/ && !isprint(ch)) {
+ if (((ch & ~0x7F) != 0) /*!isascii(ch)*/ && !isprint(ch)) {
unprint[pos++] = 'M';
unprint[pos++] = '-';
ch &= toascii(ch);
}
- if(iscntrl(ch)) {
+ if (iscntrl(ch)) {
unprint[pos++] = '^';
unprint[pos++] = (ch == '\177') ? '?' : ch | 0100;
} else
/* Parser error handler. Moves error into our error handling system. */
void
-yyerror (char *s)
+yyerror(char *s)
{
Error(ERR_PARSER, (char *)NULL, s);
}
/* Report an internal error. Essentially a fatal error with trace info.
* Exit immediately because it's essentially an assert() trap. */
void
-InternalError (unsigned int line, char *file, char *message)
+InternalError(unsigned int line, char *file, char *message)
{
fprintf(stderr, "INTERNAL ERROR at %s, line %d: %s\n", file, line,
- message);
+ message);
exit(EXIT_FAILURE);
}
/* Report a fatal error. These are unrecoverable (such as running out of
* memory), so just exit immediately. */
void
-Fatal (fatal_num num)
+Fatal(fatal_num num)
{
fprintf(stderr, "FATAL: %s\n", fatal_msgs[num]);
exit(EXIT_FAILURE);
* specified and NULL passed for the argtypes parameter when Error() is
* called. */
static char *
-process_argtypes (char *src, char *argtypes)
+process_argtypes(char *src, char *argtypes)
{
char *dest;
char *argtype[9];
int at_num;
char *destp, *srcp, *argtypep;
- if(argtypes) {
+ if (argtypes) {
dest = malloc(strlen(src) + strlen(argtypes));
- if(!dest)
+ if (!dest)
Fatal(FATAL_NOMEM);
/* split argtypes by % */
at_num = 0;
- while((argtypes = strchr(argtypes, '%')) && at_num < 9)
+ while ((argtypes = strchr(argtypes, '%')) && at_num < 9)
argtype[at_num++] = ++argtypes;
/* search through src for %, copying as we go */
destp = dest;
srcp = src;
- while(*srcp != '\0') {
+ while (*srcp != '\0') {
*(destp++) = *srcp;
- if(*(srcp++) == '%') {
- if(isdigit(*srcp)) {
+ if (*(srcp++) == '%') {
+ if (isdigit(*srcp)) {
/* %1, %2, etc */
- argtypep = argtype[*srcp-'1'];
- while((*argtypep != '%') && (*argtypep != '\0'))
+ argtypep = argtype[*srcp - '1'];
+ while ((*argtypep != '%') && (*argtypep != '\0'))
*(destp++) = *(argtypep++);
} else
*(destp++) = *srcp;
}
} else {
dest = strdup(src);
- if(!dest)
+ if (!dest)
Fatal(FATAL_NOMEM);
}
return dest;
* argument types. Does not print the error, only stores it for
* OutputError() to print. */
void
-Error (err_num num, char *argtypes, ...)
+Error(err_num num, char *argtypes, ...)
{
va_list ap;
char *printf_str;
- if((last_err_num != ERR_NONE) && (last_err_num != ERR_PARSER))
+ if ((last_err_num != ERR_NONE) && (last_err_num != ERR_PARSER))
return;
last_err_num = num;
* argument types. Does not print the warning, only stores it for
* OutputWarning() to print. */
void
-Warning (warn_num num, char *argtypes, ...)
+Warning(warn_num num, char *argtypes, ...)
{
va_list ap;
char *printf_str;
- if(last_warn_num != WARN_NONE)
+ if (last_warn_num != WARN_NONE)
return;
last_warn_num = num;
/* Output a previously stored error (if any) to stderr. */
void
-OutputError (void)
+OutputError(void)
{
- if(last_err_num != ERR_NONE)
+ if (last_err_num != ERR_NONE)
fprintf(stderr, "%s:%u: %s\n", filename, line_number, last_err);
last_err_num = ERR_NONE;
}
/* Output a previously stored warning (if any) to stderr. */
void
-OutputWarning (void)
+OutputWarning(void)
{
- if(last_warn_num != WARN_NONE)
+ if (last_warn_num != WARN_NONE)
fprintf(stderr, "%s:%u: warning: %s\n", filename, line_number,
- last_warn);
+ last_warn);
last_warn_num = WARN_NONE;
}
-
-/* $Id: expr.c,v 1.4 2001/07/11 23:16:50 peter Exp $
+/* $Id: expr.c,v 1.5 2001/08/19 03:52:58 peter Exp $
* Expression handling
*
* Copyright (C) 2001 Michael Urman
/* allocate a new expression node, with children as defined.
* If it's a unary operator, put the element on the right */
expr *
-expr_new (ExprType ltype,
- ExprItem left,
- ExprOp op,
- ExprType rtype,
- ExprItem right)
+expr_new(ExprType ltype,
+ ExprItem left,
+ ExprOp op,
+ ExprType rtype,
+ ExprItem right)
{
expr *ptr;
- ptr = malloc (sizeof (expr));
- if (ptr == NULL) Fatal (FATAL_NOMEM);
+ ptr = malloc(sizeof(expr));
+ if (ptr == NULL)
+ Fatal(FATAL_NOMEM);
ptr->ltype = ltype;
ptr->op = op;
ptr->rtype = rtype;
- switch (ltype)
- {
+ switch (ltype) {
case EXPR_NUM:
case EXPR_SYM:
case EXPR_EXPR:
- memcpy (&ptr->left, &left, sizeof (ExprItem));
+ memcpy(&ptr->left, &left, sizeof(ExprItem));
+ break;
+ case EXPR_NONE:
break;
- case EXPR_NONE: break;
}
- switch (rtype)
- {
+ switch (rtype) {
case EXPR_NUM:
case EXPR_SYM:
case EXPR_EXPR:
- memcpy (&ptr->right, &right, sizeof (ExprItem));
+ memcpy(&ptr->right, &right, sizeof(ExprItem));
break;
case EXPR_NONE:
- Fatal (FATAL_UNKNOWN); /* TODO: better error? */
+ Fatal(FATAL_UNKNOWN); /* TODO: better error? */
break;
}
return ptr;
/* helpers */
ExprItem
-ExprSym (struct symrec_s *s)
+ExprSym(struct symrec_s *s)
{
ExprItem e;
+
e.sym = s;
return e;
}
ExprItem
-ExprExpr (expr *x)
+ExprExpr(expr *x)
{
ExprItem e;
e.expr = x;
+
return e;
}
ExprItem
-ExprNum (unsigned long n)
+ExprNum(unsigned long n)
{
ExprItem e;
+
e.num = n;
return e;
}
ExprItem
-ExprNone (void)
+ExprNone(void)
{
ExprItem e;
+
e.num = 0;
return e;
}
/* get rid of unnecessary branches if possible. report. */
int
-expr_simplify (expr *e)
+expr_simplify(expr *e)
{
int simplified = 0;
/* try to simplify the left side */
- if (e->ltype == EXPR_EXPR)
- {
+ if (e->ltype == EXPR_EXPR) {
/* if the left subexpr isn't an IDENT, recurse simplification */
if (e->left.expr->op != EXPR_IDENT)
- simplified |= expr_simplify (e->left.expr);
+ simplified |= expr_simplify(e->left.expr);
/* if the left subexpr is just an IDENT (or string thereof),
* pull it up into the current node */
- while (e->ltype == EXPR_EXPR && e->left.expr->op == EXPR_IDENT)
- {
+ while (e->ltype == EXPR_EXPR && e->left.expr->op == EXPR_IDENT) {
ExprItem tmp;
e->ltype = e->left.expr->rtype;
- memcpy (&tmp, &(e->left.expr->right), sizeof (ExprItem));
- free (e->left.expr);
- memcpy (&(e->left.num), &tmp, sizeof (ExprItem));
+ memcpy(&tmp, &(e->left.expr->right), sizeof(ExprItem));
+ free(e->left.expr);
+ memcpy(&(e->left.num), &tmp, sizeof(ExprItem));
simplified = 1;
}
- }
- else if (e->ltype == EXPR_SYM)
- {
+ } else if (e->ltype == EXPR_SYM) {
/* if it's a symbol that has a defined value, turn it into a
* number */
- if (e->left.sym->status & SYM_VALUED)
- {
+ if (e->left.sym->status & SYM_VALUED) {
e->ltype = EXPR_NUM;
/* don't try to free the symrec here. */
e->left.num = e->left.sym->value;
}
/* ditto on the right */
- if (e->rtype == EXPR_EXPR)
- {
+ if (e->rtype == EXPR_EXPR) {
if (e->right.expr->op != EXPR_IDENT)
- simplified |= expr_simplify (e->right.expr);
+ simplified |= expr_simplify(e->right.expr);
- while (e->rtype == EXPR_EXPR && e->right.expr->op == EXPR_IDENT)
- {
+ while (e->rtype == EXPR_EXPR && e->right.expr->op == EXPR_IDENT) {
ExprItem tmp;
e->rtype = e->right.expr->rtype;
- memcpy (&tmp, &(e->right.expr->right), sizeof (ExprItem));
- free (e->right.expr);
- memcpy (&(e->right.num), &tmp, sizeof (ExprItem));
+ memcpy(&tmp, &(e->right.expr->right), sizeof(ExprItem));
+ free(e->right.expr);
+ memcpy(&(e->right.num), &tmp, sizeof(ExprItem));
simplified = 1;
}
- }
- else if (e->rtype == EXPR_SYM)
- {
- if (e->right.sym->status & SYM_VALUED)
- {
+ } else if (e->rtype == EXPR_SYM) {
+ if (e->right.sym->status & SYM_VALUED) {
e->rtype = EXPR_NUM;
/* don't try to free the symrec here. */
e->right.num = e->right.sym->value;
}
if ((e->ltype == EXPR_NUM || e->ltype == EXPR_NONE)
- && e->rtype == EXPR_NUM
- && e->op != EXPR_IDENT)
- {
- switch (e->op)
- {
- case EXPR_ADD: e->right.num = e->left.num + e->right.num; break;
- case EXPR_SUB: e->right.num = e->left.num - e->right.num; break;
- case EXPR_MUL: e->right.num = e->left.num * e->right.num; break;
- case EXPR_DIV: e->right.num = e->left.num / e->right.num; break;
- case EXPR_MOD: e->right.num = e->left.num % e->right.num; break;
- case EXPR_NEG: e->right.num = -(e->right.num); break;
- case EXPR_NOT: e->right.num = ~(e->right.num); break;
- case EXPR_OR: e->right.num = e->left.num | e->right.num; break;
- case EXPR_AND: e->right.num = e->left.num & e->right.num; break;
- case EXPR_XOR: e->right.num = e->left.num ^ e->right.num; break;
- case EXPR_SHL: e->right.num = e->right.num << e->left.num; break;
- case EXPR_SHR: e->right.num = e->right.num << e->left.num; break;
- case EXPR_LOR: e->right.num = e->left.num || e->right.num; break;
- case EXPR_LAND: e->right.num = e->left.num && e->right.num; break;
- case EXPR_LNOT: e->right.num = !e->right.num; break;
- case EXPR_EQ: e->right.num = e->right.num == e->left.num; break;
- case EXPR_LT: e->right.num = e->right.num < e->left.num; break;
- case EXPR_GT: e->right.num = e->right.num > e->left.num; break;
- case EXPR_LE: e->right.num = e->right.num <= e->left.num; break;
- case EXPR_GE: e->right.num = e->right.num >= e->left.num; break;
- case EXPR_NE: e->right.num = e->right.num != e->left.num; break;
- case EXPR_IDENT: break;
+ && e->rtype == EXPR_NUM && e->op != EXPR_IDENT) {
+ switch (e->op) {
+ case EXPR_ADD:
+ e->right.num = e->left.num + e->right.num;
+ break;
+ case EXPR_SUB:
+ e->right.num = e->left.num - e->right.num;
+ break;
+ case EXPR_MUL:
+ e->right.num = e->left.num * e->right.num;
+ break;
+ case EXPR_DIV:
+ e->right.num = e->left.num / e->right.num;
+ break;
+ case EXPR_MOD:
+ e->right.num = e->left.num % e->right.num;
+ break;
+ case EXPR_NEG:
+ e->right.num = -(e->right.num);
+ break;
+ case EXPR_NOT:
+ e->right.num = ~(e->right.num);
+ break;
+ case EXPR_OR:
+ e->right.num = e->left.num | e->right.num;
+ break;
+ case EXPR_AND:
+ e->right.num = e->left.num & e->right.num;
+ break;
+ case EXPR_XOR:
+ e->right.num = e->left.num ^ e->right.num;
+ break;
+ case EXPR_SHL:
+ e->right.num = e->right.num << e->left.num;
+ break;
+ case EXPR_SHR:
+ e->right.num = e->right.num << e->left.num;
+ break;
+ case EXPR_LOR:
+ e->right.num = e->left.num || e->right.num;
+ break;
+ case EXPR_LAND:
+ e->right.num = e->left.num && e->right.num;
+ break;
+ case EXPR_LNOT:
+ e->right.num = !e->right.num;
+ break;
+ case EXPR_EQ:
+ e->right.num = e->right.num == e->left.num;
+ break;
+ case EXPR_LT:
+ e->right.num = e->right.num < e->left.num;
+ break;
+ case EXPR_GT:
+ e->right.num = e->right.num > e->left.num;
+ break;
+ case EXPR_LE:
+ e->right.num = e->right.num <= e->left.num;
+ break;
+ case EXPR_GE:
+ e->right.num = e->right.num >= e->left.num;
+ break;
+ case EXPR_NE:
+ e->right.num = e->right.num != e->left.num;
+ break;
+ case EXPR_IDENT:
+ break;
}
e->op = EXPR_IDENT;
simplified = 1;
}
/* catch simple identities like 0+x, 1*x, etc., for x not a num */
- else if (e->ltype == EXPR_NUM
- && ((e->left.num == 1 && e->op == EXPR_MUL)
- ||(e->left.num == 0 && e->op == EXPR_ADD)
- ||(e->left.num == -1 && e->op == EXPR_AND)
- ||(e->left.num == 0 && e->op == EXPR_OR)))
- {
+ else if (e->ltype == EXPR_NUM && ((e->left.num == 1 && e->op == EXPR_MUL)
+ || (e->left.num == 0 &&
+ e->op == EXPR_ADD)
+ || (e->left.num == -1 &&
+ e->op == EXPR_AND)
+ || (e->left.num == 0 &&
+ e->op == EXPR_OR))) {
e->op = EXPR_IDENT;
simplified = 1;
}
/* and the corresponding x+|-0, x*&/1 */
- else if (e->rtype == EXPR_NUM
- && ((e->right.num == 1 && e->op == EXPR_MUL)
- ||(e->right.num == 1 && e->op == EXPR_DIV)
- ||(e->right.num == 0 && e->op == EXPR_ADD)
- ||(e->right.num == 0 && e->op == EXPR_SUB)
- ||(e->right.num == -1 && e->op == EXPR_AND)
- ||(e->right.num == 0 && e->op == EXPR_OR)
- ||(e->right.num == 0 && e->op == EXPR_SHL)
- ||(e->right.num == 0 && e->op == EXPR_SHR)))
- {
+ else if (e->rtype == EXPR_NUM && ((e->right.num == 1 && e->op == EXPR_MUL)
+ || (e->right.num == 1 &&
+ e->op == EXPR_DIV)
+ || (e->right.num == 0 &&
+ e->op == EXPR_ADD)
+ || (e->right.num == 0 &&
+ e->op == EXPR_SUB)
+ || (e->right.num == -1 &&
+ e->op == EXPR_AND)
+ || (e->right.num == 0 &&
+ e->op == EXPR_OR)
+ || (e->right.num == 0 &&
+ e->op == EXPR_SHL)
+ || (e->right.num == 0 &&
+ e->op == EXPR_SHR))) {
e->op = EXPR_IDENT;
e->rtype = e->ltype;
- memcpy (&e->right, &e->left, sizeof (ExprItem));
+ memcpy(&e->right, &e->left, sizeof(ExprItem));
simplified = 1;
}
}
int
-expr_get_value (expr *e, unsigned long *retval)
+expr_get_value(expr *e, unsigned long *retval)
{
while (!(e->op == EXPR_IDENT && e->rtype == EXPR_NUM)
- && expr_simplify (e));
+ && expr_simplify(e)) ;
- if (e->op == EXPR_IDENT && e->rtype == EXPR_NUM)
- {
+ if (e->op == EXPR_IDENT && e->rtype == EXPR_NUM) {
*retval = e->right.num;
return 1;
- }
- else
+ } else
return 0;
}
void
-expr_print (expr *e)
+expr_print(expr *e)
{
if (e->op != EXPR_IDENT) {
switch (e->ltype) {
- case EXPR_NUM: printf ("%lu", e->left.num); break;
- case EXPR_SYM: printf ("%s", e->left.sym->name); break;
- case EXPR_EXPR: printf ("("); expr_print (e->left.expr); printf(")");
- case EXPR_NONE: break;
+ case EXPR_NUM:
+ printf("%lu", e->left.num);
+ break;
+ case EXPR_SYM:
+ printf("%s", e->left.sym->name);
+ break;
+ case EXPR_EXPR:
+ printf("(");
+ expr_print(e->left.expr);
+
+ printf(")");
+ case EXPR_NONE:
+ break;
}
}
switch (e->op) {
- case EXPR_ADD: printf ("+"); break;
- case EXPR_SUB: printf ("-"); break;
- case EXPR_MUL: printf ("*"); break;
- case EXPR_DIV: printf ("/"); break;
- case EXPR_MOD: printf ("%%"); break;
- case EXPR_NEG: printf ("-"); break;
- case EXPR_NOT: printf ("~"); break;
- case EXPR_OR: printf ("|"); break;
- case EXPR_AND: printf ("&"); break;
- case EXPR_XOR: printf ("^"); break;
- case EXPR_SHL: printf ("<<"); break;
- case EXPR_SHR: printf (">>"); break;
- case EXPR_LOR: printf ("||"); break;
- case EXPR_LAND: printf ("&&"); break;
- case EXPR_LNOT: printf ("!"); break;
- case EXPR_LT: printf ("<"); break;
- case EXPR_GT: printf (">"); break;
- case EXPR_LE: printf ("<="); break;
- case EXPR_GE: printf (">="); break;
- case EXPR_NE: printf ("!="); break;
- case EXPR_EQ: printf ("=="); break;
- case EXPR_IDENT: break;
+ case EXPR_ADD:
+ printf("+");
+ break;
+ case EXPR_SUB:
+ printf("-");
+ break;
+ case EXPR_MUL:
+ printf("*");
+ break;
+ case EXPR_DIV:
+ printf("/");
+ break;
+ case EXPR_MOD:
+ printf("%%");
+ break;
+ case EXPR_NEG:
+ printf("-");
+ break;
+ case EXPR_NOT:
+ printf("~");
+ break;
+ case EXPR_OR:
+ printf("|");
+ break;
+ case EXPR_AND:
+ printf("&");
+ break;
+ case EXPR_XOR:
+ printf("^");
+ break;
+ case EXPR_SHL:
+ printf("<<");
+ break;
+ case EXPR_SHR:
+ printf(">>");
+ break;
+ case EXPR_LOR:
+ printf("||");
+ break;
+ case EXPR_LAND:
+ printf("&&");
+ break;
+ case EXPR_LNOT:
+ printf("!");
+ break;
+ case EXPR_LT:
+ printf("<");
+ break;
+ case EXPR_GT:
+ printf(">");
+ break;
+ case EXPR_LE:
+ printf("<=");
+ break;
+ case EXPR_GE:
+ printf(">=");
+ break;
+ case EXPR_NE:
+ printf("!=");
+ break;
+ case EXPR_EQ:
+ printf("==");
+ break;
+ case EXPR_IDENT:
+ break;
}
switch (e->rtype) {
- case EXPR_NUM: printf ("%lu", e->right.num); break;
- case EXPR_SYM: printf ("%s", e->right.sym->name); break;
- case EXPR_EXPR: printf ("("); expr_print (e->right.expr); printf(")");
- case EXPR_NONE: break;
+ case EXPR_NUM:
+ printf("%lu", e->right.num);
+ break;
+ case EXPR_SYM:
+ printf("%s", e->right.sym->name);
+ break;
+ case EXPR_EXPR:
+ printf("(");
+ expr_print(e->right.expr);
+
+ printf(")");
+ case EXPR_NONE:
+ break;
}
}
-/* $Id: expr.h,v 1.4 2001/07/11 23:16:50 peter Exp $
+/* $Id: expr.h,v 1.5 2001/08/19 03:52:58 peter Exp $
* Expression handling header file
*
* Copyright (C) 2001 Michael Urman
EXPR_LE,
EXPR_GE,
EXPR_NE,
- EXPR_IDENT /* if right is IDENT, then the entire expr is just a num */
+ EXPR_IDENT /* if right is IDENT, then the entire expr is just a num */
} ExprOp;
typedef enum {
- EXPR_NONE, /* for left side of a NOT, NEG, etc. */
+ EXPR_NONE, /* for left side of a NOT, NEG, etc. */
EXPR_NUM,
EXPR_EXPR,
EXPR_SYM
ExprOp op;
} expr;
-expr *expr_new (ExprType, ExprItem, ExprOp, ExprType, ExprItem);
+expr *expr_new(ExprType, ExprItem, ExprOp, ExprType, ExprItem);
-ExprItem ExprSym (struct symrec_s *);
-ExprItem ExprExpr (expr *);
-ExprItem ExprNum (unsigned long);
-ExprItem ExprNone (void);
+ExprItem ExprSym(struct symrec_s *);
+ExprItem ExprExpr(expr *);
+ExprItem ExprNum(unsigned long);
+ExprItem ExprNone(void);
#define expr_new_tree(l,o,r) \
expr_new (EXPR_EXPR, ExprExpr(l), (o), EXPR_EXPR, ExprExpr(r))
#define expr_new_ident(t,r) \
expr_new (EXPR_NONE, ExprNone(), EXPR_IDENT, (ExprType)(t), (r))
-int expr_simplify (expr *);
-void expr_print (expr *);
+int expr_simplify(expr *);
+void expr_print(expr *);
/* get the value if possible. return value is IF POSSIBLE, not the val */
-int expr_get_value (expr *, unsigned long *);
+int expr_get_value(expr *, unsigned long *);
#endif
-/* $Id: objfmt.h,v 1.1 2001/08/19 02:15:18 peter Exp $
+/* $Id: objfmt.h,v 1.2 2001/08/19 03:52:58 peter Exp $
* Output format module interface header file
*
* Copyright (C) 2001 Peter Johnson
/* Interface to the output format module(s) */
typedef struct outfmt_s {
- char *name; /* one-line description of the format */
- char *keyword; /* keyword used to select format on the command line */
+ /* one-line description of the format */
+ char *name;
+
+ /* keyword used to select format on the command line */
+ char *keyword;
/* NULL-terminated list of debugging formats that are valid to use with
* this output format.
-/* $Id: parser.h,v 1.1 2001/08/19 02:15:18 peter Exp $
+/* $Id: parser.h,v 1.2 2001/08/19 03:52:58 peter Exp $
* Parser module interface header file
*
* Copyright (C) 2001 Peter Johnson
/* Interface to the parser module(s) -- the "front end" of the assembler */
typedef struct parser_s {
- char *name; /* one-line description of the parser */
- char *keyword; /* keyword used to select parser on the command line */
+ /* one-line description of the parser */
+ char *name;
+
+ /* keyword used to select parser on the command line */
+ char *keyword;
/* NULL-terminated list of preprocessors that are valid to use with this
* parser. The raw preprocessor (raw_preproc) should always be in this
* Note that calling this has many side effects in the output format
* module: sections and variables are declared, etc.
*/
- section * (*doparse) (preproc *pp, outfmt *of, FILE *f);
+ section *(*doparse) (preproc *pp, outfmt *of, FILE *f);
} parser;
/* Available parsers */
-/* $Id: preproc.h,v 1.1 2001/08/19 02:15:18 peter Exp $
+/* $Id: preproc.h,v 1.2 2001/08/19 03:52:58 peter Exp $
* Preprocessor module interface header file
*
* Copyright (C) 2001 Peter Johnson
/* Interface to the preprocesor module(s) */
typedef struct preproc_s {
- char *name; /* one-line description of the preprocessor */
+ /* one-line description of the preprocessor */
+ char *name;
/* keyword used to select preprocessor on the command line */
- char *keyword;
+ char *keyword;
/* Initializes preprocessor.
*
-/* $Id: section.h,v 1.4 2001/08/19 02:54:20 peter Exp $
+/* $Id: section.h,v 1.5 2001/08/19 03:52:58 peter Exp $
* Section header file
*
* Copyright (C) 2001 Peter Johnson
unsigned long start;
} data;
- bytecode *bc; /* the bytecodes for the section's contents */
+ bytecode *bc; /* the bytecodes for the section's contents */
} section;
#endif
-/* $Id: symrec.c,v 1.5 2001/07/11 23:16:50 peter Exp $
+/* $Id: symrec.c,v 1.6 2001/08/19 03:52:58 peter Exp $
* Symbol table handling
*
* Copyright (C) 2001 Michael Urman
#include "errwarn.h"
/* private functions */
-static symtab *symtab_get (char *);
-static symtab *symtab_new (char *, SymType);
-static symtab *symtab_get_or_new (char *, SymType);
-static void symtab_insert (symtab *);
+static symtab *symtab_get(char *);
+static symtab *symtab_new(char *, SymType);
+static symtab *symtab_get_or_new(char *, SymType);
+static void symtab_insert(symtab *);
/* The symbol table: a chain of `symtab'. */
symtab *sym_table = (symtab *)NULL;
/* insert a symtab into the global sym_table */
void
-symtab_insert (symtab *tab)
+symtab_insert(symtab *tab)
{
tab->next = (symtab *)sym_table;
sym_table = tab;
/* find a symtab in the global sym_table */
symtab *
-symtab_get (char *name)
+symtab_get(char *name)
{
symtab *tab;
- for (tab = sym_table; tab != NULL; tab = tab->next)
- {
- if (strcmp (tab->rec.name, name) == 0)
- {
+
+ for (tab = sym_table; tab != NULL; tab = tab->next) {
+ if (strcmp(tab->rec.name, name) == 0) {
return tab;
}
}
/* call a function with each symrec. stop early if 0 returned */
void
-sym_foreach (int(*mapfunc)(symrec *))
+sym_foreach(int (*mapfunc) (symrec *))
{
symtab *tab;
- for (tab = sym_table; tab != NULL; tab = tab->next)
- {
- if (mapfunc(&(tab->rec)) == 0)
- {
+
+ for (tab = sym_table; tab != NULL; tab = tab->next) {
+ if (mapfunc(&(tab->rec)) == 0) {
return;
}
}
/* create a new symtab */
symtab *
-symtab_new (char *name, SymType type)
+symtab_new(char *name, SymType type)
{
symtab *tab;
tab = malloc(sizeof(symtab));
- if (tab == NULL) return NULL;
- tab->rec.name = malloc(strlen(name)+1);
- if (tab->rec.name == NULL)
- {
- free (tab);
+ if (tab == NULL)
+ return NULL;
+ tab->rec.name = malloc(strlen(name) + 1);
+ if (tab->rec.name == NULL) {
+ free(tab);
return NULL;
}
strcpy(tab->rec.name, name);
tab->rec.value = 0;
tab->rec.line = line_number;
tab->rec.status = SYM_NOSTATUS;
- symtab_insert (tab);
+ symtab_insert(tab);
return tab;
}
symtab *
-symtab_get_or_new (char *name, SymType type)
+symtab_get_or_new(char *name, SymType type)
{
symtab *tab;
- tab = symtab_get (name);
- if (tab == NULL)
- {
- tab = symtab_new (name, type);
- if (tab == NULL)
- {
- Fatal (FATAL_NOMEM);
+
+ tab = symtab_get(name);
+ if (tab == NULL) {
+ tab = symtab_new(name, type);
+ if (tab == NULL) {
+ Fatal(FATAL_NOMEM);
}
}
return tab;
}
symrec *
-sym_use_get (char *name, SymType type)
+sym_use_get(char *name, SymType type)
{
symtab *tab;
- tab = symtab_get_or_new (name, type);
+
+ tab = symtab_get_or_new(name, type);
tab->rec.status |= SYM_USED;
return &(tab->rec);
}
symrec *
-sym_def_get (char *name, SymType type)
+sym_def_get(char *name, SymType type)
{
symtab *tab;
- tab = symtab_get_or_new (name, type);
+
+ tab = symtab_get_or_new(name, type);
if (tab->rec.status & SYM_DECLARED)
- Error (ERR_DUPLICATE_DEF, "%s%d", tab->rec.name, tab->rec.line);
+ Error(ERR_DUPLICATE_DEF, "%s%d", tab->rec.name, tab->rec.line);
tab->rec.status |= SYM_DECLARED;
return &(tab->rec);
}
#if 0
symrec *
-putsym (char *sym_name, int sym_type)
+putsym(char *sym_name, int sym_type)
{
symrec *ptr;
ptr = malloc(sizeof(symrec));
- ptr->name = malloc(strlen(sym_name)+1);
+ ptr->name = malloc(strlen(sym_name) + 1);
strcpy(ptr->name, sym_name);
ptr->type = sym_type;
- ptr->value.var = 0; /* set value to 0 even if fctn. */
+ ptr->value.var = 0; /* set value to 0 even if fctn. */
ptr->next = (symrec *)sym_table;
sym_table = ptr;
return ptr;
}
symrec *
-getsym (char *sym_name)
+getsym(char *sym_name)
{
symrec *ptr;
- for(ptr=sym_table; ptr != (symrec *)NULL; ptr=(symrec *)ptr->next)
- if(strcmp(ptr->name, sym_name) == 0)
+
+ for (ptr = sym_table; ptr != (symrec *)NULL; ptr = (symrec *)ptr->next)
+ if (strcmp(ptr->name, sym_name) == 0)
return ptr;
return 0;
}
-#endif /* 0 */
+#endif /* 0 */
-/* $Id: symrec.h,v 1.5 2001/07/11 21:16:22 peter Exp $
+/* $Id: symrec.h,v 1.6 2001/08/19 03:52:58 peter Exp $
* Symbol table handling header file
*
* Copyright (C) 2001 Michael Urman
typedef enum {
SYM_NOSTATUS = 0,
- SYM_USED = 1 << 0, /* for using variables before declared */
- SYM_DECLARED = 1 << 1, /* once it's been declared */
- SYM_VALUED = 1 << 2 /* once its value has been determined */
+ SYM_USED = 1 << 0, /* for using variables before declared */
+ SYM_DECLARED = 1 << 1, /* once it's been declared */
+ SYM_VALUED = 1 << 2 /* once its value has been determined */
} SymStatus;
typedef enum {
- SYM_CONSTANT, /* for EQU defined symbols */
- SYM_LABEL /* for labels */
+ SYM_CONSTANT, /* for EQU defined symbols */
+ SYM_LABEL /* for labels */
} SymType;
typedef struct symrec_s {
/*symrec *putsym(char *, SymType);*/
/*symrec *getsym(char *);*/
-symrec *sym_use_get (char *, SymType);
-symrec *sym_def_get (char *, SymType);
-void sym_foreach (int(*)(symrec *));
+symrec *sym_use_get(char *, SymType);
+symrec *sym_def_get(char *, SymType);
+void sym_foreach(int (*)(symrec *));
#endif
-/* $Id: expr.c,v 1.4 2001/07/11 23:16:50 peter Exp $
+/* $Id: expr.c,v 1.5 2001/08/19 03:52:58 peter Exp $
* Expression handling
*
* Copyright (C) 2001 Michael Urman
/* allocate a new expression node, with children as defined.
* If it's a unary operator, put the element on the right */
expr *
-expr_new (ExprType ltype,
- ExprItem left,
- ExprOp op,
- ExprType rtype,
- ExprItem right)
+expr_new(ExprType ltype,
+ ExprItem left,
+ ExprOp op,
+ ExprType rtype,
+ ExprItem right)
{
expr *ptr;
- ptr = malloc (sizeof (expr));
- if (ptr == NULL) Fatal (FATAL_NOMEM);
+ ptr = malloc(sizeof(expr));
+ if (ptr == NULL)
+ Fatal(FATAL_NOMEM);
ptr->ltype = ltype;
ptr->op = op;
ptr->rtype = rtype;
- switch (ltype)
- {
+ switch (ltype) {
case EXPR_NUM:
case EXPR_SYM:
case EXPR_EXPR:
- memcpy (&ptr->left, &left, sizeof (ExprItem));
+ memcpy(&ptr->left, &left, sizeof(ExprItem));
+ break;
+ case EXPR_NONE:
break;
- case EXPR_NONE: break;
}
- switch (rtype)
- {
+ switch (rtype) {
case EXPR_NUM:
case EXPR_SYM:
case EXPR_EXPR:
- memcpy (&ptr->right, &right, sizeof (ExprItem));
+ memcpy(&ptr->right, &right, sizeof(ExprItem));
break;
case EXPR_NONE:
- Fatal (FATAL_UNKNOWN); /* TODO: better error? */
+ Fatal(FATAL_UNKNOWN); /* TODO: better error? */
break;
}
return ptr;
/* helpers */
ExprItem
-ExprSym (struct symrec_s *s)
+ExprSym(struct symrec_s *s)
{
ExprItem e;
+
e.sym = s;
return e;
}
ExprItem
-ExprExpr (expr *x)
+ExprExpr(expr *x)
{
ExprItem e;
e.expr = x;
+
return e;
}
ExprItem
-ExprNum (unsigned long n)
+ExprNum(unsigned long n)
{
ExprItem e;
+
e.num = n;
return e;
}
ExprItem
-ExprNone (void)
+ExprNone(void)
{
ExprItem e;
+
e.num = 0;
return e;
}
/* get rid of unnecessary branches if possible. report. */
int
-expr_simplify (expr *e)
+expr_simplify(expr *e)
{
int simplified = 0;
/* try to simplify the left side */
- if (e->ltype == EXPR_EXPR)
- {
+ if (e->ltype == EXPR_EXPR) {
/* if the left subexpr isn't an IDENT, recurse simplification */
if (e->left.expr->op != EXPR_IDENT)
- simplified |= expr_simplify (e->left.expr);
+ simplified |= expr_simplify(e->left.expr);
/* if the left subexpr is just an IDENT (or string thereof),
* pull it up into the current node */
- while (e->ltype == EXPR_EXPR && e->left.expr->op == EXPR_IDENT)
- {
+ while (e->ltype == EXPR_EXPR && e->left.expr->op == EXPR_IDENT) {
ExprItem tmp;
e->ltype = e->left.expr->rtype;
- memcpy (&tmp, &(e->left.expr->right), sizeof (ExprItem));
- free (e->left.expr);
- memcpy (&(e->left.num), &tmp, sizeof (ExprItem));
+ memcpy(&tmp, &(e->left.expr->right), sizeof(ExprItem));
+ free(e->left.expr);
+ memcpy(&(e->left.num), &tmp, sizeof(ExprItem));
simplified = 1;
}
- }
- else if (e->ltype == EXPR_SYM)
- {
+ } else if (e->ltype == EXPR_SYM) {
/* if it's a symbol that has a defined value, turn it into a
* number */
- if (e->left.sym->status & SYM_VALUED)
- {
+ if (e->left.sym->status & SYM_VALUED) {
e->ltype = EXPR_NUM;
/* don't try to free the symrec here. */
e->left.num = e->left.sym->value;
}
/* ditto on the right */
- if (e->rtype == EXPR_EXPR)
- {
+ if (e->rtype == EXPR_EXPR) {
if (e->right.expr->op != EXPR_IDENT)
- simplified |= expr_simplify (e->right.expr);
+ simplified |= expr_simplify(e->right.expr);
- while (e->rtype == EXPR_EXPR && e->right.expr->op == EXPR_IDENT)
- {
+ while (e->rtype == EXPR_EXPR && e->right.expr->op == EXPR_IDENT) {
ExprItem tmp;
e->rtype = e->right.expr->rtype;
- memcpy (&tmp, &(e->right.expr->right), sizeof (ExprItem));
- free (e->right.expr);
- memcpy (&(e->right.num), &tmp, sizeof (ExprItem));
+ memcpy(&tmp, &(e->right.expr->right), sizeof(ExprItem));
+ free(e->right.expr);
+ memcpy(&(e->right.num), &tmp, sizeof(ExprItem));
simplified = 1;
}
- }
- else if (e->rtype == EXPR_SYM)
- {
- if (e->right.sym->status & SYM_VALUED)
- {
+ } else if (e->rtype == EXPR_SYM) {
+ if (e->right.sym->status & SYM_VALUED) {
e->rtype = EXPR_NUM;
/* don't try to free the symrec here. */
e->right.num = e->right.sym->value;
}
if ((e->ltype == EXPR_NUM || e->ltype == EXPR_NONE)
- && e->rtype == EXPR_NUM
- && e->op != EXPR_IDENT)
- {
- switch (e->op)
- {
- case EXPR_ADD: e->right.num = e->left.num + e->right.num; break;
- case EXPR_SUB: e->right.num = e->left.num - e->right.num; break;
- case EXPR_MUL: e->right.num = e->left.num * e->right.num; break;
- case EXPR_DIV: e->right.num = e->left.num / e->right.num; break;
- case EXPR_MOD: e->right.num = e->left.num % e->right.num; break;
- case EXPR_NEG: e->right.num = -(e->right.num); break;
- case EXPR_NOT: e->right.num = ~(e->right.num); break;
- case EXPR_OR: e->right.num = e->left.num | e->right.num; break;
- case EXPR_AND: e->right.num = e->left.num & e->right.num; break;
- case EXPR_XOR: e->right.num = e->left.num ^ e->right.num; break;
- case EXPR_SHL: e->right.num = e->right.num << e->left.num; break;
- case EXPR_SHR: e->right.num = e->right.num << e->left.num; break;
- case EXPR_LOR: e->right.num = e->left.num || e->right.num; break;
- case EXPR_LAND: e->right.num = e->left.num && e->right.num; break;
- case EXPR_LNOT: e->right.num = !e->right.num; break;
- case EXPR_EQ: e->right.num = e->right.num == e->left.num; break;
- case EXPR_LT: e->right.num = e->right.num < e->left.num; break;
- case EXPR_GT: e->right.num = e->right.num > e->left.num; break;
- case EXPR_LE: e->right.num = e->right.num <= e->left.num; break;
- case EXPR_GE: e->right.num = e->right.num >= e->left.num; break;
- case EXPR_NE: e->right.num = e->right.num != e->left.num; break;
- case EXPR_IDENT: break;
+ && e->rtype == EXPR_NUM && e->op != EXPR_IDENT) {
+ switch (e->op) {
+ case EXPR_ADD:
+ e->right.num = e->left.num + e->right.num;
+ break;
+ case EXPR_SUB:
+ e->right.num = e->left.num - e->right.num;
+ break;
+ case EXPR_MUL:
+ e->right.num = e->left.num * e->right.num;
+ break;
+ case EXPR_DIV:
+ e->right.num = e->left.num / e->right.num;
+ break;
+ case EXPR_MOD:
+ e->right.num = e->left.num % e->right.num;
+ break;
+ case EXPR_NEG:
+ e->right.num = -(e->right.num);
+ break;
+ case EXPR_NOT:
+ e->right.num = ~(e->right.num);
+ break;
+ case EXPR_OR:
+ e->right.num = e->left.num | e->right.num;
+ break;
+ case EXPR_AND:
+ e->right.num = e->left.num & e->right.num;
+ break;
+ case EXPR_XOR:
+ e->right.num = e->left.num ^ e->right.num;
+ break;
+ case EXPR_SHL:
+ e->right.num = e->right.num << e->left.num;
+ break;
+ case EXPR_SHR:
+ e->right.num = e->right.num << e->left.num;
+ break;
+ case EXPR_LOR:
+ e->right.num = e->left.num || e->right.num;
+ break;
+ case EXPR_LAND:
+ e->right.num = e->left.num && e->right.num;
+ break;
+ case EXPR_LNOT:
+ e->right.num = !e->right.num;
+ break;
+ case EXPR_EQ:
+ e->right.num = e->right.num == e->left.num;
+ break;
+ case EXPR_LT:
+ e->right.num = e->right.num < e->left.num;
+ break;
+ case EXPR_GT:
+ e->right.num = e->right.num > e->left.num;
+ break;
+ case EXPR_LE:
+ e->right.num = e->right.num <= e->left.num;
+ break;
+ case EXPR_GE:
+ e->right.num = e->right.num >= e->left.num;
+ break;
+ case EXPR_NE:
+ e->right.num = e->right.num != e->left.num;
+ break;
+ case EXPR_IDENT:
+ break;
}
e->op = EXPR_IDENT;
simplified = 1;
}
/* catch simple identities like 0+x, 1*x, etc., for x not a num */
- else if (e->ltype == EXPR_NUM
- && ((e->left.num == 1 && e->op == EXPR_MUL)
- ||(e->left.num == 0 && e->op == EXPR_ADD)
- ||(e->left.num == -1 && e->op == EXPR_AND)
- ||(e->left.num == 0 && e->op == EXPR_OR)))
- {
+ else if (e->ltype == EXPR_NUM && ((e->left.num == 1 && e->op == EXPR_MUL)
+ || (e->left.num == 0 &&
+ e->op == EXPR_ADD)
+ || (e->left.num == -1 &&
+ e->op == EXPR_AND)
+ || (e->left.num == 0 &&
+ e->op == EXPR_OR))) {
e->op = EXPR_IDENT;
simplified = 1;
}
/* and the corresponding x+|-0, x*&/1 */
- else if (e->rtype == EXPR_NUM
- && ((e->right.num == 1 && e->op == EXPR_MUL)
- ||(e->right.num == 1 && e->op == EXPR_DIV)
- ||(e->right.num == 0 && e->op == EXPR_ADD)
- ||(e->right.num == 0 && e->op == EXPR_SUB)
- ||(e->right.num == -1 && e->op == EXPR_AND)
- ||(e->right.num == 0 && e->op == EXPR_OR)
- ||(e->right.num == 0 && e->op == EXPR_SHL)
- ||(e->right.num == 0 && e->op == EXPR_SHR)))
- {
+ else if (e->rtype == EXPR_NUM && ((e->right.num == 1 && e->op == EXPR_MUL)
+ || (e->right.num == 1 &&
+ e->op == EXPR_DIV)
+ || (e->right.num == 0 &&
+ e->op == EXPR_ADD)
+ || (e->right.num == 0 &&
+ e->op == EXPR_SUB)
+ || (e->right.num == -1 &&
+ e->op == EXPR_AND)
+ || (e->right.num == 0 &&
+ e->op == EXPR_OR)
+ || (e->right.num == 0 &&
+ e->op == EXPR_SHL)
+ || (e->right.num == 0 &&
+ e->op == EXPR_SHR))) {
e->op = EXPR_IDENT;
e->rtype = e->ltype;
- memcpy (&e->right, &e->left, sizeof (ExprItem));
+ memcpy(&e->right, &e->left, sizeof(ExprItem));
simplified = 1;
}
}
int
-expr_get_value (expr *e, unsigned long *retval)
+expr_get_value(expr *e, unsigned long *retval)
{
while (!(e->op == EXPR_IDENT && e->rtype == EXPR_NUM)
- && expr_simplify (e));
+ && expr_simplify(e)) ;
- if (e->op == EXPR_IDENT && e->rtype == EXPR_NUM)
- {
+ if (e->op == EXPR_IDENT && e->rtype == EXPR_NUM) {
*retval = e->right.num;
return 1;
- }
- else
+ } else
return 0;
}
void
-expr_print (expr *e)
+expr_print(expr *e)
{
if (e->op != EXPR_IDENT) {
switch (e->ltype) {
- case EXPR_NUM: printf ("%lu", e->left.num); break;
- case EXPR_SYM: printf ("%s", e->left.sym->name); break;
- case EXPR_EXPR: printf ("("); expr_print (e->left.expr); printf(")");
- case EXPR_NONE: break;
+ case EXPR_NUM:
+ printf("%lu", e->left.num);
+ break;
+ case EXPR_SYM:
+ printf("%s", e->left.sym->name);
+ break;
+ case EXPR_EXPR:
+ printf("(");
+ expr_print(e->left.expr);
+
+ printf(")");
+ case EXPR_NONE:
+ break;
}
}
switch (e->op) {
- case EXPR_ADD: printf ("+"); break;
- case EXPR_SUB: printf ("-"); break;
- case EXPR_MUL: printf ("*"); break;
- case EXPR_DIV: printf ("/"); break;
- case EXPR_MOD: printf ("%%"); break;
- case EXPR_NEG: printf ("-"); break;
- case EXPR_NOT: printf ("~"); break;
- case EXPR_OR: printf ("|"); break;
- case EXPR_AND: printf ("&"); break;
- case EXPR_XOR: printf ("^"); break;
- case EXPR_SHL: printf ("<<"); break;
- case EXPR_SHR: printf (">>"); break;
- case EXPR_LOR: printf ("||"); break;
- case EXPR_LAND: printf ("&&"); break;
- case EXPR_LNOT: printf ("!"); break;
- case EXPR_LT: printf ("<"); break;
- case EXPR_GT: printf (">"); break;
- case EXPR_LE: printf ("<="); break;
- case EXPR_GE: printf (">="); break;
- case EXPR_NE: printf ("!="); break;
- case EXPR_EQ: printf ("=="); break;
- case EXPR_IDENT: break;
+ case EXPR_ADD:
+ printf("+");
+ break;
+ case EXPR_SUB:
+ printf("-");
+ break;
+ case EXPR_MUL:
+ printf("*");
+ break;
+ case EXPR_DIV:
+ printf("/");
+ break;
+ case EXPR_MOD:
+ printf("%%");
+ break;
+ case EXPR_NEG:
+ printf("-");
+ break;
+ case EXPR_NOT:
+ printf("~");
+ break;
+ case EXPR_OR:
+ printf("|");
+ break;
+ case EXPR_AND:
+ printf("&");
+ break;
+ case EXPR_XOR:
+ printf("^");
+ break;
+ case EXPR_SHL:
+ printf("<<");
+ break;
+ case EXPR_SHR:
+ printf(">>");
+ break;
+ case EXPR_LOR:
+ printf("||");
+ break;
+ case EXPR_LAND:
+ printf("&&");
+ break;
+ case EXPR_LNOT:
+ printf("!");
+ break;
+ case EXPR_LT:
+ printf("<");
+ break;
+ case EXPR_GT:
+ printf(">");
+ break;
+ case EXPR_LE:
+ printf("<=");
+ break;
+ case EXPR_GE:
+ printf(">=");
+ break;
+ case EXPR_NE:
+ printf("!=");
+ break;
+ case EXPR_EQ:
+ printf("==");
+ break;
+ case EXPR_IDENT:
+ break;
}
switch (e->rtype) {
- case EXPR_NUM: printf ("%lu", e->right.num); break;
- case EXPR_SYM: printf ("%s", e->right.sym->name); break;
- case EXPR_EXPR: printf ("("); expr_print (e->right.expr); printf(")");
- case EXPR_NONE: break;
+ case EXPR_NUM:
+ printf("%lu", e->right.num);
+ break;
+ case EXPR_SYM:
+ printf("%s", e->right.sym->name);
+ break;
+ case EXPR_EXPR:
+ printf("(");
+ expr_print(e->right.expr);
+
+ printf(")");
+ case EXPR_NONE:
+ break;
}
}
-/* $Id: x86expr.c,v 1.4 2001/07/11 23:16:50 peter Exp $
+/* $Id: x86expr.c,v 1.5 2001/08/19 03:52:58 peter Exp $
* Expression handling
*
* Copyright (C) 2001 Michael Urman
/* allocate a new expression node, with children as defined.
* If it's a unary operator, put the element on the right */
expr *
-expr_new (ExprType ltype,
- ExprItem left,
- ExprOp op,
- ExprType rtype,
- ExprItem right)
+expr_new(ExprType ltype,
+ ExprItem left,
+ ExprOp op,
+ ExprType rtype,
+ ExprItem right)
{
expr *ptr;
- ptr = malloc (sizeof (expr));
- if (ptr == NULL) Fatal (FATAL_NOMEM);
+ ptr = malloc(sizeof(expr));
+ if (ptr == NULL)
+ Fatal(FATAL_NOMEM);
ptr->ltype = ltype;
ptr->op = op;
ptr->rtype = rtype;
- switch (ltype)
- {
+ switch (ltype) {
case EXPR_NUM:
case EXPR_SYM:
case EXPR_EXPR:
- memcpy (&ptr->left, &left, sizeof (ExprItem));
+ memcpy(&ptr->left, &left, sizeof(ExprItem));
+ break;
+ case EXPR_NONE:
break;
- case EXPR_NONE: break;
}
- switch (rtype)
- {
+ switch (rtype) {
case EXPR_NUM:
case EXPR_SYM:
case EXPR_EXPR:
- memcpy (&ptr->right, &right, sizeof (ExprItem));
+ memcpy(&ptr->right, &right, sizeof(ExprItem));
break;
case EXPR_NONE:
- Fatal (FATAL_UNKNOWN); /* TODO: better error? */
+ Fatal(FATAL_UNKNOWN); /* TODO: better error? */
break;
}
return ptr;
/* helpers */
ExprItem
-ExprSym (struct symrec_s *s)
+ExprSym(struct symrec_s *s)
{
ExprItem e;
+
e.sym = s;
return e;
}
ExprItem
-ExprExpr (expr *x)
+ExprExpr(expr *x)
{
ExprItem e;
e.expr = x;
+
return e;
}
ExprItem
-ExprNum (unsigned long n)
+ExprNum(unsigned long n)
{
ExprItem e;
+
e.num = n;
return e;
}
ExprItem
-ExprNone (void)
+ExprNone(void)
{
ExprItem e;
+
e.num = 0;
return e;
}
/* get rid of unnecessary branches if possible. report. */
int
-expr_simplify (expr *e)
+expr_simplify(expr *e)
{
int simplified = 0;
/* try to simplify the left side */
- if (e->ltype == EXPR_EXPR)
- {
+ if (e->ltype == EXPR_EXPR) {
/* if the left subexpr isn't an IDENT, recurse simplification */
if (e->left.expr->op != EXPR_IDENT)
- simplified |= expr_simplify (e->left.expr);
+ simplified |= expr_simplify(e->left.expr);
/* if the left subexpr is just an IDENT (or string thereof),
* pull it up into the current node */
- while (e->ltype == EXPR_EXPR && e->left.expr->op == EXPR_IDENT)
- {
+ while (e->ltype == EXPR_EXPR && e->left.expr->op == EXPR_IDENT) {
ExprItem tmp;
e->ltype = e->left.expr->rtype;
- memcpy (&tmp, &(e->left.expr->right), sizeof (ExprItem));
- free (e->left.expr);
- memcpy (&(e->left.num), &tmp, sizeof (ExprItem));
+ memcpy(&tmp, &(e->left.expr->right), sizeof(ExprItem));
+ free(e->left.expr);
+ memcpy(&(e->left.num), &tmp, sizeof(ExprItem));
simplified = 1;
}
- }
- else if (e->ltype == EXPR_SYM)
- {
+ } else if (e->ltype == EXPR_SYM) {
/* if it's a symbol that has a defined value, turn it into a
* number */
- if (e->left.sym->status & SYM_VALUED)
- {
+ if (e->left.sym->status & SYM_VALUED) {
e->ltype = EXPR_NUM;
/* don't try to free the symrec here. */
e->left.num = e->left.sym->value;
}
/* ditto on the right */
- if (e->rtype == EXPR_EXPR)
- {
+ if (e->rtype == EXPR_EXPR) {
if (e->right.expr->op != EXPR_IDENT)
- simplified |= expr_simplify (e->right.expr);
+ simplified |= expr_simplify(e->right.expr);
- while (e->rtype == EXPR_EXPR && e->right.expr->op == EXPR_IDENT)
- {
+ while (e->rtype == EXPR_EXPR && e->right.expr->op == EXPR_IDENT) {
ExprItem tmp;
e->rtype = e->right.expr->rtype;
- memcpy (&tmp, &(e->right.expr->right), sizeof (ExprItem));
- free (e->right.expr);
- memcpy (&(e->right.num), &tmp, sizeof (ExprItem));
+ memcpy(&tmp, &(e->right.expr->right), sizeof(ExprItem));
+ free(e->right.expr);
+ memcpy(&(e->right.num), &tmp, sizeof(ExprItem));
simplified = 1;
}
- }
- else if (e->rtype == EXPR_SYM)
- {
- if (e->right.sym->status & SYM_VALUED)
- {
+ } else if (e->rtype == EXPR_SYM) {
+ if (e->right.sym->status & SYM_VALUED) {
e->rtype = EXPR_NUM;
/* don't try to free the symrec here. */
e->right.num = e->right.sym->value;
}
if ((e->ltype == EXPR_NUM || e->ltype == EXPR_NONE)
- && e->rtype == EXPR_NUM
- && e->op != EXPR_IDENT)
- {
- switch (e->op)
- {
- case EXPR_ADD: e->right.num = e->left.num + e->right.num; break;
- case EXPR_SUB: e->right.num = e->left.num - e->right.num; break;
- case EXPR_MUL: e->right.num = e->left.num * e->right.num; break;
- case EXPR_DIV: e->right.num = e->left.num / e->right.num; break;
- case EXPR_MOD: e->right.num = e->left.num % e->right.num; break;
- case EXPR_NEG: e->right.num = -(e->right.num); break;
- case EXPR_NOT: e->right.num = ~(e->right.num); break;
- case EXPR_OR: e->right.num = e->left.num | e->right.num; break;
- case EXPR_AND: e->right.num = e->left.num & e->right.num; break;
- case EXPR_XOR: e->right.num = e->left.num ^ e->right.num; break;
- case EXPR_SHL: e->right.num = e->right.num << e->left.num; break;
- case EXPR_SHR: e->right.num = e->right.num << e->left.num; break;
- case EXPR_LOR: e->right.num = e->left.num || e->right.num; break;
- case EXPR_LAND: e->right.num = e->left.num && e->right.num; break;
- case EXPR_LNOT: e->right.num = !e->right.num; break;
- case EXPR_EQ: e->right.num = e->right.num == e->left.num; break;
- case EXPR_LT: e->right.num = e->right.num < e->left.num; break;
- case EXPR_GT: e->right.num = e->right.num > e->left.num; break;
- case EXPR_LE: e->right.num = e->right.num <= e->left.num; break;
- case EXPR_GE: e->right.num = e->right.num >= e->left.num; break;
- case EXPR_NE: e->right.num = e->right.num != e->left.num; break;
- case EXPR_IDENT: break;
+ && e->rtype == EXPR_NUM && e->op != EXPR_IDENT) {
+ switch (e->op) {
+ case EXPR_ADD:
+ e->right.num = e->left.num + e->right.num;
+ break;
+ case EXPR_SUB:
+ e->right.num = e->left.num - e->right.num;
+ break;
+ case EXPR_MUL:
+ e->right.num = e->left.num * e->right.num;
+ break;
+ case EXPR_DIV:
+ e->right.num = e->left.num / e->right.num;
+ break;
+ case EXPR_MOD:
+ e->right.num = e->left.num % e->right.num;
+ break;
+ case EXPR_NEG:
+ e->right.num = -(e->right.num);
+ break;
+ case EXPR_NOT:
+ e->right.num = ~(e->right.num);
+ break;
+ case EXPR_OR:
+ e->right.num = e->left.num | e->right.num;
+ break;
+ case EXPR_AND:
+ e->right.num = e->left.num & e->right.num;
+ break;
+ case EXPR_XOR:
+ e->right.num = e->left.num ^ e->right.num;
+ break;
+ case EXPR_SHL:
+ e->right.num = e->right.num << e->left.num;
+ break;
+ case EXPR_SHR:
+ e->right.num = e->right.num << e->left.num;
+ break;
+ case EXPR_LOR:
+ e->right.num = e->left.num || e->right.num;
+ break;
+ case EXPR_LAND:
+ e->right.num = e->left.num && e->right.num;
+ break;
+ case EXPR_LNOT:
+ e->right.num = !e->right.num;
+ break;
+ case EXPR_EQ:
+ e->right.num = e->right.num == e->left.num;
+ break;
+ case EXPR_LT:
+ e->right.num = e->right.num < e->left.num;
+ break;
+ case EXPR_GT:
+ e->right.num = e->right.num > e->left.num;
+ break;
+ case EXPR_LE:
+ e->right.num = e->right.num <= e->left.num;
+ break;
+ case EXPR_GE:
+ e->right.num = e->right.num >= e->left.num;
+ break;
+ case EXPR_NE:
+ e->right.num = e->right.num != e->left.num;
+ break;
+ case EXPR_IDENT:
+ break;
}
e->op = EXPR_IDENT;
simplified = 1;
}
/* catch simple identities like 0+x, 1*x, etc., for x not a num */
- else if (e->ltype == EXPR_NUM
- && ((e->left.num == 1 && e->op == EXPR_MUL)
- ||(e->left.num == 0 && e->op == EXPR_ADD)
- ||(e->left.num == -1 && e->op == EXPR_AND)
- ||(e->left.num == 0 && e->op == EXPR_OR)))
- {
+ else if (e->ltype == EXPR_NUM && ((e->left.num == 1 && e->op == EXPR_MUL)
+ || (e->left.num == 0 &&
+ e->op == EXPR_ADD)
+ || (e->left.num == -1 &&
+ e->op == EXPR_AND)
+ || (e->left.num == 0 &&
+ e->op == EXPR_OR))) {
e->op = EXPR_IDENT;
simplified = 1;
}
/* and the corresponding x+|-0, x*&/1 */
- else if (e->rtype == EXPR_NUM
- && ((e->right.num == 1 && e->op == EXPR_MUL)
- ||(e->right.num == 1 && e->op == EXPR_DIV)
- ||(e->right.num == 0 && e->op == EXPR_ADD)
- ||(e->right.num == 0 && e->op == EXPR_SUB)
- ||(e->right.num == -1 && e->op == EXPR_AND)
- ||(e->right.num == 0 && e->op == EXPR_OR)
- ||(e->right.num == 0 && e->op == EXPR_SHL)
- ||(e->right.num == 0 && e->op == EXPR_SHR)))
- {
+ else if (e->rtype == EXPR_NUM && ((e->right.num == 1 && e->op == EXPR_MUL)
+ || (e->right.num == 1 &&
+ e->op == EXPR_DIV)
+ || (e->right.num == 0 &&
+ e->op == EXPR_ADD)
+ || (e->right.num == 0 &&
+ e->op == EXPR_SUB)
+ || (e->right.num == -1 &&
+ e->op == EXPR_AND)
+ || (e->right.num == 0 &&
+ e->op == EXPR_OR)
+ || (e->right.num == 0 &&
+ e->op == EXPR_SHL)
+ || (e->right.num == 0 &&
+ e->op == EXPR_SHR))) {
e->op = EXPR_IDENT;
e->rtype = e->ltype;
- memcpy (&e->right, &e->left, sizeof (ExprItem));
+ memcpy(&e->right, &e->left, sizeof(ExprItem));
simplified = 1;
}
}
int
-expr_get_value (expr *e, unsigned long *retval)
+expr_get_value(expr *e, unsigned long *retval)
{
while (!(e->op == EXPR_IDENT && e->rtype == EXPR_NUM)
- && expr_simplify (e));
+ && expr_simplify(e)) ;
- if (e->op == EXPR_IDENT && e->rtype == EXPR_NUM)
- {
+ if (e->op == EXPR_IDENT && e->rtype == EXPR_NUM) {
*retval = e->right.num;
return 1;
- }
- else
+ } else
return 0;
}
void
-expr_print (expr *e)
+expr_print(expr *e)
{
if (e->op != EXPR_IDENT) {
switch (e->ltype) {
- case EXPR_NUM: printf ("%lu", e->left.num); break;
- case EXPR_SYM: printf ("%s", e->left.sym->name); break;
- case EXPR_EXPR: printf ("("); expr_print (e->left.expr); printf(")");
- case EXPR_NONE: break;
+ case EXPR_NUM:
+ printf("%lu", e->left.num);
+ break;
+ case EXPR_SYM:
+ printf("%s", e->left.sym->name);
+ break;
+ case EXPR_EXPR:
+ printf("(");
+ expr_print(e->left.expr);
+
+ printf(")");
+ case EXPR_NONE:
+ break;
}
}
switch (e->op) {
- case EXPR_ADD: printf ("+"); break;
- case EXPR_SUB: printf ("-"); break;
- case EXPR_MUL: printf ("*"); break;
- case EXPR_DIV: printf ("/"); break;
- case EXPR_MOD: printf ("%%"); break;
- case EXPR_NEG: printf ("-"); break;
- case EXPR_NOT: printf ("~"); break;
- case EXPR_OR: printf ("|"); break;
- case EXPR_AND: printf ("&"); break;
- case EXPR_XOR: printf ("^"); break;
- case EXPR_SHL: printf ("<<"); break;
- case EXPR_SHR: printf (">>"); break;
- case EXPR_LOR: printf ("||"); break;
- case EXPR_LAND: printf ("&&"); break;
- case EXPR_LNOT: printf ("!"); break;
- case EXPR_LT: printf ("<"); break;
- case EXPR_GT: printf (">"); break;
- case EXPR_LE: printf ("<="); break;
- case EXPR_GE: printf (">="); break;
- case EXPR_NE: printf ("!="); break;
- case EXPR_EQ: printf ("=="); break;
- case EXPR_IDENT: break;
+ case EXPR_ADD:
+ printf("+");
+ break;
+ case EXPR_SUB:
+ printf("-");
+ break;
+ case EXPR_MUL:
+ printf("*");
+ break;
+ case EXPR_DIV:
+ printf("/");
+ break;
+ case EXPR_MOD:
+ printf("%%");
+ break;
+ case EXPR_NEG:
+ printf("-");
+ break;
+ case EXPR_NOT:
+ printf("~");
+ break;
+ case EXPR_OR:
+ printf("|");
+ break;
+ case EXPR_AND:
+ printf("&");
+ break;
+ case EXPR_XOR:
+ printf("^");
+ break;
+ case EXPR_SHL:
+ printf("<<");
+ break;
+ case EXPR_SHR:
+ printf(">>");
+ break;
+ case EXPR_LOR:
+ printf("||");
+ break;
+ case EXPR_LAND:
+ printf("&&");
+ break;
+ case EXPR_LNOT:
+ printf("!");
+ break;
+ case EXPR_LT:
+ printf("<");
+ break;
+ case EXPR_GT:
+ printf(">");
+ break;
+ case EXPR_LE:
+ printf("<=");
+ break;
+ case EXPR_GE:
+ printf(">=");
+ break;
+ case EXPR_NE:
+ printf("!=");
+ break;
+ case EXPR_EQ:
+ printf("==");
+ break;
+ case EXPR_IDENT:
+ break;
}
switch (e->rtype) {
- case EXPR_NUM: printf ("%lu", e->right.num); break;
- case EXPR_SYM: printf ("%s", e->right.sym->name); break;
- case EXPR_EXPR: printf ("("); expr_print (e->right.expr); printf(")");
- case EXPR_NONE: break;
+ case EXPR_NUM:
+ printf("%lu", e->right.num);
+ break;
+ case EXPR_SYM:
+ printf("%s", e->right.sym->name);
+ break;
+ case EXPR_EXPR:
+ printf("(");
+ expr_print(e->right.expr);
+
+ printf(")");
+ case EXPR_NONE:
+ break;
}
}
-/* $Id: preproc.c,v 1.2 2001/08/19 02:50:14 peter Exp $
+/* $Id: preproc.c,v 1.3 2001/08/19 03:52:58 peter Exp $
* Raw preprocessor (preforms NO preprocessing)
*
* Copyright (C) 2001 Peter Johnson
{
int c = '*', n;
- if(is_interactive) {
- for(n = 0; n < max_size && (c = getc(in)) != EOF && c != '\n'; n++)
- buf[n] = (char) c;
- if(c == '\n')
- buf[n++] = (char) c;
- if(c == EOF && ferror(in))
+ if (is_interactive) {
+ for (n = 0; n < max_size && (c = getc(in)) != EOF && c != '\n'; n++)
+ buf[n] = (char)c;
+ if (c == '\n')
+ buf[n++] = (char)c;
+ if (c == EOF && ferror(in))
Error(ERR_FILE_READ, (char *)NULL);
- } else if(((n = fread(buf, 1, max_size, in)) == 0) && ferror(in))
+ } else if (((n = fread(buf, 1, max_size, in)) == 0) && ferror(in))
Error(ERR_FILE_READ, (char *)NULL);
return n;
-/* $Id: raw-preproc.c,v 1.2 2001/08/19 02:50:14 peter Exp $
+/* $Id: raw-preproc.c,v 1.3 2001/08/19 03:52:58 peter Exp $
* Raw preprocessor (preforms NO preprocessing)
*
* Copyright (C) 2001 Peter Johnson
{
int c = '*', n;
- if(is_interactive) {
- for(n = 0; n < max_size && (c = getc(in)) != EOF && c != '\n'; n++)
- buf[n] = (char) c;
- if(c == '\n')
- buf[n++] = (char) c;
- if(c == EOF && ferror(in))
+ if (is_interactive) {
+ for (n = 0; n < max_size && (c = getc(in)) != EOF && c != '\n'; n++)
+ buf[n] = (char)c;
+ if (c == '\n')
+ buf[n++] = (char)c;
+ if (c == EOF && ferror(in))
Error(ERR_FILE_READ, (char *)NULL);
- } else if(((n = fread(buf, 1, max_size, in)) == 0) && ferror(in))
+ } else if (((n = fread(buf, 1, max_size, in)) == 0) && ferror(in))
Error(ERR_FILE_READ, (char *)NULL);
return n;
-/* $Id: expr.c,v 1.4 2001/07/11 23:16:50 peter Exp $
+/* $Id: expr.c,v 1.5 2001/08/19 03:52:58 peter Exp $
* Expression handling
*
* Copyright (C) 2001 Michael Urman
/* allocate a new expression node, with children as defined.
* If it's a unary operator, put the element on the right */
expr *
-expr_new (ExprType ltype,
- ExprItem left,
- ExprOp op,
- ExprType rtype,
- ExprItem right)
+expr_new(ExprType ltype,
+ ExprItem left,
+ ExprOp op,
+ ExprType rtype,
+ ExprItem right)
{
expr *ptr;
- ptr = malloc (sizeof (expr));
- if (ptr == NULL) Fatal (FATAL_NOMEM);
+ ptr = malloc(sizeof(expr));
+ if (ptr == NULL)
+ Fatal(FATAL_NOMEM);
ptr->ltype = ltype;
ptr->op = op;
ptr->rtype = rtype;
- switch (ltype)
- {
+ switch (ltype) {
case EXPR_NUM:
case EXPR_SYM:
case EXPR_EXPR:
- memcpy (&ptr->left, &left, sizeof (ExprItem));
+ memcpy(&ptr->left, &left, sizeof(ExprItem));
+ break;
+ case EXPR_NONE:
break;
- case EXPR_NONE: break;
}
- switch (rtype)
- {
+ switch (rtype) {
case EXPR_NUM:
case EXPR_SYM:
case EXPR_EXPR:
- memcpy (&ptr->right, &right, sizeof (ExprItem));
+ memcpy(&ptr->right, &right, sizeof(ExprItem));
break;
case EXPR_NONE:
- Fatal (FATAL_UNKNOWN); /* TODO: better error? */
+ Fatal(FATAL_UNKNOWN); /* TODO: better error? */
break;
}
return ptr;
/* helpers */
ExprItem
-ExprSym (struct symrec_s *s)
+ExprSym(struct symrec_s *s)
{
ExprItem e;
+
e.sym = s;
return e;
}
ExprItem
-ExprExpr (expr *x)
+ExprExpr(expr *x)
{
ExprItem e;
e.expr = x;
+
return e;
}
ExprItem
-ExprNum (unsigned long n)
+ExprNum(unsigned long n)
{
ExprItem e;
+
e.num = n;
return e;
}
ExprItem
-ExprNone (void)
+ExprNone(void)
{
ExprItem e;
+
e.num = 0;
return e;
}
/* get rid of unnecessary branches if possible. report. */
int
-expr_simplify (expr *e)
+expr_simplify(expr *e)
{
int simplified = 0;
/* try to simplify the left side */
- if (e->ltype == EXPR_EXPR)
- {
+ if (e->ltype == EXPR_EXPR) {
/* if the left subexpr isn't an IDENT, recurse simplification */
if (e->left.expr->op != EXPR_IDENT)
- simplified |= expr_simplify (e->left.expr);
+ simplified |= expr_simplify(e->left.expr);
/* if the left subexpr is just an IDENT (or string thereof),
* pull it up into the current node */
- while (e->ltype == EXPR_EXPR && e->left.expr->op == EXPR_IDENT)
- {
+ while (e->ltype == EXPR_EXPR && e->left.expr->op == EXPR_IDENT) {
ExprItem tmp;
e->ltype = e->left.expr->rtype;
- memcpy (&tmp, &(e->left.expr->right), sizeof (ExprItem));
- free (e->left.expr);
- memcpy (&(e->left.num), &tmp, sizeof (ExprItem));
+ memcpy(&tmp, &(e->left.expr->right), sizeof(ExprItem));
+ free(e->left.expr);
+ memcpy(&(e->left.num), &tmp, sizeof(ExprItem));
simplified = 1;
}
- }
- else if (e->ltype == EXPR_SYM)
- {
+ } else if (e->ltype == EXPR_SYM) {
/* if it's a symbol that has a defined value, turn it into a
* number */
- if (e->left.sym->status & SYM_VALUED)
- {
+ if (e->left.sym->status & SYM_VALUED) {
e->ltype = EXPR_NUM;
/* don't try to free the symrec here. */
e->left.num = e->left.sym->value;
}
/* ditto on the right */
- if (e->rtype == EXPR_EXPR)
- {
+ if (e->rtype == EXPR_EXPR) {
if (e->right.expr->op != EXPR_IDENT)
- simplified |= expr_simplify (e->right.expr);
+ simplified |= expr_simplify(e->right.expr);
- while (e->rtype == EXPR_EXPR && e->right.expr->op == EXPR_IDENT)
- {
+ while (e->rtype == EXPR_EXPR && e->right.expr->op == EXPR_IDENT) {
ExprItem tmp;
e->rtype = e->right.expr->rtype;
- memcpy (&tmp, &(e->right.expr->right), sizeof (ExprItem));
- free (e->right.expr);
- memcpy (&(e->right.num), &tmp, sizeof (ExprItem));
+ memcpy(&tmp, &(e->right.expr->right), sizeof(ExprItem));
+ free(e->right.expr);
+ memcpy(&(e->right.num), &tmp, sizeof(ExprItem));
simplified = 1;
}
- }
- else if (e->rtype == EXPR_SYM)
- {
- if (e->right.sym->status & SYM_VALUED)
- {
+ } else if (e->rtype == EXPR_SYM) {
+ if (e->right.sym->status & SYM_VALUED) {
e->rtype = EXPR_NUM;
/* don't try to free the symrec here. */
e->right.num = e->right.sym->value;
}
if ((e->ltype == EXPR_NUM || e->ltype == EXPR_NONE)
- && e->rtype == EXPR_NUM
- && e->op != EXPR_IDENT)
- {
- switch (e->op)
- {
- case EXPR_ADD: e->right.num = e->left.num + e->right.num; break;
- case EXPR_SUB: e->right.num = e->left.num - e->right.num; break;
- case EXPR_MUL: e->right.num = e->left.num * e->right.num; break;
- case EXPR_DIV: e->right.num = e->left.num / e->right.num; break;
- case EXPR_MOD: e->right.num = e->left.num % e->right.num; break;
- case EXPR_NEG: e->right.num = -(e->right.num); break;
- case EXPR_NOT: e->right.num = ~(e->right.num); break;
- case EXPR_OR: e->right.num = e->left.num | e->right.num; break;
- case EXPR_AND: e->right.num = e->left.num & e->right.num; break;
- case EXPR_XOR: e->right.num = e->left.num ^ e->right.num; break;
- case EXPR_SHL: e->right.num = e->right.num << e->left.num; break;
- case EXPR_SHR: e->right.num = e->right.num << e->left.num; break;
- case EXPR_LOR: e->right.num = e->left.num || e->right.num; break;
- case EXPR_LAND: e->right.num = e->left.num && e->right.num; break;
- case EXPR_LNOT: e->right.num = !e->right.num; break;
- case EXPR_EQ: e->right.num = e->right.num == e->left.num; break;
- case EXPR_LT: e->right.num = e->right.num < e->left.num; break;
- case EXPR_GT: e->right.num = e->right.num > e->left.num; break;
- case EXPR_LE: e->right.num = e->right.num <= e->left.num; break;
- case EXPR_GE: e->right.num = e->right.num >= e->left.num; break;
- case EXPR_NE: e->right.num = e->right.num != e->left.num; break;
- case EXPR_IDENT: break;
+ && e->rtype == EXPR_NUM && e->op != EXPR_IDENT) {
+ switch (e->op) {
+ case EXPR_ADD:
+ e->right.num = e->left.num + e->right.num;
+ break;
+ case EXPR_SUB:
+ e->right.num = e->left.num - e->right.num;
+ break;
+ case EXPR_MUL:
+ e->right.num = e->left.num * e->right.num;
+ break;
+ case EXPR_DIV:
+ e->right.num = e->left.num / e->right.num;
+ break;
+ case EXPR_MOD:
+ e->right.num = e->left.num % e->right.num;
+ break;
+ case EXPR_NEG:
+ e->right.num = -(e->right.num);
+ break;
+ case EXPR_NOT:
+ e->right.num = ~(e->right.num);
+ break;
+ case EXPR_OR:
+ e->right.num = e->left.num | e->right.num;
+ break;
+ case EXPR_AND:
+ e->right.num = e->left.num & e->right.num;
+ break;
+ case EXPR_XOR:
+ e->right.num = e->left.num ^ e->right.num;
+ break;
+ case EXPR_SHL:
+ e->right.num = e->right.num << e->left.num;
+ break;
+ case EXPR_SHR:
+ e->right.num = e->right.num << e->left.num;
+ break;
+ case EXPR_LOR:
+ e->right.num = e->left.num || e->right.num;
+ break;
+ case EXPR_LAND:
+ e->right.num = e->left.num && e->right.num;
+ break;
+ case EXPR_LNOT:
+ e->right.num = !e->right.num;
+ break;
+ case EXPR_EQ:
+ e->right.num = e->right.num == e->left.num;
+ break;
+ case EXPR_LT:
+ e->right.num = e->right.num < e->left.num;
+ break;
+ case EXPR_GT:
+ e->right.num = e->right.num > e->left.num;
+ break;
+ case EXPR_LE:
+ e->right.num = e->right.num <= e->left.num;
+ break;
+ case EXPR_GE:
+ e->right.num = e->right.num >= e->left.num;
+ break;
+ case EXPR_NE:
+ e->right.num = e->right.num != e->left.num;
+ break;
+ case EXPR_IDENT:
+ break;
}
e->op = EXPR_IDENT;
simplified = 1;
}
/* catch simple identities like 0+x, 1*x, etc., for x not a num */
- else if (e->ltype == EXPR_NUM
- && ((e->left.num == 1 && e->op == EXPR_MUL)
- ||(e->left.num == 0 && e->op == EXPR_ADD)
- ||(e->left.num == -1 && e->op == EXPR_AND)
- ||(e->left.num == 0 && e->op == EXPR_OR)))
- {
+ else if (e->ltype == EXPR_NUM && ((e->left.num == 1 && e->op == EXPR_MUL)
+ || (e->left.num == 0 &&
+ e->op == EXPR_ADD)
+ || (e->left.num == -1 &&
+ e->op == EXPR_AND)
+ || (e->left.num == 0 &&
+ e->op == EXPR_OR))) {
e->op = EXPR_IDENT;
simplified = 1;
}
/* and the corresponding x+|-0, x*&/1 */
- else if (e->rtype == EXPR_NUM
- && ((e->right.num == 1 && e->op == EXPR_MUL)
- ||(e->right.num == 1 && e->op == EXPR_DIV)
- ||(e->right.num == 0 && e->op == EXPR_ADD)
- ||(e->right.num == 0 && e->op == EXPR_SUB)
- ||(e->right.num == -1 && e->op == EXPR_AND)
- ||(e->right.num == 0 && e->op == EXPR_OR)
- ||(e->right.num == 0 && e->op == EXPR_SHL)
- ||(e->right.num == 0 && e->op == EXPR_SHR)))
- {
+ else if (e->rtype == EXPR_NUM && ((e->right.num == 1 && e->op == EXPR_MUL)
+ || (e->right.num == 1 &&
+ e->op == EXPR_DIV)
+ || (e->right.num == 0 &&
+ e->op == EXPR_ADD)
+ || (e->right.num == 0 &&
+ e->op == EXPR_SUB)
+ || (e->right.num == -1 &&
+ e->op == EXPR_AND)
+ || (e->right.num == 0 &&
+ e->op == EXPR_OR)
+ || (e->right.num == 0 &&
+ e->op == EXPR_SHL)
+ || (e->right.num == 0 &&
+ e->op == EXPR_SHR))) {
e->op = EXPR_IDENT;
e->rtype = e->ltype;
- memcpy (&e->right, &e->left, sizeof (ExprItem));
+ memcpy(&e->right, &e->left, sizeof(ExprItem));
simplified = 1;
}
}
int
-expr_get_value (expr *e, unsigned long *retval)
+expr_get_value(expr *e, unsigned long *retval)
{
while (!(e->op == EXPR_IDENT && e->rtype == EXPR_NUM)
- && expr_simplify (e));
+ && expr_simplify(e)) ;
- if (e->op == EXPR_IDENT && e->rtype == EXPR_NUM)
- {
+ if (e->op == EXPR_IDENT && e->rtype == EXPR_NUM) {
*retval = e->right.num;
return 1;
- }
- else
+ } else
return 0;
}
void
-expr_print (expr *e)
+expr_print(expr *e)
{
if (e->op != EXPR_IDENT) {
switch (e->ltype) {
- case EXPR_NUM: printf ("%lu", e->left.num); break;
- case EXPR_SYM: printf ("%s", e->left.sym->name); break;
- case EXPR_EXPR: printf ("("); expr_print (e->left.expr); printf(")");
- case EXPR_NONE: break;
+ case EXPR_NUM:
+ printf("%lu", e->left.num);
+ break;
+ case EXPR_SYM:
+ printf("%s", e->left.sym->name);
+ break;
+ case EXPR_EXPR:
+ printf("(");
+ expr_print(e->left.expr);
+
+ printf(")");
+ case EXPR_NONE:
+ break;
}
}
switch (e->op) {
- case EXPR_ADD: printf ("+"); break;
- case EXPR_SUB: printf ("-"); break;
- case EXPR_MUL: printf ("*"); break;
- case EXPR_DIV: printf ("/"); break;
- case EXPR_MOD: printf ("%%"); break;
- case EXPR_NEG: printf ("-"); break;
- case EXPR_NOT: printf ("~"); break;
- case EXPR_OR: printf ("|"); break;
- case EXPR_AND: printf ("&"); break;
- case EXPR_XOR: printf ("^"); break;
- case EXPR_SHL: printf ("<<"); break;
- case EXPR_SHR: printf (">>"); break;
- case EXPR_LOR: printf ("||"); break;
- case EXPR_LAND: printf ("&&"); break;
- case EXPR_LNOT: printf ("!"); break;
- case EXPR_LT: printf ("<"); break;
- case EXPR_GT: printf (">"); break;
- case EXPR_LE: printf ("<="); break;
- case EXPR_GE: printf (">="); break;
- case EXPR_NE: printf ("!="); break;
- case EXPR_EQ: printf ("=="); break;
- case EXPR_IDENT: break;
+ case EXPR_ADD:
+ printf("+");
+ break;
+ case EXPR_SUB:
+ printf("-");
+ break;
+ case EXPR_MUL:
+ printf("*");
+ break;
+ case EXPR_DIV:
+ printf("/");
+ break;
+ case EXPR_MOD:
+ printf("%%");
+ break;
+ case EXPR_NEG:
+ printf("-");
+ break;
+ case EXPR_NOT:
+ printf("~");
+ break;
+ case EXPR_OR:
+ printf("|");
+ break;
+ case EXPR_AND:
+ printf("&");
+ break;
+ case EXPR_XOR:
+ printf("^");
+ break;
+ case EXPR_SHL:
+ printf("<<");
+ break;
+ case EXPR_SHR:
+ printf(">>");
+ break;
+ case EXPR_LOR:
+ printf("||");
+ break;
+ case EXPR_LAND:
+ printf("&&");
+ break;
+ case EXPR_LNOT:
+ printf("!");
+ break;
+ case EXPR_LT:
+ printf("<");
+ break;
+ case EXPR_GT:
+ printf(">");
+ break;
+ case EXPR_LE:
+ printf("<=");
+ break;
+ case EXPR_GE:
+ printf(">=");
+ break;
+ case EXPR_NE:
+ printf("!=");
+ break;
+ case EXPR_EQ:
+ printf("==");
+ break;
+ case EXPR_IDENT:
+ break;
}
switch (e->rtype) {
- case EXPR_NUM: printf ("%lu", e->right.num); break;
- case EXPR_SYM: printf ("%s", e->right.sym->name); break;
- case EXPR_EXPR: printf ("("); expr_print (e->right.expr); printf(")");
- case EXPR_NONE: break;
+ case EXPR_NUM:
+ printf("%lu", e->right.num);
+ break;
+ case EXPR_SYM:
+ printf("%s", e->right.sym->name);
+ break;
+ case EXPR_EXPR:
+ printf("(");
+ expr_print(e->right.expr);
+
+ printf(")");
+ case EXPR_NONE:
+ break;
}
}
-/* $Id: x86expr.c,v 1.4 2001/07/11 23:16:50 peter Exp $
+/* $Id: x86expr.c,v 1.5 2001/08/19 03:52:58 peter Exp $
* Expression handling
*
* Copyright (C) 2001 Michael Urman
/* allocate a new expression node, with children as defined.
* If it's a unary operator, put the element on the right */
expr *
-expr_new (ExprType ltype,
- ExprItem left,
- ExprOp op,
- ExprType rtype,
- ExprItem right)
+expr_new(ExprType ltype,
+ ExprItem left,
+ ExprOp op,
+ ExprType rtype,
+ ExprItem right)
{
expr *ptr;
- ptr = malloc (sizeof (expr));
- if (ptr == NULL) Fatal (FATAL_NOMEM);
+ ptr = malloc(sizeof(expr));
+ if (ptr == NULL)
+ Fatal(FATAL_NOMEM);
ptr->ltype = ltype;
ptr->op = op;
ptr->rtype = rtype;
- switch (ltype)
- {
+ switch (ltype) {
case EXPR_NUM:
case EXPR_SYM:
case EXPR_EXPR:
- memcpy (&ptr->left, &left, sizeof (ExprItem));
+ memcpy(&ptr->left, &left, sizeof(ExprItem));
+ break;
+ case EXPR_NONE:
break;
- case EXPR_NONE: break;
}
- switch (rtype)
- {
+ switch (rtype) {
case EXPR_NUM:
case EXPR_SYM:
case EXPR_EXPR:
- memcpy (&ptr->right, &right, sizeof (ExprItem));
+ memcpy(&ptr->right, &right, sizeof(ExprItem));
break;
case EXPR_NONE:
- Fatal (FATAL_UNKNOWN); /* TODO: better error? */
+ Fatal(FATAL_UNKNOWN); /* TODO: better error? */
break;
}
return ptr;
/* helpers */
ExprItem
-ExprSym (struct symrec_s *s)
+ExprSym(struct symrec_s *s)
{
ExprItem e;
+
e.sym = s;
return e;
}
ExprItem
-ExprExpr (expr *x)
+ExprExpr(expr *x)
{
ExprItem e;
e.expr = x;
+
return e;
}
ExprItem
-ExprNum (unsigned long n)
+ExprNum(unsigned long n)
{
ExprItem e;
+
e.num = n;
return e;
}
ExprItem
-ExprNone (void)
+ExprNone(void)
{
ExprItem e;
+
e.num = 0;
return e;
}
/* get rid of unnecessary branches if possible. report. */
int
-expr_simplify (expr *e)
+expr_simplify(expr *e)
{
int simplified = 0;
/* try to simplify the left side */
- if (e->ltype == EXPR_EXPR)
- {
+ if (e->ltype == EXPR_EXPR) {
/* if the left subexpr isn't an IDENT, recurse simplification */
if (e->left.expr->op != EXPR_IDENT)
- simplified |= expr_simplify (e->left.expr);
+ simplified |= expr_simplify(e->left.expr);
/* if the left subexpr is just an IDENT (or string thereof),
* pull it up into the current node */
- while (e->ltype == EXPR_EXPR && e->left.expr->op == EXPR_IDENT)
- {
+ while (e->ltype == EXPR_EXPR && e->left.expr->op == EXPR_IDENT) {
ExprItem tmp;
e->ltype = e->left.expr->rtype;
- memcpy (&tmp, &(e->left.expr->right), sizeof (ExprItem));
- free (e->left.expr);
- memcpy (&(e->left.num), &tmp, sizeof (ExprItem));
+ memcpy(&tmp, &(e->left.expr->right), sizeof(ExprItem));
+ free(e->left.expr);
+ memcpy(&(e->left.num), &tmp, sizeof(ExprItem));
simplified = 1;
}
- }
- else if (e->ltype == EXPR_SYM)
- {
+ } else if (e->ltype == EXPR_SYM) {
/* if it's a symbol that has a defined value, turn it into a
* number */
- if (e->left.sym->status & SYM_VALUED)
- {
+ if (e->left.sym->status & SYM_VALUED) {
e->ltype = EXPR_NUM;
/* don't try to free the symrec here. */
e->left.num = e->left.sym->value;
}
/* ditto on the right */
- if (e->rtype == EXPR_EXPR)
- {
+ if (e->rtype == EXPR_EXPR) {
if (e->right.expr->op != EXPR_IDENT)
- simplified |= expr_simplify (e->right.expr);
+ simplified |= expr_simplify(e->right.expr);
- while (e->rtype == EXPR_EXPR && e->right.expr->op == EXPR_IDENT)
- {
+ while (e->rtype == EXPR_EXPR && e->right.expr->op == EXPR_IDENT) {
ExprItem tmp;
e->rtype = e->right.expr->rtype;
- memcpy (&tmp, &(e->right.expr->right), sizeof (ExprItem));
- free (e->right.expr);
- memcpy (&(e->right.num), &tmp, sizeof (ExprItem));
+ memcpy(&tmp, &(e->right.expr->right), sizeof(ExprItem));
+ free(e->right.expr);
+ memcpy(&(e->right.num), &tmp, sizeof(ExprItem));
simplified = 1;
}
- }
- else if (e->rtype == EXPR_SYM)
- {
- if (e->right.sym->status & SYM_VALUED)
- {
+ } else if (e->rtype == EXPR_SYM) {
+ if (e->right.sym->status & SYM_VALUED) {
e->rtype = EXPR_NUM;
/* don't try to free the symrec here. */
e->right.num = e->right.sym->value;
}
if ((e->ltype == EXPR_NUM || e->ltype == EXPR_NONE)
- && e->rtype == EXPR_NUM
- && e->op != EXPR_IDENT)
- {
- switch (e->op)
- {
- case EXPR_ADD: e->right.num = e->left.num + e->right.num; break;
- case EXPR_SUB: e->right.num = e->left.num - e->right.num; break;
- case EXPR_MUL: e->right.num = e->left.num * e->right.num; break;
- case EXPR_DIV: e->right.num = e->left.num / e->right.num; break;
- case EXPR_MOD: e->right.num = e->left.num % e->right.num; break;
- case EXPR_NEG: e->right.num = -(e->right.num); break;
- case EXPR_NOT: e->right.num = ~(e->right.num); break;
- case EXPR_OR: e->right.num = e->left.num | e->right.num; break;
- case EXPR_AND: e->right.num = e->left.num & e->right.num; break;
- case EXPR_XOR: e->right.num = e->left.num ^ e->right.num; break;
- case EXPR_SHL: e->right.num = e->right.num << e->left.num; break;
- case EXPR_SHR: e->right.num = e->right.num << e->left.num; break;
- case EXPR_LOR: e->right.num = e->left.num || e->right.num; break;
- case EXPR_LAND: e->right.num = e->left.num && e->right.num; break;
- case EXPR_LNOT: e->right.num = !e->right.num; break;
- case EXPR_EQ: e->right.num = e->right.num == e->left.num; break;
- case EXPR_LT: e->right.num = e->right.num < e->left.num; break;
- case EXPR_GT: e->right.num = e->right.num > e->left.num; break;
- case EXPR_LE: e->right.num = e->right.num <= e->left.num; break;
- case EXPR_GE: e->right.num = e->right.num >= e->left.num; break;
- case EXPR_NE: e->right.num = e->right.num != e->left.num; break;
- case EXPR_IDENT: break;
+ && e->rtype == EXPR_NUM && e->op != EXPR_IDENT) {
+ switch (e->op) {
+ case EXPR_ADD:
+ e->right.num = e->left.num + e->right.num;
+ break;
+ case EXPR_SUB:
+ e->right.num = e->left.num - e->right.num;
+ break;
+ case EXPR_MUL:
+ e->right.num = e->left.num * e->right.num;
+ break;
+ case EXPR_DIV:
+ e->right.num = e->left.num / e->right.num;
+ break;
+ case EXPR_MOD:
+ e->right.num = e->left.num % e->right.num;
+ break;
+ case EXPR_NEG:
+ e->right.num = -(e->right.num);
+ break;
+ case EXPR_NOT:
+ e->right.num = ~(e->right.num);
+ break;
+ case EXPR_OR:
+ e->right.num = e->left.num | e->right.num;
+ break;
+ case EXPR_AND:
+ e->right.num = e->left.num & e->right.num;
+ break;
+ case EXPR_XOR:
+ e->right.num = e->left.num ^ e->right.num;
+ break;
+ case EXPR_SHL:
+ e->right.num = e->right.num << e->left.num;
+ break;
+ case EXPR_SHR:
+ e->right.num = e->right.num << e->left.num;
+ break;
+ case EXPR_LOR:
+ e->right.num = e->left.num || e->right.num;
+ break;
+ case EXPR_LAND:
+ e->right.num = e->left.num && e->right.num;
+ break;
+ case EXPR_LNOT:
+ e->right.num = !e->right.num;
+ break;
+ case EXPR_EQ:
+ e->right.num = e->right.num == e->left.num;
+ break;
+ case EXPR_LT:
+ e->right.num = e->right.num < e->left.num;
+ break;
+ case EXPR_GT:
+ e->right.num = e->right.num > e->left.num;
+ break;
+ case EXPR_LE:
+ e->right.num = e->right.num <= e->left.num;
+ break;
+ case EXPR_GE:
+ e->right.num = e->right.num >= e->left.num;
+ break;
+ case EXPR_NE:
+ e->right.num = e->right.num != e->left.num;
+ break;
+ case EXPR_IDENT:
+ break;
}
e->op = EXPR_IDENT;
simplified = 1;
}
/* catch simple identities like 0+x, 1*x, etc., for x not a num */
- else if (e->ltype == EXPR_NUM
- && ((e->left.num == 1 && e->op == EXPR_MUL)
- ||(e->left.num == 0 && e->op == EXPR_ADD)
- ||(e->left.num == -1 && e->op == EXPR_AND)
- ||(e->left.num == 0 && e->op == EXPR_OR)))
- {
+ else if (e->ltype == EXPR_NUM && ((e->left.num == 1 && e->op == EXPR_MUL)
+ || (e->left.num == 0 &&
+ e->op == EXPR_ADD)
+ || (e->left.num == -1 &&
+ e->op == EXPR_AND)
+ || (e->left.num == 0 &&
+ e->op == EXPR_OR))) {
e->op = EXPR_IDENT;
simplified = 1;
}
/* and the corresponding x+|-0, x*&/1 */
- else if (e->rtype == EXPR_NUM
- && ((e->right.num == 1 && e->op == EXPR_MUL)
- ||(e->right.num == 1 && e->op == EXPR_DIV)
- ||(e->right.num == 0 && e->op == EXPR_ADD)
- ||(e->right.num == 0 && e->op == EXPR_SUB)
- ||(e->right.num == -1 && e->op == EXPR_AND)
- ||(e->right.num == 0 && e->op == EXPR_OR)
- ||(e->right.num == 0 && e->op == EXPR_SHL)
- ||(e->right.num == 0 && e->op == EXPR_SHR)))
- {
+ else if (e->rtype == EXPR_NUM && ((e->right.num == 1 && e->op == EXPR_MUL)
+ || (e->right.num == 1 &&
+ e->op == EXPR_DIV)
+ || (e->right.num == 0 &&
+ e->op == EXPR_ADD)
+ || (e->right.num == 0 &&
+ e->op == EXPR_SUB)
+ || (e->right.num == -1 &&
+ e->op == EXPR_AND)
+ || (e->right.num == 0 &&
+ e->op == EXPR_OR)
+ || (e->right.num == 0 &&
+ e->op == EXPR_SHL)
+ || (e->right.num == 0 &&
+ e->op == EXPR_SHR))) {
e->op = EXPR_IDENT;
e->rtype = e->ltype;
- memcpy (&e->right, &e->left, sizeof (ExprItem));
+ memcpy(&e->right, &e->left, sizeof(ExprItem));
simplified = 1;
}
}
int
-expr_get_value (expr *e, unsigned long *retval)
+expr_get_value(expr *e, unsigned long *retval)
{
while (!(e->op == EXPR_IDENT && e->rtype == EXPR_NUM)
- && expr_simplify (e));
+ && expr_simplify(e)) ;
- if (e->op == EXPR_IDENT && e->rtype == EXPR_NUM)
- {
+ if (e->op == EXPR_IDENT && e->rtype == EXPR_NUM) {
*retval = e->right.num;
return 1;
- }
- else
+ } else
return 0;
}
void
-expr_print (expr *e)
+expr_print(expr *e)
{
if (e->op != EXPR_IDENT) {
switch (e->ltype) {
- case EXPR_NUM: printf ("%lu", e->left.num); break;
- case EXPR_SYM: printf ("%s", e->left.sym->name); break;
- case EXPR_EXPR: printf ("("); expr_print (e->left.expr); printf(")");
- case EXPR_NONE: break;
+ case EXPR_NUM:
+ printf("%lu", e->left.num);
+ break;
+ case EXPR_SYM:
+ printf("%s", e->left.sym->name);
+ break;
+ case EXPR_EXPR:
+ printf("(");
+ expr_print(e->left.expr);
+
+ printf(")");
+ case EXPR_NONE:
+ break;
}
}
switch (e->op) {
- case EXPR_ADD: printf ("+"); break;
- case EXPR_SUB: printf ("-"); break;
- case EXPR_MUL: printf ("*"); break;
- case EXPR_DIV: printf ("/"); break;
- case EXPR_MOD: printf ("%%"); break;
- case EXPR_NEG: printf ("-"); break;
- case EXPR_NOT: printf ("~"); break;
- case EXPR_OR: printf ("|"); break;
- case EXPR_AND: printf ("&"); break;
- case EXPR_XOR: printf ("^"); break;
- case EXPR_SHL: printf ("<<"); break;
- case EXPR_SHR: printf (">>"); break;
- case EXPR_LOR: printf ("||"); break;
- case EXPR_LAND: printf ("&&"); break;
- case EXPR_LNOT: printf ("!"); break;
- case EXPR_LT: printf ("<"); break;
- case EXPR_GT: printf (">"); break;
- case EXPR_LE: printf ("<="); break;
- case EXPR_GE: printf (">="); break;
- case EXPR_NE: printf ("!="); break;
- case EXPR_EQ: printf ("=="); break;
- case EXPR_IDENT: break;
+ case EXPR_ADD:
+ printf("+");
+ break;
+ case EXPR_SUB:
+ printf("-");
+ break;
+ case EXPR_MUL:
+ printf("*");
+ break;
+ case EXPR_DIV:
+ printf("/");
+ break;
+ case EXPR_MOD:
+ printf("%%");
+ break;
+ case EXPR_NEG:
+ printf("-");
+ break;
+ case EXPR_NOT:
+ printf("~");
+ break;
+ case EXPR_OR:
+ printf("|");
+ break;
+ case EXPR_AND:
+ printf("&");
+ break;
+ case EXPR_XOR:
+ printf("^");
+ break;
+ case EXPR_SHL:
+ printf("<<");
+ break;
+ case EXPR_SHR:
+ printf(">>");
+ break;
+ case EXPR_LOR:
+ printf("||");
+ break;
+ case EXPR_LAND:
+ printf("&&");
+ break;
+ case EXPR_LNOT:
+ printf("!");
+ break;
+ case EXPR_LT:
+ printf("<");
+ break;
+ case EXPR_GT:
+ printf(">");
+ break;
+ case EXPR_LE:
+ printf("<=");
+ break;
+ case EXPR_GE:
+ printf(">=");
+ break;
+ case EXPR_NE:
+ printf("!=");
+ break;
+ case EXPR_EQ:
+ printf("==");
+ break;
+ case EXPR_IDENT:
+ break;
}
switch (e->rtype) {
- case EXPR_NUM: printf ("%lu", e->right.num); break;
- case EXPR_SYM: printf ("%s", e->right.sym->name); break;
- case EXPR_EXPR: printf ("("); expr_print (e->right.expr); printf(")");
- case EXPR_NONE: break;
+ case EXPR_NUM:
+ printf("%lu", e->right.num);
+ break;
+ case EXPR_SYM:
+ printf("%s", e->right.sym->name);
+ break;
+ case EXPR_EXPR:
+ printf("(");
+ expr_print(e->right.expr);
+
+ printf(")");
+ case EXPR_NONE:
+ break;
}
}
-/* $Id: bytecode.c,v 1.15 2001/08/18 22:15:12 peter Exp $
+/* $Id: bytecode.c,v 1.16 2001/08/19 03:52:58 peter Exp $
* Bytecode utility functions
*
* Copyright (C) 2001 Peter Johnson
/* Static structures for when NULL is passed to conversion functions. */
/* for Convert*ToEA() */
static effaddr eff_static;
+
/* for Convert*ToImm() */
static immval im_static;
+
/* for Convert*ToBytes() */
unsigned char bytes_static[16];
static void BuildBC_Common(bytecode *bc);
effaddr *
-ConvertRegToEA (effaddr *ptr, unsigned long reg)
+ConvertRegToEA(effaddr *ptr, unsigned long reg)
{
- if(!ptr)
+ if (!ptr)
ptr = &eff_static;
ptr->len = 0;
ptr->segment = 0;
- ptr->modrm = 0xC0 | (reg & 0x07); /* Mod=11, R/M=Reg, Reg=0 */
+ ptr->modrm = 0xC0 | (reg & 0x07); /* Mod=11, R/M=Reg, Reg=0 */
ptr->valid_modrm = 1;
ptr->need_modrm = 1;
ptr->valid_sib = 0;
}
effaddr *
-ConvertExprToEA (effaddr *ptr, expr *expr_ptr)
+ConvertExprToEA(effaddr *ptr, expr *expr_ptr)
{
- if(!ptr)
+ if (!ptr)
ptr = &eff_static;
ptr->segment = 0;
}
effaddr *
-ConvertImmToEA (effaddr *ptr, immval *im_ptr, unsigned char im_len)
+ConvertImmToEA(effaddr *ptr, immval *im_ptr, unsigned char im_len)
{
- if(!ptr)
+ if (!ptr)
ptr = &eff_static;
ptr->disp = im_ptr->val;
- if(im_ptr->len > im_len)
+ if (im_ptr->len > im_len)
Warning(WARN_VALUE_EXCEEDS_BOUNDS, (char *)NULL, "word");
ptr->len = im_len;
ptr->segment = 0;
}
immval *
-ConvertIntToImm (immval *ptr, unsigned long int_val)
+ConvertIntToImm(immval *ptr, unsigned long int_val)
{
- if(!ptr)
+ if (!ptr)
ptr = &im_static;
/* FIXME: this will leak expr's if static is used */
ptr->val = expr_new_ident(EXPR_NUM, ExprNum(int_val));
- if((int_val & 0xFF) == int_val)
+ if ((int_val & 0xFF) == int_val)
ptr->len = 1;
- else if((int_val & 0xFFFF) == int_val)
+ else if ((int_val & 0xFFFF) == int_val)
ptr->len = 2;
else
ptr->len = 4;
}
immval *
-ConvertExprToImm (immval *ptr, expr *expr_ptr)
+ConvertExprToImm(immval *ptr, expr *expr_ptr)
{
- if(!ptr)
+ if (!ptr)
ptr = &im_static;
ptr->val = expr_ptr;
}
void
-SetEASegment (effaddr *ptr, unsigned char segment)
+SetEASegment(effaddr *ptr, unsigned char segment)
{
- if(!ptr)
+ if (!ptr)
return;
- if(ptr->segment != 0)
+ if (ptr->segment != 0)
Warning(WARN_MULT_SEG_OVERRIDE, (char *)NULL);
ptr->segment = segment;
}
void
-SetEALen (effaddr *ptr, unsigned char len)
+SetEALen(effaddr *ptr, unsigned char len)
{
- if(!ptr)
+ if (!ptr)
return;
/* Currently don't warn if length truncated, as this is called only from
}
void
-SetInsnOperSizeOverride (bytecode *bc, unsigned char opersize)
+SetInsnOperSizeOverride(bytecode *bc, unsigned char opersize)
{
- if(!bc)
+ if (!bc)
return;
- switch(bc->type) {
+ switch (bc->type) {
case BC_INSN:
bc->data.insn.opersize = opersize;
break;
break;
default:
InternalError(__LINE__, __FILE__,
- "OperSize override applied to non-instruction");
+ "OperSize override applied to non-instruction");
return;
}
}
void
-SetInsnAddrSizeOverride (bytecode *bc, unsigned char addrsize)
+SetInsnAddrSizeOverride(bytecode *bc, unsigned char addrsize)
{
- if(!bc)
+ if (!bc)
return;
- switch(bc->type) {
+ switch (bc->type) {
case BC_INSN:
bc->data.insn.addrsize = addrsize;
break;
break;
default:
InternalError(__LINE__, __FILE__,
- "AddrSize override applied to non-instruction");
+ "AddrSize override applied to non-instruction");
return;
}
}
void
-SetInsnLockRepPrefix (bytecode *bc, unsigned char prefix)
+SetInsnLockRepPrefix(bytecode *bc, unsigned char prefix)
{
unsigned char *lockrep_pre = (unsigned char *)NULL;
- if(!bc)
+ if (!bc)
return;
- switch(bc->type) {
+ switch (bc->type) {
case BC_INSN:
lockrep_pre = &bc->data.insn.lockrep_pre;
break;
break;
default:
InternalError(__LINE__, __FILE__,
- "LockRep prefix applied to non-instruction");
+ "LockRep prefix applied to non-instruction");
return;
}
- if(*lockrep_pre != 0)
+ if (*lockrep_pre != 0)
Warning(WARN_MULT_LOCKREP_PREFIX, (char *)NULL);
*lockrep_pre = prefix;
}
void
-SetOpcodeSel (jmprel_opcode_sel *old_sel, jmprel_opcode_sel new_sel)
+SetOpcodeSel(jmprel_opcode_sel *old_sel, jmprel_opcode_sel new_sel)
{
- if(!old_sel)
+ if (!old_sel)
return;
- if((*old_sel == JR_SHORT_FORCED) || (*old_sel == JR_NEAR_FORCED))
+ if ((*old_sel == JR_SHORT_FORCED) || (*old_sel == JR_NEAR_FORCED))
Warning(WARN_MULT_SHORTNEAR, (char *)NULL);
*old_sel = new_sel;
}
static void
-BuildBC_Common (bytecode *bc)
+BuildBC_Common(bytecode *bc)
{
bc->len = 0;
}
void
-BuildBC_Insn (bytecode *bc,
- unsigned char opersize,
- unsigned char opcode_len,
- unsigned char op0,
- unsigned char op1,
- unsigned char op2,
- effaddr *ea_ptr,
- unsigned char spare,
- immval *im_ptr,
- unsigned char im_len,
- unsigned char im_sign)
+BuildBC_Insn(bytecode *bc,
+ unsigned char opersize,
+ unsigned char opcode_len,
+ unsigned char op0,
+ unsigned char op1,
+ unsigned char op2,
+ effaddr *ea_ptr,
+ unsigned char spare,
+ immval *im_ptr,
+ unsigned char im_len,
+ unsigned char im_sign)
{
bc->next = (bytecode *)NULL;
bc->type = BC_INSN;
- if(ea_ptr) {
+ if (ea_ptr) {
bc->data.insn.ea = *ea_ptr;
- bc->data.insn.ea.modrm &= 0xC7; /* zero spare/reg bits */
+ bc->data.insn.ea.modrm &= 0xC7; /* zero spare/reg bits */
bc->data.insn.ea.modrm |= (spare << 3) & 0x38; /* plug in provided bits */
} else {
bc->data.insn.ea.len = 0;
bc->data.insn.ea.need_sib = 0;
}
- if(im_ptr) {
+ if (im_ptr) {
bc->data.insn.imm = *im_ptr;
bc->data.insn.imm.f_sign = im_sign;
bc->data.insn.imm.f_len = im_len;
}
void
-BuildBC_JmpRel (bytecode *bc,
- targetval *target,
- unsigned char short_valid,
- unsigned char short_opcode_len,
- unsigned char short_op0,
- unsigned char short_op1,
- unsigned char short_op2,
- unsigned char near_valid,
- unsigned char near_opcode_len,
- unsigned char near_op0,
- unsigned char near_op1,
- unsigned char near_op2,
- unsigned char addrsize)
+BuildBC_JmpRel(bytecode *bc,
+ targetval *target,
+ unsigned char short_valid,
+ unsigned char short_opcode_len,
+ unsigned char short_op0,
+ unsigned char short_op1,
+ unsigned char short_op2,
+ unsigned char near_valid,
+ unsigned char near_opcode_len,
+ unsigned char near_op0,
+ unsigned char near_op1,
+ unsigned char near_op2,
+ unsigned char addrsize)
{
bc->next = (bytecode *)NULL;
bc->type = BC_JMPREL;
bc->data.jmprel.target = target->val;
bc->data.jmprel.op_sel = target->op_sel;
- if((target->op_sel == JR_SHORT_FORCED) && (!short_valid))
+ if ((target->op_sel == JR_SHORT_FORCED) && (!short_valid))
Error(ERR_NO_JMPREL_FORM, (char *)NULL, "SHORT");
- if((target->op_sel == JR_NEAR_FORCED) && (!near_valid))
+ if ((target->op_sel == JR_NEAR_FORCED) && (!near_valid))
Error(ERR_NO_JMPREL_FORM, (char *)NULL, "NEAR");
bc->data.jmprel.shortop.valid = short_valid;
- if(short_valid) {
+ if (short_valid) {
bc->data.jmprel.shortop.opcode[0] = short_op0;
bc->data.jmprel.shortop.opcode[1] = short_op1;
bc->data.jmprel.shortop.opcode[2] = short_op2;
}
bc->data.jmprel.nearop.valid = near_valid;
- if(near_valid) {
+ if (near_valid) {
bc->data.jmprel.nearop.opcode[0] = near_op0;
bc->data.jmprel.nearop.opcode[1] = near_op1;
bc->data.jmprel.nearop.opcode[2] = near_op2;
}
void
-BuildBC_Data (bytecode *bc,
- dataval *data,
- unsigned long size)
+BuildBC_Data(bytecode *bc, dataval *data, unsigned long size)
{
dataval *cur = data;
* constants (equ's) should always be legal, but labels should raise
* warnings when used in db or dq context at the minimum).
*/
- while(cur) {
- switch(cur->type) {
+ while (cur) {
+ switch (cur->type) {
case DV_EMPTY:
case DV_STRING:
/* string is valid in every size */
break;
case DV_FLOAT:
- if(size == 1)
+ if (size == 1)
Error(ERR_DECLDATA_FLOAT, (char *)NULL, "DB");
- else if(size == 2)
+ else if (size == 2)
Error(ERR_DECLDATA_FLOAT, (char *)NULL, "DW");
break;
case DV_EXPR:
- if(size == 10)
+ if (size == 10)
Error(ERR_DECLDATA_EXPR, (char *)NULL, "DT");
break;
}
}
void
-BuildBC_Reserve (bytecode *bc,
- expr *numitems,
- unsigned long itemsize)
+BuildBC_Reserve(bytecode *bc, expr *numitems, unsigned long itemsize)
{
bc->next = (bytecode *)NULL;
bc->type = BC_RESERVE;
}
void
-DebugPrintBC (bytecode *bc)
+DebugPrintBC(bytecode *bc)
{
- switch(bc->type) {
+ switch (bc->type) {
case BC_EMPTY:
printf("_Empty_\n");
break;
else
expr_print(bc->data.insn.ea.disp);
printf("\n");
- printf (" Len=%u SegmentOv=%2x\n",
- (unsigned int)bc->data.insn.ea.len,
- (unsigned int)bc->data.insn.ea.segment);
+ printf(" Len=%u SegmentOv=%2x\n",
+ (unsigned int)bc->data.insn.ea.len,
+ (unsigned int)bc->data.insn.ea.segment);
printf(" ModRM=%2x ValidRM=%u NeedRM=%u\n",
- (unsigned int)bc->data.insn.ea.modrm,
- (unsigned int)bc->data.insn.ea.valid_modrm,
- (unsigned int)bc->data.insn.ea.need_modrm);
+ (unsigned int)bc->data.insn.ea.modrm,
+ (unsigned int)bc->data.insn.ea.valid_modrm,
+ (unsigned int)bc->data.insn.ea.need_modrm);
printf(" SIB=%2x ValidSIB=%u NeedSIB=%u\n",
- (unsigned int)bc->data.insn.ea.sib,
- (unsigned int)bc->data.insn.ea.valid_sib,
- (unsigned int)bc->data.insn.ea.need_sib);
+ (unsigned int)bc->data.insn.ea.sib,
+ (unsigned int)bc->data.insn.ea.valid_sib,
+ (unsigned int)bc->data.insn.ea.need_sib);
printf("Immediate Value:\n");
printf(" Val=");
if (!bc->data.insn.imm.val)
expr_print(bc->data.insn.imm.val);
printf("\n");
printf(" Len=%u, IsNeg=%u\n",
- (unsigned int)bc->data.insn.imm.len,
- (unsigned int)bc->data.insn.imm.isneg);
+ (unsigned int)bc->data.insn.imm.len,
+ (unsigned int)bc->data.insn.imm.isneg);
printf(" FLen=%u, FSign=%u\n",
- (unsigned int)bc->data.insn.imm.f_len,
- (unsigned int)bc->data.insn.imm.f_sign);
+ (unsigned int)bc->data.insn.imm.f_len,
+ (unsigned int)bc->data.insn.imm.f_sign);
printf("Opcode: %2x %2x %2x OpLen=%u\n",
- (unsigned int)bc->data.insn.opcode[0],
- (unsigned int)bc->data.insn.opcode[1],
- (unsigned int)bc->data.insn.opcode[2],
- (unsigned int)bc->data.insn.opcode_len);
+ (unsigned int)bc->data.insn.opcode[0],
+ (unsigned int)bc->data.insn.opcode[1],
+ (unsigned int)bc->data.insn.opcode[2],
+ (unsigned int)bc->data.insn.opcode_len);
printf("AddrSize=%u OperSize=%u LockRepPre=%2x\n",
- (unsigned int)bc->data.insn.addrsize,
- (unsigned int)bc->data.insn.opersize,
- (unsigned int)bc->data.insn.lockrep_pre);
+ (unsigned int)bc->data.insn.addrsize,
+ (unsigned int)bc->data.insn.opersize,
+ (unsigned int)bc->data.insn.lockrep_pre);
break;
case BC_JMPREL:
printf("_Relative Jump_\n");
printf("Target=");
expr_print(bc->data.jmprel.target);
printf("\nShort Form:\n");
- if(!bc->data.jmprel.shortop.valid)
+ if (!bc->data.jmprel.shortop.valid)
printf(" None\n");
else
printf(" Opcode: %2x %2x %2x OpLen=%u\n",
- (unsigned int)bc->data.jmprel.shortop.opcode[0],
- (unsigned int)bc->data.jmprel.shortop.opcode[1],
- (unsigned int)bc->data.jmprel.shortop.opcode[2],
- (unsigned int)bc->data.jmprel.shortop.opcode_len);
- if(!bc->data.jmprel.nearop.valid)
+ (unsigned int)bc->data.jmprel.shortop.opcode[0],
+ (unsigned int)bc->data.jmprel.shortop.opcode[1],
+ (unsigned int)bc->data.jmprel.shortop.opcode[2],
+ (unsigned int)bc->data.jmprel.shortop.opcode_len);
+ if (!bc->data.jmprel.nearop.valid)
printf(" None\n");
else
printf(" Opcode: %2x %2x %2x OpLen=%u\n",
- (unsigned int)bc->data.jmprel.nearop.opcode[0],
- (unsigned int)bc->data.jmprel.nearop.opcode[1],
- (unsigned int)bc->data.jmprel.nearop.opcode[2],
- (unsigned int)bc->data.jmprel.nearop.opcode_len);
+ (unsigned int)bc->data.jmprel.nearop.opcode[0],
+ (unsigned int)bc->data.jmprel.nearop.opcode[1],
+ (unsigned int)bc->data.jmprel.nearop.opcode[2],
+ (unsigned int)bc->data.jmprel.nearop.opcode_len);
printf("OpSel=");
- switch(bc->data.jmprel.op_sel) {
- case JR_NONE: printf("None"); break;
- case JR_SHORT: printf("Short"); break;
- case JR_NEAR: printf("Near"); break;
- case JR_SHORT_FORCED: printf("Forced Short"); break;
- case JR_NEAR_FORCED: printf("Forced Near"); break;
- default: printf("UNKNOWN!!"); break;
+ switch (bc->data.jmprel.op_sel) {
+ case JR_NONE:
+ printf("None");
+ break;
+ case JR_SHORT:
+ printf("Short");
+ break;
+ case JR_NEAR:
+ printf("Near");
+ break;
+ case JR_SHORT_FORCED:
+ printf("Forced Short");
+ break;
+ case JR_NEAR_FORCED:
+ printf("Forced Near");
+ break;
+ default:
+ printf("UNKNOWN!!");
+ break;
}
printf("\nAddrSize=%u OperSize=%u LockRepPre=%2x\n",
- (unsigned int)bc->data.jmprel.addrsize,
- (unsigned int)bc->data.jmprel.opersize,
- (unsigned int)bc->data.jmprel.lockrep_pre);
+ (unsigned int)bc->data.jmprel.addrsize,
+ (unsigned int)bc->data.jmprel.opersize,
+ (unsigned int)bc->data.jmprel.lockrep_pre);
break;
case BC_DATA:
printf("_Data_\n");
printf("Final Element Size=%u\n",
- (unsigned int)bc->data.data.size);
+ (unsigned int)bc->data.data.size);
printf("Elements:\n");
dataval_print(bc->data.data.data);
break;
printf("Num Items=");
expr_print(bc->data.reserve.numitems);
printf("\nItem Size=%u\n",
- (unsigned int)bc->data.reserve.itemsize);
+ (unsigned int)bc->data.reserve.itemsize);
break;
default:
printf("_Unknown_\n");
}
printf("Length=%lu\n", bc->len);
printf("Filename=\"%s\" Line Number=%u\n",
- bc->filename ? bc->filename : "<UNKNOWN>", bc->lineno);
+ bc->filename ? bc->filename : "<UNKNOWN>", bc->lineno);
printf("Offset=%lx BITS=%u\n", bc->offset, bc->mode_bits);
}
dataval *
-dataval_new_expr (expr *exp)
+dataval_new_expr(expr *exp)
{
dataval *retval = malloc(sizeof(dataval));
- if(!retval)
+ if (!retval)
Fatal(FATAL_NOMEM);
retval->next = (dataval *)NULL;
}
dataval *
-dataval_new_float (double float_val)
+dataval_new_float(double float_val)
{
dataval *retval = malloc(sizeof(dataval));
- if(!retval)
+ if (!retval)
Fatal(FATAL_NOMEM);
retval->next = (dataval *)NULL;
}
dataval *
-dataval_new_string (char *str_val)
+dataval_new_string(char *str_val)
{
dataval *retval = malloc(sizeof(dataval));
- if(!retval)
+ if (!retval)
Fatal(FATAL_NOMEM);
retval->next = (dataval *)NULL;
}
dataval *
-dataval_append (dataval *list, dataval *item)
+dataval_append(dataval *list, dataval *item)
{
- if(item)
+ if (item)
item->next = (dataval *)NULL;
- if(!list) {
+ if (!list) {
item->last = item;
return item;
} else {
- if(item) {
+ if (item) {
list->last->next = item;
list->last = item;
item->last = (dataval *)NULL;
}
void
-dataval_print (dataval *start)
+dataval_print(dataval *start)
{
dataval *cur = start;
- while(cur) {
- switch(cur->type) {
+ while (cur) {
+ switch (cur->type) {
case DV_EMPTY:
printf(" Empty\n");
break;
cur = cur->next;
}
}
-
-/* $Id: bytecode.h,v 1.15 2001/07/25 00:33:10 peter Exp $
+/* $Id: bytecode.h,v 1.16 2001/08/19 03:52:58 peter Exp $
* Bytecode utility functions header file
*
* Copyright (C) 2001 Peter Johnson
union {
struct {
- effaddr ea; /* effective address */
+ effaddr ea; /* effective address */
- immval imm; /* immediate or relative value */
+ immval imm; /* immediate or relative value */
unsigned char opcode[3]; /* opcode */
unsigned char opcode_len;
unsigned char lockrep_pre; /* 0 indicates no prefix */
} jmprel;
struct {
- dataval *data; /* non-converted data (linked list) */
+ dataval *data; /* non-converted data (linked list) */
/* final (converted) size of each element (in bytes) */
unsigned char size;
} reserve;
} data;
- unsigned long len; /* total length of entire bytecode */
+ unsigned long len; /* total length of entire bytecode */
/* where it came from */
char *filename;
unsigned char near_op2,
unsigned char addrsize);
-void BuildBC_Data(bytecode *bc,
- dataval *data,
- unsigned long size);
+void BuildBC_Data(bytecode *bc, dataval *data, unsigned long size);
void BuildBC_Reserve(bytecode *bc,
struct expr_s *numitems,
-/* $Id: errwarn.c,v 1.19 2001/08/18 23:05:37 peter Exp $
+/* $Id: errwarn.c,v 1.20 2001/08/19 03:52:58 peter Exp $
* Error and warning reporting and related functions.
*
* Copyright (C) 2001 Peter Johnson
/* Convert a possibly unprintable character into a printable string, using
* standard cat(1) convention for unprintable characters. */
char *
-conv_unprint (char ch)
+conv_unprint(char ch)
{
- int pos=0;
+ int pos = 0;
- if(((ch & ~0x7F) != 0)/*!isascii(ch)*/ && !isprint(ch)) {
+ if (((ch & ~0x7F) != 0) /*!isascii(ch)*/ && !isprint(ch)) {
unprint[pos++] = 'M';
unprint[pos++] = '-';
ch &= toascii(ch);
}
- if(iscntrl(ch)) {
+ if (iscntrl(ch)) {
unprint[pos++] = '^';
unprint[pos++] = (ch == '\177') ? '?' : ch | 0100;
} else
/* Parser error handler. Moves error into our error handling system. */
void
-yyerror (char *s)
+yyerror(char *s)
{
Error(ERR_PARSER, (char *)NULL, s);
}
/* Report an internal error. Essentially a fatal error with trace info.
* Exit immediately because it's essentially an assert() trap. */
void
-InternalError (unsigned int line, char *file, char *message)
+InternalError(unsigned int line, char *file, char *message)
{
fprintf(stderr, "INTERNAL ERROR at %s, line %d: %s\n", file, line,
- message);
+ message);
exit(EXIT_FAILURE);
}
/* Report a fatal error. These are unrecoverable (such as running out of
* memory), so just exit immediately. */
void
-Fatal (fatal_num num)
+Fatal(fatal_num num)
{
fprintf(stderr, "FATAL: %s\n", fatal_msgs[num]);
exit(EXIT_FAILURE);
* specified and NULL passed for the argtypes parameter when Error() is
* called. */
static char *
-process_argtypes (char *src, char *argtypes)
+process_argtypes(char *src, char *argtypes)
{
char *dest;
char *argtype[9];
int at_num;
char *destp, *srcp, *argtypep;
- if(argtypes) {
+ if (argtypes) {
dest = malloc(strlen(src) + strlen(argtypes));
- if(!dest)
+ if (!dest)
Fatal(FATAL_NOMEM);
/* split argtypes by % */
at_num = 0;
- while((argtypes = strchr(argtypes, '%')) && at_num < 9)
+ while ((argtypes = strchr(argtypes, '%')) && at_num < 9)
argtype[at_num++] = ++argtypes;
/* search through src for %, copying as we go */
destp = dest;
srcp = src;
- while(*srcp != '\0') {
+ while (*srcp != '\0') {
*(destp++) = *srcp;
- if(*(srcp++) == '%') {
- if(isdigit(*srcp)) {
+ if (*(srcp++) == '%') {
+ if (isdigit(*srcp)) {
/* %1, %2, etc */
- argtypep = argtype[*srcp-'1'];
- while((*argtypep != '%') && (*argtypep != '\0'))
+ argtypep = argtype[*srcp - '1'];
+ while ((*argtypep != '%') && (*argtypep != '\0'))
*(destp++) = *(argtypep++);
} else
*(destp++) = *srcp;
}
} else {
dest = strdup(src);
- if(!dest)
+ if (!dest)
Fatal(FATAL_NOMEM);
}
return dest;
* argument types. Does not print the error, only stores it for
* OutputError() to print. */
void
-Error (err_num num, char *argtypes, ...)
+Error(err_num num, char *argtypes, ...)
{
va_list ap;
char *printf_str;
- if((last_err_num != ERR_NONE) && (last_err_num != ERR_PARSER))
+ if ((last_err_num != ERR_NONE) && (last_err_num != ERR_PARSER))
return;
last_err_num = num;
* argument types. Does not print the warning, only stores it for
* OutputWarning() to print. */
void
-Warning (warn_num num, char *argtypes, ...)
+Warning(warn_num num, char *argtypes, ...)
{
va_list ap;
char *printf_str;
- if(last_warn_num != WARN_NONE)
+ if (last_warn_num != WARN_NONE)
return;
last_warn_num = num;
/* Output a previously stored error (if any) to stderr. */
void
-OutputError (void)
+OutputError(void)
{
- if(last_err_num != ERR_NONE)
+ if (last_err_num != ERR_NONE)
fprintf(stderr, "%s:%u: %s\n", filename, line_number, last_err);
last_err_num = ERR_NONE;
}
/* Output a previously stored warning (if any) to stderr. */
void
-OutputWarning (void)
+OutputWarning(void)
{
- if(last_warn_num != WARN_NONE)
+ if (last_warn_num != WARN_NONE)
fprintf(stderr, "%s:%u: warning: %s\n", filename, line_number,
- last_warn);
+ last_warn);
last_warn_num = WARN_NONE;
}
-
-/* $Id: expr.c,v 1.4 2001/07/11 23:16:50 peter Exp $
+/* $Id: expr.c,v 1.5 2001/08/19 03:52:58 peter Exp $
* Expression handling
*
* Copyright (C) 2001 Michael Urman
/* allocate a new expression node, with children as defined.
* If it's a unary operator, put the element on the right */
expr *
-expr_new (ExprType ltype,
- ExprItem left,
- ExprOp op,
- ExprType rtype,
- ExprItem right)
+expr_new(ExprType ltype,
+ ExprItem left,
+ ExprOp op,
+ ExprType rtype,
+ ExprItem right)
{
expr *ptr;
- ptr = malloc (sizeof (expr));
- if (ptr == NULL) Fatal (FATAL_NOMEM);
+ ptr = malloc(sizeof(expr));
+ if (ptr == NULL)
+ Fatal(FATAL_NOMEM);
ptr->ltype = ltype;
ptr->op = op;
ptr->rtype = rtype;
- switch (ltype)
- {
+ switch (ltype) {
case EXPR_NUM:
case EXPR_SYM:
case EXPR_EXPR:
- memcpy (&ptr->left, &left, sizeof (ExprItem));
+ memcpy(&ptr->left, &left, sizeof(ExprItem));
+ break;
+ case EXPR_NONE:
break;
- case EXPR_NONE: break;
}
- switch (rtype)
- {
+ switch (rtype) {
case EXPR_NUM:
case EXPR_SYM:
case EXPR_EXPR:
- memcpy (&ptr->right, &right, sizeof (ExprItem));
+ memcpy(&ptr->right, &right, sizeof(ExprItem));
break;
case EXPR_NONE:
- Fatal (FATAL_UNKNOWN); /* TODO: better error? */
+ Fatal(FATAL_UNKNOWN); /* TODO: better error? */
break;
}
return ptr;
/* helpers */
ExprItem
-ExprSym (struct symrec_s *s)
+ExprSym(struct symrec_s *s)
{
ExprItem e;
+
e.sym = s;
return e;
}
ExprItem
-ExprExpr (expr *x)
+ExprExpr(expr *x)
{
ExprItem e;
e.expr = x;
+
return e;
}
ExprItem
-ExprNum (unsigned long n)
+ExprNum(unsigned long n)
{
ExprItem e;
+
e.num = n;
return e;
}
ExprItem
-ExprNone (void)
+ExprNone(void)
{
ExprItem e;
+
e.num = 0;
return e;
}
/* get rid of unnecessary branches if possible. report. */
int
-expr_simplify (expr *e)
+expr_simplify(expr *e)
{
int simplified = 0;
/* try to simplify the left side */
- if (e->ltype == EXPR_EXPR)
- {
+ if (e->ltype == EXPR_EXPR) {
/* if the left subexpr isn't an IDENT, recurse simplification */
if (e->left.expr->op != EXPR_IDENT)
- simplified |= expr_simplify (e->left.expr);
+ simplified |= expr_simplify(e->left.expr);
/* if the left subexpr is just an IDENT (or string thereof),
* pull it up into the current node */
- while (e->ltype == EXPR_EXPR && e->left.expr->op == EXPR_IDENT)
- {
+ while (e->ltype == EXPR_EXPR && e->left.expr->op == EXPR_IDENT) {
ExprItem tmp;
e->ltype = e->left.expr->rtype;
- memcpy (&tmp, &(e->left.expr->right), sizeof (ExprItem));
- free (e->left.expr);
- memcpy (&(e->left.num), &tmp, sizeof (ExprItem));
+ memcpy(&tmp, &(e->left.expr->right), sizeof(ExprItem));
+ free(e->left.expr);
+ memcpy(&(e->left.num), &tmp, sizeof(ExprItem));
simplified = 1;
}
- }
- else if (e->ltype == EXPR_SYM)
- {
+ } else if (e->ltype == EXPR_SYM) {
/* if it's a symbol that has a defined value, turn it into a
* number */
- if (e->left.sym->status & SYM_VALUED)
- {
+ if (e->left.sym->status & SYM_VALUED) {
e->ltype = EXPR_NUM;
/* don't try to free the symrec here. */
e->left.num = e->left.sym->value;
}
/* ditto on the right */
- if (e->rtype == EXPR_EXPR)
- {
+ if (e->rtype == EXPR_EXPR) {
if (e->right.expr->op != EXPR_IDENT)
- simplified |= expr_simplify (e->right.expr);
+ simplified |= expr_simplify(e->right.expr);
- while (e->rtype == EXPR_EXPR && e->right.expr->op == EXPR_IDENT)
- {
+ while (e->rtype == EXPR_EXPR && e->right.expr->op == EXPR_IDENT) {
ExprItem tmp;
e->rtype = e->right.expr->rtype;
- memcpy (&tmp, &(e->right.expr->right), sizeof (ExprItem));
- free (e->right.expr);
- memcpy (&(e->right.num), &tmp, sizeof (ExprItem));
+ memcpy(&tmp, &(e->right.expr->right), sizeof(ExprItem));
+ free(e->right.expr);
+ memcpy(&(e->right.num), &tmp, sizeof(ExprItem));
simplified = 1;
}
- }
- else if (e->rtype == EXPR_SYM)
- {
- if (e->right.sym->status & SYM_VALUED)
- {
+ } else if (e->rtype == EXPR_SYM) {
+ if (e->right.sym->status & SYM_VALUED) {
e->rtype = EXPR_NUM;
/* don't try to free the symrec here. */
e->right.num = e->right.sym->value;
}
if ((e->ltype == EXPR_NUM || e->ltype == EXPR_NONE)
- && e->rtype == EXPR_NUM
- && e->op != EXPR_IDENT)
- {
- switch (e->op)
- {
- case EXPR_ADD: e->right.num = e->left.num + e->right.num; break;
- case EXPR_SUB: e->right.num = e->left.num - e->right.num; break;
- case EXPR_MUL: e->right.num = e->left.num * e->right.num; break;
- case EXPR_DIV: e->right.num = e->left.num / e->right.num; break;
- case EXPR_MOD: e->right.num = e->left.num % e->right.num; break;
- case EXPR_NEG: e->right.num = -(e->right.num); break;
- case EXPR_NOT: e->right.num = ~(e->right.num); break;
- case EXPR_OR: e->right.num = e->left.num | e->right.num; break;
- case EXPR_AND: e->right.num = e->left.num & e->right.num; break;
- case EXPR_XOR: e->right.num = e->left.num ^ e->right.num; break;
- case EXPR_SHL: e->right.num = e->right.num << e->left.num; break;
- case EXPR_SHR: e->right.num = e->right.num << e->left.num; break;
- case EXPR_LOR: e->right.num = e->left.num || e->right.num; break;
- case EXPR_LAND: e->right.num = e->left.num && e->right.num; break;
- case EXPR_LNOT: e->right.num = !e->right.num; break;
- case EXPR_EQ: e->right.num = e->right.num == e->left.num; break;
- case EXPR_LT: e->right.num = e->right.num < e->left.num; break;
- case EXPR_GT: e->right.num = e->right.num > e->left.num; break;
- case EXPR_LE: e->right.num = e->right.num <= e->left.num; break;
- case EXPR_GE: e->right.num = e->right.num >= e->left.num; break;
- case EXPR_NE: e->right.num = e->right.num != e->left.num; break;
- case EXPR_IDENT: break;
+ && e->rtype == EXPR_NUM && e->op != EXPR_IDENT) {
+ switch (e->op) {
+ case EXPR_ADD:
+ e->right.num = e->left.num + e->right.num;
+ break;
+ case EXPR_SUB:
+ e->right.num = e->left.num - e->right.num;
+ break;
+ case EXPR_MUL:
+ e->right.num = e->left.num * e->right.num;
+ break;
+ case EXPR_DIV:
+ e->right.num = e->left.num / e->right.num;
+ break;
+ case EXPR_MOD:
+ e->right.num = e->left.num % e->right.num;
+ break;
+ case EXPR_NEG:
+ e->right.num = -(e->right.num);
+ break;
+ case EXPR_NOT:
+ e->right.num = ~(e->right.num);
+ break;
+ case EXPR_OR:
+ e->right.num = e->left.num | e->right.num;
+ break;
+ case EXPR_AND:
+ e->right.num = e->left.num & e->right.num;
+ break;
+ case EXPR_XOR:
+ e->right.num = e->left.num ^ e->right.num;
+ break;
+ case EXPR_SHL:
+ e->right.num = e->right.num << e->left.num;
+ break;
+ case EXPR_SHR:
+ e->right.num = e->right.num << e->left.num;
+ break;
+ case EXPR_LOR:
+ e->right.num = e->left.num || e->right.num;
+ break;
+ case EXPR_LAND:
+ e->right.num = e->left.num && e->right.num;
+ break;
+ case EXPR_LNOT:
+ e->right.num = !e->right.num;
+ break;
+ case EXPR_EQ:
+ e->right.num = e->right.num == e->left.num;
+ break;
+ case EXPR_LT:
+ e->right.num = e->right.num < e->left.num;
+ break;
+ case EXPR_GT:
+ e->right.num = e->right.num > e->left.num;
+ break;
+ case EXPR_LE:
+ e->right.num = e->right.num <= e->left.num;
+ break;
+ case EXPR_GE:
+ e->right.num = e->right.num >= e->left.num;
+ break;
+ case EXPR_NE:
+ e->right.num = e->right.num != e->left.num;
+ break;
+ case EXPR_IDENT:
+ break;
}
e->op = EXPR_IDENT;
simplified = 1;
}
/* catch simple identities like 0+x, 1*x, etc., for x not a num */
- else if (e->ltype == EXPR_NUM
- && ((e->left.num == 1 && e->op == EXPR_MUL)
- ||(e->left.num == 0 && e->op == EXPR_ADD)
- ||(e->left.num == -1 && e->op == EXPR_AND)
- ||(e->left.num == 0 && e->op == EXPR_OR)))
- {
+ else if (e->ltype == EXPR_NUM && ((e->left.num == 1 && e->op == EXPR_MUL)
+ || (e->left.num == 0 &&
+ e->op == EXPR_ADD)
+ || (e->left.num == -1 &&
+ e->op == EXPR_AND)
+ || (e->left.num == 0 &&
+ e->op == EXPR_OR))) {
e->op = EXPR_IDENT;
simplified = 1;
}
/* and the corresponding x+|-0, x*&/1 */
- else if (e->rtype == EXPR_NUM
- && ((e->right.num == 1 && e->op == EXPR_MUL)
- ||(e->right.num == 1 && e->op == EXPR_DIV)
- ||(e->right.num == 0 && e->op == EXPR_ADD)
- ||(e->right.num == 0 && e->op == EXPR_SUB)
- ||(e->right.num == -1 && e->op == EXPR_AND)
- ||(e->right.num == 0 && e->op == EXPR_OR)
- ||(e->right.num == 0 && e->op == EXPR_SHL)
- ||(e->right.num == 0 && e->op == EXPR_SHR)))
- {
+ else if (e->rtype == EXPR_NUM && ((e->right.num == 1 && e->op == EXPR_MUL)
+ || (e->right.num == 1 &&
+ e->op == EXPR_DIV)
+ || (e->right.num == 0 &&
+ e->op == EXPR_ADD)
+ || (e->right.num == 0 &&
+ e->op == EXPR_SUB)
+ || (e->right.num == -1 &&
+ e->op == EXPR_AND)
+ || (e->right.num == 0 &&
+ e->op == EXPR_OR)
+ || (e->right.num == 0 &&
+ e->op == EXPR_SHL)
+ || (e->right.num == 0 &&
+ e->op == EXPR_SHR))) {
e->op = EXPR_IDENT;
e->rtype = e->ltype;
- memcpy (&e->right, &e->left, sizeof (ExprItem));
+ memcpy(&e->right, &e->left, sizeof(ExprItem));
simplified = 1;
}
}
int
-expr_get_value (expr *e, unsigned long *retval)
+expr_get_value(expr *e, unsigned long *retval)
{
while (!(e->op == EXPR_IDENT && e->rtype == EXPR_NUM)
- && expr_simplify (e));
+ && expr_simplify(e)) ;
- if (e->op == EXPR_IDENT && e->rtype == EXPR_NUM)
- {
+ if (e->op == EXPR_IDENT && e->rtype == EXPR_NUM) {
*retval = e->right.num;
return 1;
- }
- else
+ } else
return 0;
}
void
-expr_print (expr *e)
+expr_print(expr *e)
{
if (e->op != EXPR_IDENT) {
switch (e->ltype) {
- case EXPR_NUM: printf ("%lu", e->left.num); break;
- case EXPR_SYM: printf ("%s", e->left.sym->name); break;
- case EXPR_EXPR: printf ("("); expr_print (e->left.expr); printf(")");
- case EXPR_NONE: break;
+ case EXPR_NUM:
+ printf("%lu", e->left.num);
+ break;
+ case EXPR_SYM:
+ printf("%s", e->left.sym->name);
+ break;
+ case EXPR_EXPR:
+ printf("(");
+ expr_print(e->left.expr);
+
+ printf(")");
+ case EXPR_NONE:
+ break;
}
}
switch (e->op) {
- case EXPR_ADD: printf ("+"); break;
- case EXPR_SUB: printf ("-"); break;
- case EXPR_MUL: printf ("*"); break;
- case EXPR_DIV: printf ("/"); break;
- case EXPR_MOD: printf ("%%"); break;
- case EXPR_NEG: printf ("-"); break;
- case EXPR_NOT: printf ("~"); break;
- case EXPR_OR: printf ("|"); break;
- case EXPR_AND: printf ("&"); break;
- case EXPR_XOR: printf ("^"); break;
- case EXPR_SHL: printf ("<<"); break;
- case EXPR_SHR: printf (">>"); break;
- case EXPR_LOR: printf ("||"); break;
- case EXPR_LAND: printf ("&&"); break;
- case EXPR_LNOT: printf ("!"); break;
- case EXPR_LT: printf ("<"); break;
- case EXPR_GT: printf (">"); break;
- case EXPR_LE: printf ("<="); break;
- case EXPR_GE: printf (">="); break;
- case EXPR_NE: printf ("!="); break;
- case EXPR_EQ: printf ("=="); break;
- case EXPR_IDENT: break;
+ case EXPR_ADD:
+ printf("+");
+ break;
+ case EXPR_SUB:
+ printf("-");
+ break;
+ case EXPR_MUL:
+ printf("*");
+ break;
+ case EXPR_DIV:
+ printf("/");
+ break;
+ case EXPR_MOD:
+ printf("%%");
+ break;
+ case EXPR_NEG:
+ printf("-");
+ break;
+ case EXPR_NOT:
+ printf("~");
+ break;
+ case EXPR_OR:
+ printf("|");
+ break;
+ case EXPR_AND:
+ printf("&");
+ break;
+ case EXPR_XOR:
+ printf("^");
+ break;
+ case EXPR_SHL:
+ printf("<<");
+ break;
+ case EXPR_SHR:
+ printf(">>");
+ break;
+ case EXPR_LOR:
+ printf("||");
+ break;
+ case EXPR_LAND:
+ printf("&&");
+ break;
+ case EXPR_LNOT:
+ printf("!");
+ break;
+ case EXPR_LT:
+ printf("<");
+ break;
+ case EXPR_GT:
+ printf(">");
+ break;
+ case EXPR_LE:
+ printf("<=");
+ break;
+ case EXPR_GE:
+ printf(">=");
+ break;
+ case EXPR_NE:
+ printf("!=");
+ break;
+ case EXPR_EQ:
+ printf("==");
+ break;
+ case EXPR_IDENT:
+ break;
}
switch (e->rtype) {
- case EXPR_NUM: printf ("%lu", e->right.num); break;
- case EXPR_SYM: printf ("%s", e->right.sym->name); break;
- case EXPR_EXPR: printf ("("); expr_print (e->right.expr); printf(")");
- case EXPR_NONE: break;
+ case EXPR_NUM:
+ printf("%lu", e->right.num);
+ break;
+ case EXPR_SYM:
+ printf("%s", e->right.sym->name);
+ break;
+ case EXPR_EXPR:
+ printf("(");
+ expr_print(e->right.expr);
+
+ printf(")");
+ case EXPR_NONE:
+ break;
}
}
-/* $Id: expr.h,v 1.4 2001/07/11 23:16:50 peter Exp $
+/* $Id: expr.h,v 1.5 2001/08/19 03:52:58 peter Exp $
* Expression handling header file
*
* Copyright (C) 2001 Michael Urman
EXPR_LE,
EXPR_GE,
EXPR_NE,
- EXPR_IDENT /* if right is IDENT, then the entire expr is just a num */
+ EXPR_IDENT /* if right is IDENT, then the entire expr is just a num */
} ExprOp;
typedef enum {
- EXPR_NONE, /* for left side of a NOT, NEG, etc. */
+ EXPR_NONE, /* for left side of a NOT, NEG, etc. */
EXPR_NUM,
EXPR_EXPR,
EXPR_SYM
ExprOp op;
} expr;
-expr *expr_new (ExprType, ExprItem, ExprOp, ExprType, ExprItem);
+expr *expr_new(ExprType, ExprItem, ExprOp, ExprType, ExprItem);
-ExprItem ExprSym (struct symrec_s *);
-ExprItem ExprExpr (expr *);
-ExprItem ExprNum (unsigned long);
-ExprItem ExprNone (void);
+ExprItem ExprSym(struct symrec_s *);
+ExprItem ExprExpr(expr *);
+ExprItem ExprNum(unsigned long);
+ExprItem ExprNone(void);
#define expr_new_tree(l,o,r) \
expr_new (EXPR_EXPR, ExprExpr(l), (o), EXPR_EXPR, ExprExpr(r))
#define expr_new_ident(t,r) \
expr_new (EXPR_NONE, ExprNone(), EXPR_IDENT, (ExprType)(t), (r))
-int expr_simplify (expr *);
-void expr_print (expr *);
+int expr_simplify(expr *);
+void expr_print(expr *);
/* get the value if possible. return value is IF POSSIBLE, not the val */
-int expr_get_value (expr *, unsigned long *);
+int expr_get_value(expr *, unsigned long *);
#endif
-/* $Id: main.c,v 1.6 2001/08/19 02:15:18 peter Exp $
+/* $Id: main.c,v 1.7 2001/08/19 03:52:58 peter Exp $
* Program entry point, command line parsing
*
* Copyright (C) 2001 Peter Johnson
unsigned int mode_bits = 32;
int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
{
FILE *in;
- if(argc==2) {
+ if (argc == 2) {
in = fopen(argv[1], "rt");
- if(!in) {
+ if (!in) {
fprintf(stderr, "could not open file `%s'\n", argv[1]);
return EXIT_FAILURE;
}
nasm_parser.doparse(&raw_preproc, &dbg_outfmt, in);
- if(filename)
+ if (filename)
free(filename);
return EXIT_SUCCESS;
}
-
-/* $Id: objfmt.h,v 1.1 2001/08/19 02:15:18 peter Exp $
+/* $Id: objfmt.h,v 1.2 2001/08/19 03:52:58 peter Exp $
* Output format module interface header file
*
* Copyright (C) 2001 Peter Johnson
/* Interface to the output format module(s) */
typedef struct outfmt_s {
- char *name; /* one-line description of the format */
- char *keyword; /* keyword used to select format on the command line */
+ /* one-line description of the format */
+ char *name;
+
+ /* keyword used to select format on the command line */
+ char *keyword;
/* NULL-terminated list of debugging formats that are valid to use with
* this output format.
-/* $Id: outfmt.h,v 1.1 2001/08/19 02:15:18 peter Exp $
+/* $Id: outfmt.h,v 1.2 2001/08/19 03:52:58 peter Exp $
* Output format module interface header file
*
* Copyright (C) 2001 Peter Johnson
/* Interface to the output format module(s) */
typedef struct outfmt_s {
- char *name; /* one-line description of the format */
- char *keyword; /* keyword used to select format on the command line */
+ /* one-line description of the format */
+ char *name;
+
+ /* keyword used to select format on the command line */
+ char *keyword;
/* NULL-terminated list of debugging formats that are valid to use with
* this output format.
-/* $Id: parser.h,v 1.1 2001/08/19 02:15:18 peter Exp $
+/* $Id: parser.h,v 1.2 2001/08/19 03:52:58 peter Exp $
* Parser module interface header file
*
* Copyright (C) 2001 Peter Johnson
/* Interface to the parser module(s) -- the "front end" of the assembler */
typedef struct parser_s {
- char *name; /* one-line description of the parser */
- char *keyword; /* keyword used to select parser on the command line */
+ /* one-line description of the parser */
+ char *name;
+
+ /* keyword used to select parser on the command line */
+ char *keyword;
/* NULL-terminated list of preprocessors that are valid to use with this
* parser. The raw preprocessor (raw_preproc) should always be in this
* Note that calling this has many side effects in the output format
* module: sections and variables are declared, etc.
*/
- section * (*doparse) (preproc *pp, outfmt *of, FILE *f);
+ section *(*doparse) (preproc *pp, outfmt *of, FILE *f);
} parser;
/* Available parsers */
-/* $Id: preproc.h,v 1.1 2001/08/19 02:15:18 peter Exp $
+/* $Id: preproc.h,v 1.2 2001/08/19 03:52:58 peter Exp $
* Preprocessor module interface header file
*
* Copyright (C) 2001 Peter Johnson
/* Interface to the preprocesor module(s) */
typedef struct preproc_s {
- char *name; /* one-line description of the preprocessor */
+ /* one-line description of the preprocessor */
+ char *name;
/* keyword used to select preprocessor on the command line */
- char *keyword;
+ char *keyword;
/* Initializes preprocessor.
*
-/* $Id: preproc.c,v 1.2 2001/08/19 02:50:14 peter Exp $
+/* $Id: preproc.c,v 1.3 2001/08/19 03:52:58 peter Exp $
* Raw preprocessor (preforms NO preprocessing)
*
* Copyright (C) 2001 Peter Johnson
{
int c = '*', n;
- if(is_interactive) {
- for(n = 0; n < max_size && (c = getc(in)) != EOF && c != '\n'; n++)
- buf[n] = (char) c;
- if(c == '\n')
- buf[n++] = (char) c;
- if(c == EOF && ferror(in))
+ if (is_interactive) {
+ for (n = 0; n < max_size && (c = getc(in)) != EOF && c != '\n'; n++)
+ buf[n] = (char)c;
+ if (c == '\n')
+ buf[n++] = (char)c;
+ if (c == EOF && ferror(in))
Error(ERR_FILE_READ, (char *)NULL);
- } else if(((n = fread(buf, 1, max_size, in)) == 0) && ferror(in))
+ } else if (((n = fread(buf, 1, max_size, in)) == 0) && ferror(in))
Error(ERR_FILE_READ, (char *)NULL);
return n;
-/* $Id: raw-preproc.c,v 1.2 2001/08/19 02:50:14 peter Exp $
+/* $Id: raw-preproc.c,v 1.3 2001/08/19 03:52:58 peter Exp $
* Raw preprocessor (preforms NO preprocessing)
*
* Copyright (C) 2001 Peter Johnson
{
int c = '*', n;
- if(is_interactive) {
- for(n = 0; n < max_size && (c = getc(in)) != EOF && c != '\n'; n++)
- buf[n] = (char) c;
- if(c == '\n')
- buf[n++] = (char) c;
- if(c == EOF && ferror(in))
+ if (is_interactive) {
+ for (n = 0; n < max_size && (c = getc(in)) != EOF && c != '\n'; n++)
+ buf[n] = (char)c;
+ if (c == '\n')
+ buf[n++] = (char)c;
+ if (c == EOF && ferror(in))
Error(ERR_FILE_READ, (char *)NULL);
- } else if(((n = fread(buf, 1, max_size, in)) == 0) && ferror(in))
+ } else if (((n = fread(buf, 1, max_size, in)) == 0) && ferror(in))
Error(ERR_FILE_READ, (char *)NULL);
return n;
-/* $Id: section.h,v 1.4 2001/08/19 02:54:20 peter Exp $
+/* $Id: section.h,v 1.5 2001/08/19 03:52:58 peter Exp $
* Section header file
*
* Copyright (C) 2001 Peter Johnson
unsigned long start;
} data;
- bytecode *bc; /* the bytecodes for the section's contents */
+ bytecode *bc; /* the bytecodes for the section's contents */
} section;
#endif
-/* $Id: symrec.c,v 1.5 2001/07/11 23:16:50 peter Exp $
+/* $Id: symrec.c,v 1.6 2001/08/19 03:52:58 peter Exp $
* Symbol table handling
*
* Copyright (C) 2001 Michael Urman
#include "errwarn.h"
/* private functions */
-static symtab *symtab_get (char *);
-static symtab *symtab_new (char *, SymType);
-static symtab *symtab_get_or_new (char *, SymType);
-static void symtab_insert (symtab *);
+static symtab *symtab_get(char *);
+static symtab *symtab_new(char *, SymType);
+static symtab *symtab_get_or_new(char *, SymType);
+static void symtab_insert(symtab *);
/* The symbol table: a chain of `symtab'. */
symtab *sym_table = (symtab *)NULL;
/* insert a symtab into the global sym_table */
void
-symtab_insert (symtab *tab)
+symtab_insert(symtab *tab)
{
tab->next = (symtab *)sym_table;
sym_table = tab;
/* find a symtab in the global sym_table */
symtab *
-symtab_get (char *name)
+symtab_get(char *name)
{
symtab *tab;
- for (tab = sym_table; tab != NULL; tab = tab->next)
- {
- if (strcmp (tab->rec.name, name) == 0)
- {
+
+ for (tab = sym_table; tab != NULL; tab = tab->next) {
+ if (strcmp(tab->rec.name, name) == 0) {
return tab;
}
}
/* call a function with each symrec. stop early if 0 returned */
void
-sym_foreach (int(*mapfunc)(symrec *))
+sym_foreach(int (*mapfunc) (symrec *))
{
symtab *tab;
- for (tab = sym_table; tab != NULL; tab = tab->next)
- {
- if (mapfunc(&(tab->rec)) == 0)
- {
+
+ for (tab = sym_table; tab != NULL; tab = tab->next) {
+ if (mapfunc(&(tab->rec)) == 0) {
return;
}
}
/* create a new symtab */
symtab *
-symtab_new (char *name, SymType type)
+symtab_new(char *name, SymType type)
{
symtab *tab;
tab = malloc(sizeof(symtab));
- if (tab == NULL) return NULL;
- tab->rec.name = malloc(strlen(name)+1);
- if (tab->rec.name == NULL)
- {
- free (tab);
+ if (tab == NULL)
+ return NULL;
+ tab->rec.name = malloc(strlen(name) + 1);
+ if (tab->rec.name == NULL) {
+ free(tab);
return NULL;
}
strcpy(tab->rec.name, name);
tab->rec.value = 0;
tab->rec.line = line_number;
tab->rec.status = SYM_NOSTATUS;
- symtab_insert (tab);
+ symtab_insert(tab);
return tab;
}
symtab *
-symtab_get_or_new (char *name, SymType type)
+symtab_get_or_new(char *name, SymType type)
{
symtab *tab;
- tab = symtab_get (name);
- if (tab == NULL)
- {
- tab = symtab_new (name, type);
- if (tab == NULL)
- {
- Fatal (FATAL_NOMEM);
+
+ tab = symtab_get(name);
+ if (tab == NULL) {
+ tab = symtab_new(name, type);
+ if (tab == NULL) {
+ Fatal(FATAL_NOMEM);
}
}
return tab;
}
symrec *
-sym_use_get (char *name, SymType type)
+sym_use_get(char *name, SymType type)
{
symtab *tab;
- tab = symtab_get_or_new (name, type);
+
+ tab = symtab_get_or_new(name, type);
tab->rec.status |= SYM_USED;
return &(tab->rec);
}
symrec *
-sym_def_get (char *name, SymType type)
+sym_def_get(char *name, SymType type)
{
symtab *tab;
- tab = symtab_get_or_new (name, type);
+
+ tab = symtab_get_or_new(name, type);
if (tab->rec.status & SYM_DECLARED)
- Error (ERR_DUPLICATE_DEF, "%s%d", tab->rec.name, tab->rec.line);
+ Error(ERR_DUPLICATE_DEF, "%s%d", tab->rec.name, tab->rec.line);
tab->rec.status |= SYM_DECLARED;
return &(tab->rec);
}
#if 0
symrec *
-putsym (char *sym_name, int sym_type)
+putsym(char *sym_name, int sym_type)
{
symrec *ptr;
ptr = malloc(sizeof(symrec));
- ptr->name = malloc(strlen(sym_name)+1);
+ ptr->name = malloc(strlen(sym_name) + 1);
strcpy(ptr->name, sym_name);
ptr->type = sym_type;
- ptr->value.var = 0; /* set value to 0 even if fctn. */
+ ptr->value.var = 0; /* set value to 0 even if fctn. */
ptr->next = (symrec *)sym_table;
sym_table = ptr;
return ptr;
}
symrec *
-getsym (char *sym_name)
+getsym(char *sym_name)
{
symrec *ptr;
- for(ptr=sym_table; ptr != (symrec *)NULL; ptr=(symrec *)ptr->next)
- if(strcmp(ptr->name, sym_name) == 0)
+
+ for (ptr = sym_table; ptr != (symrec *)NULL; ptr = (symrec *)ptr->next)
+ if (strcmp(ptr->name, sym_name) == 0)
return ptr;
return 0;
}
-#endif /* 0 */
+#endif /* 0 */
-/* $Id: symrec.h,v 1.5 2001/07/11 21:16:22 peter Exp $
+/* $Id: symrec.h,v 1.6 2001/08/19 03:52:58 peter Exp $
* Symbol table handling header file
*
* Copyright (C) 2001 Michael Urman
typedef enum {
SYM_NOSTATUS = 0,
- SYM_USED = 1 << 0, /* for using variables before declared */
- SYM_DECLARED = 1 << 1, /* once it's been declared */
- SYM_VALUED = 1 << 2 /* once its value has been determined */
+ SYM_USED = 1 << 0, /* for using variables before declared */
+ SYM_DECLARED = 1 << 1, /* once it's been declared */
+ SYM_VALUED = 1 << 2 /* once its value has been determined */
} SymStatus;
typedef enum {
- SYM_CONSTANT, /* for EQU defined symbols */
- SYM_LABEL /* for labels */
+ SYM_CONSTANT, /* for EQU defined symbols */
+ SYM_LABEL /* for labels */
} SymType;
typedef struct symrec_s {
/*symrec *putsym(char *, SymType);*/
/*symrec *getsym(char *);*/
-symrec *sym_use_get (char *, SymType);
-symrec *sym_def_get (char *, SymType);
-void sym_foreach (int(*)(symrec *));
+symrec *sym_use_get(char *, SymType);
+symrec *sym_def_get(char *, SymType);
+void sym_foreach(int (*)(symrec *));
#endif
projects / yasm / commitdiff