int stdscan(void *private_data, struct tokenval *tv) { char ourcopy[MAX_KEYWORD + 1], *r, *s; (void)private_data; /* Don't warn that this parameter is unused */ stdscan_bufptr = nasm_skip_spaces(stdscan_bufptr); if (!*stdscan_bufptr) return tv->t_type = TOKEN_EOS; /* we have a token; either an id, a number or a char */ if (isidstart(*stdscan_bufptr) || (*stdscan_bufptr == '$' && isidstart(stdscan_bufptr[1]))) { /* now we've got an identifier */ bool is_sym = false; int token_type; if (*stdscan_bufptr == '$') { is_sym = true; stdscan_bufptr++; } r = stdscan_bufptr++; /* read the entire buffer to advance the buffer pointer but... */ while (isidchar(*stdscan_bufptr)) stdscan_bufptr++; /* ... copy only up to IDLEN_MAX-1 characters */ tv->t_charptr = stdscan_copy(r, stdscan_bufptr - r < IDLEN_MAX ? stdscan_bufptr - r : IDLEN_MAX - 1); if (is_sym || stdscan_bufptr - r > MAX_KEYWORD) return tv->t_type = TOKEN_ID; /* bypass all other checks */ for (s = tv->t_charptr, r = ourcopy; *s; s++) *r++ = nasm_tolower(*s); *r = '\0'; /* right, so we have an identifier sitting in temp storage. now, * is it actually a register or instruction name, or what? */ token_type = nasm_token_hash(ourcopy, tv); if (likely(!(tv->t_flag & TFLAG_BRC))) { /* most of the tokens fall into this case */ return token_type; } else { return tv->t_type = TOKEN_ID; } } else if (*stdscan_bufptr == '$' && !isnumchar(stdscan_bufptr[1])) { /* * It's a $ sign with no following hex number; this must * mean it's a Here token ($), evaluating to the current * assembly location, or a Base token ($$), evaluating to * the base of the current segment. */ stdscan_bufptr++; if (*stdscan_bufptr == '$') { stdscan_bufptr++; return tv->t_type = TOKEN_BASE; } return tv->t_type = TOKEN_HERE; } else if (isnumstart(*stdscan_bufptr)) { /* now we've got a number */ bool rn_error; bool is_hex = false; bool is_float = false; bool has_e = false; char c; r = stdscan_bufptr; if (*stdscan_bufptr == '$') { stdscan_bufptr++; is_hex = true; } for (;;) { c = *stdscan_bufptr++; if (!is_hex && (c == 'e' || c == 'E')) { has_e = true; if (*stdscan_bufptr == '+' || *stdscan_bufptr == '-') { /* * e can only be followed by +/- if it is either a * prefixed hex number or a floating-point number */ is_float = true; stdscan_bufptr++; } } else if (c == 'H' || c == 'h' || c == 'X' || c == 'x') { is_hex = true; } else if (c == 'P' || c == 'p') { is_float = true; if (*stdscan_bufptr == '+' || *stdscan_bufptr == '-') stdscan_bufptr++; } else if (isnumchar(c) || c == '_') ; /* just advance */ else if (c == '.') is_float = true; else break; } stdscan_bufptr--; /* Point to first character beyond number */ if (has_e && !is_hex) { /* 1e13 is floating-point, but 1e13h is not */ is_float = true; } if (is_float) { tv->t_charptr = stdscan_copy(r, stdscan_bufptr - r); return tv->t_type = TOKEN_FLOAT; } else { r = stdscan_copy(r, stdscan_bufptr - r); tv->t_integer = readnum(r, &rn_error); stdscan_pop(); if (rn_error) { /* some malformation occurred */ return tv->t_type = TOKEN_ERRNUM; } tv->t_charptr = NULL; return tv->t_type = TOKEN_NUM; } } else if (*stdscan_bufptr == '\'' || *stdscan_bufptr == '"' || *stdscan_bufptr == '`') { /* a quoted string */ char start_quote = *stdscan_bufptr; tv->t_charptr = stdscan_bufptr; tv->t_inttwo = nasm_unquote(tv->t_charptr, &stdscan_bufptr); if (*stdscan_bufptr != start_quote) return tv->t_type = TOKEN_ERRSTR; stdscan_bufptr++; /* Skip final quote */ return tv->t_type = TOKEN_STR; } else if (*stdscan_bufptr == '{') { /* now we've got a decorator */ int token_len; stdscan_bufptr = nasm_skip_spaces(stdscan_bufptr); r = ++stdscan_bufptr; /* * read the entire buffer to advance the buffer pointer * {rn-sae}, {rd-sae}, {ru-sae}, {rz-sae} contain '-' in tokens. */ while (isbrcchar(*stdscan_bufptr)) stdscan_bufptr++; token_len = stdscan_bufptr - r; /* ... copy only up to DECOLEN_MAX-1 characters */ tv->t_charptr = stdscan_copy(r, token_len < DECOLEN_MAX ? token_len : DECOLEN_MAX - 1); stdscan_bufptr = nasm_skip_spaces(stdscan_bufptr); /* if brace is not closed properly or token is too long */ if ((*stdscan_bufptr != '}') || (token_len > MAX_KEYWORD)) { nasm_error(ERR_NONFATAL, "invalid decorator token inside braces"); return tv->t_type = TOKEN_INVALID; } stdscan_bufptr++; /* skip closing brace */ for (s = tv->t_charptr, r = ourcopy; *s; s++) *r++ = nasm_tolower(*s); *r = '\0'; /* right, so we have a decorator sitting in temp storage. */ nasm_token_hash(ourcopy, tv); /* handle tokens inside braces */ return stdscan_handle_brace(tv); } else if (*stdscan_bufptr == ';') { /* a comment has happened - stay */ return tv->t_type = TOKEN_EOS; } else if (stdscan_bufptr[0] == '>' && stdscan_bufptr[1] == '>') { stdscan_bufptr += 2; return tv->t_type = TOKEN_SHR; } else if (stdscan_bufptr[0] == '<' && stdscan_bufptr[1] == '<') { stdscan_bufptr += 2; return tv->t_type = TOKEN_SHL; } else if (stdscan_bufptr[0] == '/' && stdscan_bufptr[1] == '/') { stdscan_bufptr += 2; return tv->t_type = TOKEN_SDIV; } else if (stdscan_bufptr[0] == '%' && stdscan_bufptr[1] == '%') { stdscan_bufptr += 2; return tv->t_type = TOKEN_SMOD; } else if (stdscan_bufptr[0] == '=' && stdscan_bufptr[1] == '=') { stdscan_bufptr += 2; return tv->t_type = TOKEN_EQ; } else if (stdscan_bufptr[0] == '<' && stdscan_bufptr[1] == '>') { stdscan_bufptr += 2; return tv->t_type = TOKEN_NE; } else if (stdscan_bufptr[0] == '!' && stdscan_bufptr[1] == '=') { stdscan_bufptr += 2; return tv->t_type = TOKEN_NE; } else if (stdscan_bufptr[0] == '<' && stdscan_bufptr[1] == '=') { stdscan_bufptr += 2; return tv->t_type = TOKEN_LE; } else if (stdscan_bufptr[0] == '>' && stdscan_bufptr[1] == '=') { stdscan_bufptr += 2; return tv->t_type = TOKEN_GE; } else if (stdscan_bufptr[0] == '&' && stdscan_bufptr[1] == '&') { stdscan_bufptr += 2; return tv->t_type = TOKEN_DBL_AND; } else if (stdscan_bufptr[0] == '^' && stdscan_bufptr[1] == '^') { stdscan_bufptr += 2; return tv->t_type = TOKEN_DBL_XOR; } else if (stdscan_bufptr[0] == '|' && stdscan_bufptr[1] == '|') { stdscan_bufptr += 2; return tv->t_type = TOKEN_DBL_OR; } else /* just an ordinary char */ return tv->t_type = (uint8_t)(*stdscan_bufptr++); }
int main(int argc, char **argv) { char buffer[INSN_MAX * 2], *p, *ep, *q; char outbuf[256]; char *pname = *argv; char *filename = NULL; uint32_t nextsync, synclen, initskip = 0L; int lenread; int32_t lendis; bool autosync = false; int bits = 16, b; bool eof = false; iflag_t prefer; bool rn_error; int64_t offset; FILE *fp; nasm_ctype_init(); nasm_set_verror(ndisasm_verror); iflag_clear_all(&prefer); offset = 0; init_sync(); while (--argc) { char *v, *vv, *p = *++argv; if (*p == '-' && p[1]) { p++; while (*p) switch (nasm_tolower(*p)) { case 'a': /* auto or intelligent sync */ case 'i': autosync = true; p++; break; case 'h': fputs(help, stderr); return 0; case 'r': case 'v': fprintf(stderr, "NDISASM version %s compiled on %s\n", nasm_version, nasm_date); return 0; case 'u': /* -u for -b 32, -uu for -b 64 */ if (bits < 64) bits <<= 1; p++; break; case 'b': /* bits */ v = p[1] ? p + 1 : --argc ? *++argv : NULL; if (!v) { fprintf(stderr, "%s: `-b' requires an argument\n", pname); return 1; } b = strtoul(v, &ep, 10); if (*ep || !(bits == 16 || bits == 32 || bits == 64)) { fprintf(stderr, "%s: argument to `-b' should" " be 16, 32 or 64\n", pname); } else { bits = b; } p = ""; /* force to next argument */ break; case 'o': /* origin */ v = p[1] ? p + 1 : --argc ? *++argv : NULL; if (!v) { fprintf(stderr, "%s: `-o' requires an argument\n", pname); return 1; } offset = readnum(v, &rn_error); if (rn_error) { fprintf(stderr, "%s: `-o' requires a numeric argument\n", pname); return 1; } p = ""; /* force to next argument */ break; case 's': /* sync point */ v = p[1] ? p + 1 : --argc ? *++argv : NULL; if (!v) { fprintf(stderr, "%s: `-s' requires an argument\n", pname); return 1; } add_sync(readnum(v, &rn_error), 0L); if (rn_error) { fprintf(stderr, "%s: `-s' requires a numeric argument\n", pname); return 1; } p = ""; /* force to next argument */ break; case 'e': /* skip a header */ v = p[1] ? p + 1 : --argc ? *++argv : NULL; if (!v) { fprintf(stderr, "%s: `-e' requires an argument\n", pname); return 1; } initskip = readnum(v, &rn_error); if (rn_error) { fprintf(stderr, "%s: `-e' requires a numeric argument\n", pname); return 1; } p = ""; /* force to next argument */ break; case 'k': /* skip a region */ v = p[1] ? p + 1 : --argc ? *++argv : NULL; if (!v) { fprintf(stderr, "%s: `-k' requires an argument\n", pname); return 1; } vv = strchr(v, ','); if (!vv) { fprintf(stderr, "%s: `-k' requires two numbers separated" " by a comma\n", pname); return 1; } *vv++ = '\0'; nextsync = readnum(v, &rn_error); if (rn_error) { fprintf(stderr, "%s: `-k' requires numeric arguments\n", pname); return 1; } synclen = readnum(vv, &rn_error); if (rn_error) { fprintf(stderr, "%s: `-k' requires numeric arguments\n", pname); return 1; } add_sync(nextsync, synclen); p = ""; /* force to next argument */ break; case 'p': /* preferred vendor */ v = p[1] ? p + 1 : --argc ? *++argv : NULL; if (!v) { fprintf(stderr, "%s: `-p' requires an argument\n", pname); return 1; } if (!strcmp(v, "intel")) { iflag_clear_all(&prefer); /* default */ } else if (!strcmp(v, "amd")) { iflag_clear_all(&prefer); iflag_set(&prefer, IF_AMD); iflag_set(&prefer, IF_3DNOW); } else if (!strcmp(v, "cyrix")) { iflag_clear_all(&prefer); iflag_set(&prefer, IF_CYRIX); iflag_set(&prefer, IF_3DNOW); } else if (!strcmp(v, "idt") || !strcmp(v, "centaur") || !strcmp(v, "winchip")) { iflag_clear_all(&prefer); iflag_set(&prefer, IF_3DNOW); } else { fprintf(stderr, "%s: unknown vendor `%s' specified with `-p'\n", pname, v); return 1; } p = ""; /* force to next argument */ break; default: /*bf */ fprintf(stderr, "%s: unrecognised option `-%c'\n", pname, *p); return 1; } } else if (!filename) { filename = p; } else { fprintf(stderr, "%s: more than one filename specified\n", pname); return 1; } } if (!filename) { fprintf(stderr, help, pname); return 0; } if (strcmp(filename, "-")) { fp = fopen(filename, "rb"); if (!fp) { fprintf(stderr, "%s: unable to open `%s': %s\n", pname, filename, strerror(errno)); return 1; } } else fp = stdin; if (initskip > 0) skip(initskip, fp); /* * This main loop is really horrible, and wants rewriting with * an axe. It'll stay the way it is for a while though, until I * find the energy... */ p = q = buffer; nextsync = next_sync(offset, &synclen); do { uint32_t to_read = buffer + sizeof(buffer) - p; if ((nextsync || synclen) && to_read > nextsync - offset - (p - q)) to_read = nextsync - offset - (p - q); if (to_read) { lenread = fread(p, 1, to_read, fp); if (lenread == 0) eof = true; /* help along systems with bad feof */ } else lenread = 0; p += lenread; if ((nextsync || synclen) && (uint32_t)offset == nextsync) { if (synclen) { fprintf(stdout, "%08"PRIX64" skipping 0x%"PRIX32" bytes\n", offset, synclen); offset += synclen; skip(synclen, fp); } p = q = buffer; nextsync = next_sync(offset, &synclen); } while (p > q && (p - q >= INSN_MAX || lenread == 0)) { lendis = disasm((uint8_t *)q, INSN_MAX, outbuf, sizeof(outbuf), bits, offset, autosync, &prefer); if (!lendis || lendis > (p - q) || ((nextsync || synclen) && (uint32_t)lendis > nextsync - offset)) lendis = eatbyte((uint8_t *) q, outbuf, sizeof(outbuf), bits); output_ins(offset, (uint8_t *) q, lendis, outbuf); q += lendis; offset += lendis; } if (q >= buffer + INSN_MAX) { uint8_t *r = (uint8_t *) buffer, *s = (uint8_t *) q; int count = p - q; while (count--) *r++ = *s++; p -= (q - buffer); q = buffer; } } while (lenread > 0 || !(eof || feof(fp))); if (fp != stdin) fclose(fp); return 0; }