static const char *bufend;
static const char *bufpos;
static strset_t stringset;
+bool allow_dollar_in_symbol = true;
/**
* Prints a parse error message at the current token.
{
assert(bufpos <= bufend);
if (bufpos >= bufend) {
+ if (input == NULL) {
+ c = EOF;
+ return;
+ }
+
size_t s = fread(buf + MAX_PUTBACK, 1, sizeof(buf) - MAX_PUTBACK,
input);
if(s == 0) {
}
#define SYMBOL_CHARS \
+ case '$': if (!allow_dollar_in_symbol) goto dollar_sign; \
case 'a': \
case 'b': \
case 'c': \
break;
default:
+dollar_sign:
goto end_symbol;
}
}
if(v >= TARGET_LONG_MIN && v <= TARGET_LONG_MAX) {
lexer_token.datatype = type_long;
return;
- } else if(is_oct_hex && v >= 0 && v <= TARGET_ULONG_MAX) {
+ } else if(is_oct_hex && v >= 0 && (unsigned long long)v <= (unsigned long long)TARGET_ULONG_MAX) {
lexer_token.datatype = type_unsigned_long;
return;
}
*/
static void parse_number_hex(void)
{
+ bool is_float = false;
assert(c == 'x' || c == 'X');
next_char();
+ obstack_1grow(&symbol_obstack, '0');
+ obstack_1grow(&symbol_obstack, 'x');
+
while(isxdigit(c)) {
obstack_1grow(&symbol_obstack, (char) c);
next_char();
}
- obstack_1grow(&symbol_obstack, '\0');
- char *string = obstack_finish(&symbol_obstack);
- if(c == '.' || c == 'p' || c == 'P') {
+ if (c == '.') {
+ obstack_1grow(&symbol_obstack, (char) c);
+ next_char();
+
+ while (isxdigit(c)) {
+ obstack_1grow(&symbol_obstack, (char) c);
+ next_char();
+ }
+ is_float = true;
+ }
+ if (c == 'p' || c == 'P') {
+ obstack_1grow(&symbol_obstack, (char) c);
next_char();
- internal_error("Hex floating point numbers not implemented yet");
+
+ if (c == '-' || c == '+') {
+ obstack_1grow(&symbol_obstack, (char) c);
+ next_char();
+ }
+
+ while (isxdigit(c)) {
+ obstack_1grow(&symbol_obstack, (char) c);
+ next_char();
+ }
+ is_float = true;
}
+
+ obstack_1grow(&symbol_obstack, '\0');
+ char *string = obstack_finish(&symbol_obstack);
if(*string == '\0') {
parse_error("invalid hex number");
lexer_token.type = T_ERROR;
+ obstack_free(&symbol_obstack, string);
+ return;
}
- const char *endptr;
- lexer_token.type = T_INTEGER;
- lexer_token.v.intvalue = parse_int_string(string, &endptr, 16);
- if(*endptr != '\0') {
- parse_error("hex number literal too long");
+ if (is_float) {
+ char *endptr;
+ lexer_token.type = T_FLOATINGPOINT;
+ lexer_token.v.floatvalue = strtold(string, &endptr);
+
+ if(*endptr != '\0') {
+ parse_error("invalid hex float literal");
+ }
+
+ parse_floating_suffix();
+ } else {
+ const char *endptr;
+ lexer_token.type = T_INTEGER;
+ lexer_token.v.intvalue = parse_int_string(string + 2, &endptr, 16);
+ if(*endptr != '\0') {
+ parse_error("hex number literal too long");
+ }
+ parse_integer_suffix(true);
}
obstack_free(&symbol_obstack, string);
- parse_integer_suffix(true);
}
/**
static void parse_number_dec(void)
{
bool is_float = false;
- while(isdigit(c)) {
+ while (isdigit(c)) {
obstack_1grow(&symbol_obstack, (char) c);
next_char();
}
- if(c == '.') {
+ if (c == '.') {
obstack_1grow(&symbol_obstack, '.');
next_char();
- while(isdigit(c)) {
+ while (isdigit(c)) {
obstack_1grow(&symbol_obstack, (char) c);
next_char();
}
is_float = true;
}
if(c == 'e' || c == 'E') {
- obstack_1grow(&symbol_obstack, 'e');
+ obstack_1grow(&symbol_obstack, (char) c);
next_char();
if(c == '-' || c == '+') {
int ec = c;
next_char();
- switch(ec) {
+ switch (ec) {
case '"': return '"';
case '\'': return '\'';
case '\\': return '\\';
case EOF:
parse_error("reached end of file while parsing escape sequence");
return EOF;
+ case 'e':
+ if (c_mode & _GNUC)
+ return 27; /* hopefully 27 is ALWAYS the code for ESACAPE */
+ /*fallthrough*/
default:
parse_error("unknown escape sequence");
return EOF;
case '/':
next_char();
if (c == '*') {
- /* TODO: nested comment, warn here */
+ /* nested comment, warn here */
+ if (warning.comment) {
+ warningf(&lexer_token.source_position, "'/*' within comment");
+ }
}
break;
case '*':
case '\r':
return;
+ case '\\':
+ next_char();
+ if (c == '\n' || c == '\r') {
+ if (warning.comment)
+ warningf(&lexer_token.source_position, "multi-line comment");
+ return;
+ }
+ break;
+
default:
next_char();
break;
/**
* STDC pragmas.
*/
-typedef enum {
+typedef enum stdc_pragma_kind_t {
STDC_UNKNOWN,
STDC_FP_CONTRACT,
STDC_FENV_ACCESS,
/**
* STDC pragma values.
*/
-typedef enum {
+typedef enum stdc_pragma_value_kind_t {
STDC_VALUE_UNKNOWN,
STDC_VALUE_ON,
STDC_VALUE_OFF,
case '.':
MAYBE_PROLOG
- case '0':
- case '1':
- case '2':
- case '3':
- case '4':
- case '5':
- case '6':
- case '7':
- case '8':
- case '9':
+ DIGITS
put_back(c);
c = '.';
parse_number_dec();
return;
default:
+dollar_sign:
+ errorf(&lexer_token.source_position, "unknown character '%c' found", c);
next_char();
- errorf(&lexer_token.source_position, "unknown character '%c' found\n", c);
lexer_token.type = T_ERROR;
return;
}
void lexer_next_token(void)
{
lexer_next_preprocessing_token();
- if(lexer_token.type != '\n')
- return;
+ while (lexer_token.type == '\n') {
newline_found:
- do {
lexer_next_preprocessing_token();
- } while(lexer_token.type == '\n');
+ }
- if(lexer_token.type == '#') {
+ if (lexer_token.type == '#') {
parse_preprocessor_directive();
goto newline_found;
}
void init_lexer(void)
{
strset_init(&stringset);
+ symbol_L = symbol_table_insert("L");
}
void lexer_open_stream(FILE *stream, const char *input_name)
lexer_token.source_position.linenr = 0;
lexer_token.source_position.input_name = input_name;
- symbol_L = symbol_table_insert("L");
bufpos = NULL;
bufend = NULL;
c = '\n';
}
+void lexer_open_buffer(const char *buffer, size_t len, const char *input_name)
+{
+ input = NULL;
+ lexer_token.source_position.linenr = 0;
+ lexer_token.source_position.input_name = input_name;
+
+ bufpos = buffer;
+ bufend = buffer + len;
+
+ /* place a virtual \n at the beginning so the lexer knows that we're
+ * at the beginning of a line */
+ c = '\n';
+}
+
void exit_lexer(void)
{
strset_destroy(&stringset);