mirror of
https://github.com/netwide-assembler/nasm.git
synced 2025-10-10 00:25:06 -04:00
349 lines
12 KiB
C
349 lines
12 KiB
C
/* ----------------------------------------------------------------------- *
|
|
*
|
|
* Copyright 1996-2018 The NASM Authors - All Rights Reserved
|
|
* See the file AUTHORS included with the NASM distribution for
|
|
* the specific copyright holders.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following
|
|
* conditions are met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above
|
|
* copyright notice, this list of conditions and the following
|
|
* disclaimer in the documentation and/or other materials provided
|
|
* with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
|
|
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
|
|
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
|
|
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
|
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
* ----------------------------------------------------------------------- */
|
|
|
|
#include "compiler.h"
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <ctype.h>
|
|
|
|
#include "nasm.h"
|
|
#include "nasmlib.h"
|
|
#include "error.h"
|
|
#include "quote.h"
|
|
#include "stdscan.h"
|
|
#include "insns.h"
|
|
|
|
/*
|
|
* Standard scanner routine used by parser.c and some output
|
|
* formats. It keeps a succession of temporary-storage strings in
|
|
* stdscan_tempstorage, which can be cleared using stdscan_reset.
|
|
*/
|
|
static char *stdscan_bufptr = NULL;
|
|
static char **stdscan_tempstorage = NULL;
|
|
static int stdscan_tempsize = 0, stdscan_templen = 0;
|
|
#define STDSCAN_TEMP_DELTA 256
|
|
|
|
void stdscan_set(char *str)
|
|
{
|
|
stdscan_bufptr = str;
|
|
}
|
|
|
|
char *stdscan_get(void)
|
|
{
|
|
return stdscan_bufptr;
|
|
}
|
|
|
|
static void stdscan_pop(void)
|
|
{
|
|
nasm_free(stdscan_tempstorage[--stdscan_templen]);
|
|
}
|
|
|
|
void stdscan_reset(void)
|
|
{
|
|
while (stdscan_templen > 0)
|
|
stdscan_pop();
|
|
}
|
|
|
|
/*
|
|
* Unimportant cleanup is done to avoid confusing people who are trying
|
|
* to debug real memory leaks
|
|
*/
|
|
void stdscan_cleanup(void)
|
|
{
|
|
stdscan_reset();
|
|
nasm_free(stdscan_tempstorage);
|
|
}
|
|
|
|
static char *stdscan_copy(char *p, int len)
|
|
{
|
|
char *text;
|
|
|
|
text = nasm_malloc(len + 1);
|
|
memcpy(text, p, len);
|
|
text[len] = '\0';
|
|
|
|
if (stdscan_templen >= stdscan_tempsize) {
|
|
stdscan_tempsize += STDSCAN_TEMP_DELTA;
|
|
stdscan_tempstorage = nasm_realloc(stdscan_tempstorage,
|
|
stdscan_tempsize *
|
|
sizeof(char *));
|
|
}
|
|
stdscan_tempstorage[stdscan_templen++] = text;
|
|
|
|
return text;
|
|
}
|
|
|
|
/*
|
|
* a token is enclosed with braces. proper token type will be assigned
|
|
* accordingly with the token flag.
|
|
*/
|
|
static int stdscan_handle_brace(struct tokenval *tv)
|
|
{
|
|
if (!(tv->t_flag & TFLAG_BRC_ANY)) {
|
|
/* invalid token is put inside braces */
|
|
nasm_nonfatal("`%s' is not a valid decorator with braces", tv->t_charptr);
|
|
tv->t_type = TOKEN_INVALID;
|
|
} else if (tv->t_flag & TFLAG_BRC_OPT) {
|
|
if (is_reg_class(OPMASKREG, tv->t_integer)) {
|
|
/* within braces, opmask register is now used as a mask */
|
|
tv->t_type = TOKEN_OPMASK;
|
|
}
|
|
}
|
|
|
|
return tv->t_type;
|
|
}
|
|
|
|
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 (nasm_isidstart(*stdscan_bufptr) ||
|
|
(*stdscan_bufptr == '$' && nasm_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 (nasm_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 (unlikely(tv->t_flag & TFLAG_WARN)) {
|
|
nasm_warnf(ERR_PASS1|ERR_WARN_PTR, "`%s' is not a NASM keyword",
|
|
tv->t_charptr);
|
|
}
|
|
|
|
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 == '$' && !nasm_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 (nasm_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 (nasm_isnumchar(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 (nasm_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_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] == '>') {
|
|
if (stdscan_bufptr[2] == '>') {
|
|
stdscan_bufptr += 3;
|
|
return tv->t_type = TOKEN_SAR;
|
|
} else {
|
|
stdscan_bufptr += 2;
|
|
return tv->t_type = TOKEN_SHR;
|
|
}
|
|
} else if (stdscan_bufptr[0] == '<' && stdscan_bufptr[1] == '<') {
|
|
stdscan_bufptr += stdscan_bufptr[2] == '<' ? 3 : 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++);
|
|
}
|