--input.position.colno;
}
-#define MATCH_NEWLINE(code) \
- case '\r': \
- next_char(); \
- if (input.c == '\n') { \
- case '\n': \
- next_char(); \
- } \
- info.whitespace = 0; \
- ++input.position.lineno; \
- input.position.colno = 1; \
- code
+#define NEWLINE \
+ '\r': \
+ next_char(); \
+ if (input.c == '\n') { \
+ case '\n': \
+ next_char(); \
+ } \
+ info.whitespace = 0; \
+ ++input.position.lineno; \
+ input.position.colno = 1; \
+ goto newline; \
+ newline // Let it look like an ordinary case label.
#define eat(c_type) (assert(input.c == c_type), next_char())
eat('\\');
switch (input.c) {
- MATCH_NEWLINE(
+ case NEWLINE:
return;
- )
default:
break;
return result;
}
-static string_t make_string(char *string, size_t len)
+static string_t sym_make_string(string_encoding_t const enc)
{
- const char *result = identify_string(string);
- return (string_t) {result, len};
+ obstack_1grow(&symbol_obstack, '\0');
+ size_t const len = obstack_object_size(&symbol_obstack) - 1;
+ char *const string = obstack_finish(&symbol_obstack);
+ char const *const result = identify_string(string);
+ return (string_t){ result, len, enc };
}
-static void parse_string_literal(void)
+static void parse_string(utf32 const delimiter, preprocessor_token_kind_t const kind, string_encoding_t const enc, char const *const context)
{
const unsigned start_linenr = input.position.lineno;
- eat('"');
+ eat(delimiter);
while (true) {
switch (input.c) {
case '\\': {
- utf32 tc;
if (resolve_escape_sequences) {
- tc = parse_escape_sequence();
- obstack_1grow(&symbol_obstack, (char) tc);
+ utf32 const tc = parse_escape_sequence();
+ if (enc == STRING_ENCODING_CHAR) {
+ if (tc >= 0x100) {
+ warningf(WARN_OTHER, &pp_token.base.source_position, "escape sequence out of range");
+ }
+ obstack_1grow(&symbol_obstack, tc);
+ } else {
+ obstack_grow_symbol(&symbol_obstack, tc);
+ }
} else {
- obstack_1grow(&symbol_obstack, (char) input.c);
+ obstack_1grow(&symbol_obstack, (char)input.c);
next_char();
- obstack_1grow(&symbol_obstack, (char) input.c);
+ obstack_1grow(&symbol_obstack, (char)input.c);
next_char();
}
break;
}
+ case NEWLINE:
+ errorf(&pp_token.base.source_position, "newline while parsing %s", context);
+ break;
+
case EOF: {
source_position_t source_position;
source_position.input_name = pp_token.base.source_position.input_name;
source_position.lineno = start_linenr;
- errorf(&source_position, "string has no end");
+ errorf(&source_position, "EOF while parsing %s", context);
goto end_of_string;
}
- case '"':
- next_char();
- goto end_of_string;
-
default:
- obstack_grow_symbol(&symbol_obstack, input.c);
- next_char();
- break;
+ if (input.c == delimiter) {
+ next_char();
+ goto end_of_string;
+ } else {
+ obstack_grow_symbol(&symbol_obstack, input.c);
+ next_char();
+ break;
+ }
}
}
end_of_string:
- /* add finishing 0 to the string */
- obstack_1grow(&symbol_obstack, '\0');
- const size_t size = (size_t)obstack_object_size(&symbol_obstack);
- char *const string = obstack_finish(&symbol_obstack);
-
- pp_token.kind = TP_STRING_LITERAL;
- pp_token.string.string = make_string(string, size);
+ pp_token.kind = kind;
+ pp_token.string.string = sym_make_string(enc);
}
-/**
- * Parse a wide string literal and set lexer_token.
- */
-static void parse_wide_string_literal(void)
+static void parse_string_literal(string_encoding_t const enc)
{
- parse_string_literal();
- if (pp_token.kind == TP_STRING_LITERAL)
- pp_token.kind = TP_WIDE_STRING_LITERAL;
+ parse_string('"', TP_STRING_LITERAL, enc, "string literal");
}
-static void parse_wide_character_constant(void)
+static void parse_character_constant(string_encoding_t const enc)
{
- eat('\'');
-
- while (true) {
- switch (input.c) {
- case '\\': {
- const utf32 tc = parse_escape_sequence();
- obstack_grow_symbol(&symbol_obstack, tc);
- break;
- }
-
- MATCH_NEWLINE(
- parse_error("newline while parsing character constant");
- break;
- )
-
- case '\'':
- next_char();
- goto end_of_wide_char_constant;
-
- case EOF:
- parse_error("EOF while parsing character constant");
- goto end_of_wide_char_constant;
-
- default:
- obstack_grow_symbol(&symbol_obstack, input.c);
- next_char();
- break;
- }
- }
-
-end_of_wide_char_constant:
- obstack_1grow(&symbol_obstack, '\0');
- size_t size = (size_t) obstack_object_size(&symbol_obstack)-1;
- char *string = obstack_finish(&symbol_obstack);
- pp_token.kind = TP_WIDE_CHARACTER_CONSTANT;
- pp_token.string.string = make_string(string, size);
-
- if (size == 0) {
- parse_error("empty character constant");
- }
-}
-
-static void parse_character_constant(void)
-{
- const unsigned start_linenr = input.position.lineno;
-
- eat('\'');
-
- int tc;
- while (true) {
- switch (input.c) {
- case '\\':
- tc = parse_escape_sequence();
- obstack_1grow(&symbol_obstack, (char) tc);
- break;
-
- MATCH_NEWLINE(
- parse_error("newline while parsing character constant");
- break;
- )
-
- case EOF: {
- source_position_t source_position;
- source_position.input_name = pp_token.base.source_position.input_name;
- source_position.lineno = start_linenr;
- errorf(&source_position, "EOF while parsing character constant");
- goto end_of_char_constant;
- }
-
- case '\'':
- next_char();
- goto end_of_char_constant;
-
- default:
- obstack_1grow(&symbol_obstack, (char) input.c);
- next_char();
- break;
-
- }
- }
-
-end_of_char_constant:;
- obstack_1grow(&symbol_obstack, '\0');
- const size_t size = (size_t)obstack_object_size(&symbol_obstack);
- char *const string = obstack_finish(&symbol_obstack);
-
- pp_token.kind = TP_CHARACTER_CONSTANT;
- pp_token.string.string = make_string(string, size);
-
- if (size == 0) {
+ parse_string('\'', TP_CHARACTER_CONSTANT, enc, "character constant");
+ if (pp_token.string.string.size == 0) {
parse_error("empty character constant");
}
}
}
break;
- MATCH_NEWLINE(
+ case NEWLINE:
break;
- )
case EOF: {
source_position_t source_position;
next_char();
continue;
- MATCH_NEWLINE(
+ case NEWLINE:
info.at_line_begin = true;
return;
- )
case '/':
next_char();
/* might be a wide string or character constant ( L"string"/L'c' ) */
if (input.c == '"' && string[0] == 'L' && string[1] == '\0') {
obstack_free(&symbol_obstack, string);
- parse_wide_string_literal();
+ parse_string_literal(STRING_ENCODING_WIDE);
return;
} else if (input.c == '\'' && string[0] == 'L' && string[1] == '\0') {
obstack_free(&symbol_obstack, string);
- parse_wide_character_constant();
+ parse_character_constant(STRING_ENCODING_WIDE);
return;
}
}
end_number:
- obstack_1grow(&symbol_obstack, '\0');
- size_t size = obstack_object_size(&symbol_obstack);
- char *string = obstack_finish(&symbol_obstack);
-
pp_token.kind = TP_NUMBER;
- pp_token.number.number = make_string(string, size);
+ pp_token.number.number = sym_make_string(STRING_ENCODING_CHAR);
}
next_char();
goto restart;
- MATCH_NEWLINE(
+ case NEWLINE:
info.at_line_begin = true;
info.had_whitespace = true;
goto restart;
- )
SYMBOL_CHARS
parse_symbol();
return;
case '"':
- parse_string_literal();
+ parse_string_literal(STRING_ENCODING_CHAR);
return;
case '\'':
- parse_character_constant();
+ parse_character_constant(STRING_ENCODING_CHAR);
return;
case '.':
case TP_NUMBER:
fputs(pp_token.number.number.begin, out);
break;
- case TP_WIDE_STRING_LITERAL:
- fputc('L', out);
+
case TP_STRING_LITERAL:
+ fputs(get_string_encoding_prefix(pp_token.string.string.encoding), out);
fputc('"', out);
fputs(pp_token.string.string.begin, out);
fputc('"', out);
break;
- case TP_WIDE_CHARACTER_CONSTANT:
- fputc('L', out);
+
case TP_CHARACTER_CONSTANT:
+ fputs(get_string_encoding_prefix(pp_token.string.string.encoding), out);
fputc('\'', out);
fputs(pp_token.string.string.begin, out);
fputc('\'', out);
static void parse_headername(void)
{
const source_position_t start_position = input.position;
- string_t string = {NULL, 0};
+ string_t string = { NULL, 0, STRING_ENCODING_CHAR };
assert(obstack_object_size(&symbol_obstack) == 0);
/* behind an #include we can have the special headername lexems.
/* check wether we have a "... or <... headername */
switch (input.c) {
- case '<':
+ {
+ utf32 delimiter;
+ case '<': delimiter = '>'; goto parse_name;
+ case '"': delimiter = '"'; goto parse_name;
+parse_name:
next_char();
while (true) {
switch (input.c) {
+ case NEWLINE:
case EOF:
- /* fallthrough */
- MATCH_NEWLINE(
- parse_error("header name without closing '>'");
+ errorf(&pp_token.base.source_position, "header name without closing '%c'", (char)delimiter);
goto finish_error;
- )
- case '>':
- next_char();
- goto finished_headername;
- }
- obstack_1grow(&symbol_obstack, (char) input.c);
- next_char();
- }
- /* we should never be here */
- case '"':
- next_char();
- while (true) {
- switch (input.c) {
- case EOF:
- /* fallthrough */
- MATCH_NEWLINE(
- parse_error("header name without closing '>'");
- goto finish_error;
- )
- case '"':
- next_char();
- goto finished_headername;
+ default:
+ if (input.c == delimiter) {
+ next_char();
+ goto finished_headername;
+ } else {
+ obstack_1grow(&symbol_obstack, (char)input.c);
+ next_char();
+ }
+ break;
}
- obstack_1grow(&symbol_obstack, (char) input.c);
- next_char();
}
/* we should never be here */
+ }
default:
/* TODO: do normal pp_token parsing and concatenate results */
}
finished_headername:
- obstack_1grow(&symbol_obstack, '\0');
- const size_t size = (size_t)obstack_object_size(&symbol_obstack);
- char *const headername = obstack_finish(&symbol_obstack);
- string = make_string(headername, size);
+ string = sym_make_string(STRING_ENCODING_CHAR);
finish_error:
pp_token.base.source_position = start_position;
/* skip till newline */
while (true) {
switch (input.c) {
- MATCH_NEWLINE(
- return;
- )
+ case NEWLINE:
case EOF:
return;
}
projects / cparser / blobdiff