darkplaces/gmqcc
0
0
Fork 0
mirror of https://github.com/DarkPlacesEngine/gmqcc.git synced 2025-02-21 10:51:10 +00:00
Code Issues Projects Releases Packages Wiki Activity

Replacing lexer's vectors and getting rid of the macros

Browse source
This commit is contained in:
Wolfgang (Blub) Bumiller 2012-11-15 18:48:38 +01:00
parent 906f319673
commit c583ae24f2
3 changed files with 92 additions and 355 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

177
gmqcc.h
View file

@ -615,183 +615,8 @@ static const struct {
{ "END" , 0, 3 } /* virtual assembler instruction */ { "END" , 0, 3 } /* virtual assembler instruction */
}; };
/*===================================================================*/ /*===================================================================*/
/*============================= ast.c ===============================*/ /*============================= ir.c ================================*/
/*===================================================================*/ /*===================================================================*/
#define MEM_VECTOR_PROTO(Towner, Tmem, mem) \
bool GMQCC_WARN Towner##_##mem##_add(Towner*, Tmem); \
bool GMQCC_WARN Towner##_##mem##_remove(Towner*, size_t)
#define MEM_VECTOR_PROTO_ALL(Towner, Tmem, mem) \
MEM_VECTOR_PROTO(Towner, Tmem, mem); \
bool GMQCC_WARN Towner##_##mem##_find(Towner*, Tmem, size_t*); \
void Towner##_##mem##_clear(Towner*)
#define MEM_VECTOR_MAKE(Twhat, name) \
Twhat *name; \
size_t name##_count; \
size_t name##_alloc
#define MEM_VEC_FUN_ADD(Tself, Twhat, mem) \
bool GMQCC_WARN Tself##_##mem##_add(Tself *self, Twhat f) \
{ \
Twhat *reall; \
if (self->mem##_count == self->mem##_alloc) { \
if (!self->mem##_alloc) { \
self->mem##_alloc = 16; \
} else { \
self->mem##_alloc *= 2; \
} \
reall = (Twhat*)mem_a(sizeof(Twhat) * self->mem##_alloc); \
if (!reall) { \
return false; \
} \
memcpy(reall, self->mem, sizeof(Twhat) * self->mem##_count); \
mem_d(self->mem); \
self->mem = reall; \
} \
self->mem[self->mem##_count++] = f; \
return true; \
}
#define MEM_VEC_FUN_REMOVE(Tself, Twhat, mem) \
bool GMQCC_WARN Tself##_##mem##_remove(Tself *self, size_t idx) \
{ \
size_t i; \
Twhat *reall; \
if (idx >= self->mem##_count) { \
return true; /* huh... */ \
} \
for (i = idx; i < self->mem##_count-1; ++i) { \
self->mem[i] = self->mem[i+1]; \
} \
self->mem##_count--; \
if (self->mem##_count < self->mem##_count/2) { \
self->mem##_alloc /= 2; \
reall = (Twhat*)mem_a(sizeof(Twhat) * self->mem##_count); \
if (!reall) { \
return false; \
} \
memcpy(reall, self->mem, sizeof(Twhat) * self->mem##_count); \
mem_d(self->mem); \
self->mem = reall; \
} \
return true; \
}
#define MEM_VEC_FUN_FIND(Tself, Twhat, mem) \
bool GMQCC_WARN Tself##_##mem##_find(Tself *self, Twhat obj, size_t *idx) \
{ \
size_t i; \
for (i = 0; i < self->mem##_count; ++i) { \
if (self->mem[i] == obj) { \
if (idx) { \
*idx = i; \
} \
return true; \
} \
} \
return false; \
}
#define MEM_VEC_FUN_APPEND(Tself, Twhat, mem) \
bool GMQCC_WARN Tself##_##mem##_append(Tself *s, Twhat *p, size_t c) \
{ \
Twhat *reall; \
size_t oldalloc; \
if (s->mem##_count+c > s->mem##_alloc) { \
if (!s->mem##_alloc) { \
s->mem##_alloc = c < 16 ? 16 : c; \
s->mem = (Twhat*)mem_a(sizeof(Twhat) * s->mem##_alloc); \
} else { \
oldalloc = s->mem##_alloc; \
s->mem##_alloc *= 2; \
if (s->mem##_count+c >= s->mem##_alloc) { \
s->mem##_alloc = s->mem##_count+c; \
} \
reall = (Twhat*)mem_a(sizeof(Twhat) * s->mem##_alloc); \
if (!reall) { \
s->mem##_alloc = oldalloc; \
return false; \
} \
memcpy(reall, s->mem, sizeof(Twhat) * s->mem##_count); \
mem_d(s->mem); \
s->mem = reall; \
} \
} \
memcpy(&s->mem[s->mem##_count], p, c*sizeof(*p)); \
s->mem##_count += c; \
return true; \
}
#define MEM_VEC_FUN_RESIZE(Tself, Twhat, mem) \
bool GMQCC_WARN Tself##_##mem##_resize(Tself *s, size_t c) \
{ \
Twhat *reall; \
if (c > s->mem##_alloc) { \
reall = (Twhat*)mem_a(sizeof(Twhat) * c); \
if (!reall) { return false; } \
memcpy(reall, s->mem, sizeof(Twhat) * s->mem##_count); \
s->mem##_alloc = c; \
s->mem##_count = c; \
mem_d(s->mem); \
s->mem = reall; \
return true; \
} \
s->mem##_count = c; \
if (c < (s->mem##_alloc / 2)) { \
reall = (Twhat*)mem_a(sizeof(Twhat) * c); \
if (!reall) { return false; } \
memcpy(reall, s->mem, sizeof(Twhat) * c); \
mem_d(s->mem); \
s->mem = reall; \
s->mem##_alloc = c; \
} \
return true; \
}
#define MEM_VEC_FUN_CLEAR(Tself, mem) \
void Tself##_##mem##_clear(Tself *self) \
{ \
if (!self->mem) \
return; \
mem_d((void*) self->mem); \
self->mem = NULL; \
self->mem##_count = 0; \
self->mem##_alloc = 0; \
}
#define MEM_VECTOR_CLEAR(owner, mem) \
if ((owner)->mem) \
mem_d((void*)((owner)->mem)); \
(owner)->mem = NULL; \
(owner)->mem##_count = 0; \
(owner)->mem##_alloc = 0
#define MEM_VECTOR_INIT(owner, mem) \
{ \
(owner)->mem = NULL; \
(owner)->mem##_count = 0; \
(owner)->mem##_alloc = 0; \
}
#define MEM_VECTOR_MOVE(from, mem, to, tm) \
{ \
(to)->tm = (from)->mem; \
(to)->tm##_count = (from)->mem##_count; \
(to)->tm##_alloc = (from)->mem##_alloc; \
(from)->mem = NULL; \
(from)->mem##_count = 0; \
(from)->mem##_alloc = 0; \
}
#define MEM_VEC_FUNCTIONS(Tself, Twhat, mem) \
MEM_VEC_FUN_REMOVE(Tself, Twhat, mem) \
MEM_VEC_FUN_ADD(Tself, Twhat, mem)
#define MEM_VEC_FUNCTIONS_ALL(Tself, Twhat, mem) \
MEM_VEC_FUNCTIONS(Tself, Twhat, mem) \
MEM_VEC_FUN_CLEAR(Tself, mem) \
MEM_VEC_FUN_FIND(Tself, Twhat, mem)
enum store_types { enum store_types {
store_global, store_global,

264
lexer.c
View file

@ -6,9 +6,6 @@
#include "gmqcc.h" #include "gmqcc.h"
#include "lexer.h" #include "lexer.h"
MEM_VEC_FUNCTIONS(token, char, value)
MEM_VEC_FUNCTIONS(lex_file, frame_macro, frames)
char* *lex_filenames; char* *lex_filenames;
void lexerror(lex_file *lex, const char *fmt, ...) void lexerror(lex_file *lex, const char *fmt, ...)
@ -123,7 +120,8 @@ static void lex_token_new(lex_file *lex)
token_delete(lex->tok); token_delete(lex->tok);
lex->tok = token_new(); lex->tok = token_new();
#else #else
lex->tok.value_count = 0; if (lex->tok.value)
vec_shrinkto(lex->tok.value, 0);
lex->tok.constval.t = 0; lex->tok.constval.t = 0;
lex->tok.ctx.line = lex->sline; lex->tok.ctx.line = lex->sline;
lex->tok.ctx.file = lex->name; lex->tok.ctx.file = lex->name;
@ -200,12 +198,12 @@ void lex_cleanup(void)
void lex_close(lex_file *lex) void lex_close(lex_file *lex)
{ {
size_t i; size_t i;
for (i = 0; i < lex->frames_count; ++i) for (i = 0; i < vec_size(lex->frames); ++i)
mem_d(lex->frames[i].name); mem_d(lex->frames[i].name);
MEM_VECTOR_CLEAR(lex, frames); vec_free(lex->frames);
if (lex->modelname) if (lex->modelname)
mem_d(lex->modelname); vec_free(lex->modelname);
if (lex->file) if (lex->file)
fclose(lex->file); fclose(lex->file);
@ -213,7 +211,7 @@ void lex_close(lex_file *lex)
if (lex->tok) if (lex->tok)
token_delete(lex->tok); token_delete(lex->tok);
#else #else
MEM_VECTOR_CLEAR(&(lex->tok), value); vec_free(lex->tok.value);
#endif #endif
/* mem_d(lex->name); collected in lex_filenames */ /* mem_d(lex->name); collected in lex_filenames */
mem_d(lex); mem_d(lex);
@ -334,24 +332,16 @@ static bool isxdigit_only(int ch)
} }
/* Append a character to the token buffer */ /* Append a character to the token buffer */
static bool GMQCC_WARN lex_tokench(lex_file *lex, int ch) static void lex_tokench(lex_file *lex, int ch)
{ {
if (!token_value_add(&lex->tok, ch)) { vec_push(lex->tok.value, ch);
lexerror(lex, "out of memory");
return false;
}
return true;
} }
/* Append a trailing null-byte */ /* Append a trailing null-byte */
static bool GMQCC_WARN lex_endtoken(lex_file *lex) static void lex_endtoken(lex_file *lex)
{ {
if (!token_value_add(&lex->tok, 0)) { vec_push(lex->tok.value, 0);
lexerror(lex, "out of memory"); vec_shrinkby(lex->tok.value, 1);
return false;
}
lex->tok.value_count--;
return true;
} }
/* Skip whitespace and comments and return the first /* Skip whitespace and comments and return the first
@ -399,18 +389,16 @@ static int lex_skipwhite(lex_file *lex)
if (ch == '\n') { if (ch == '\n') {
/* end-of-line */ /* end-of-line */
/* see if there was whitespace first */ /* see if there was whitespace first */
if (haswhite) { /* (lex->tok.value_count) { */ if (haswhite) { /* (vec_size(lex->tok.value)) { */
lex_ungetch(lex, ch); lex_ungetch(lex, ch);
if (!lex_endtoken(lex)) lex_endtoken(lex);
return TOKEN_FATAL;
return TOKEN_WHITE; return TOKEN_WHITE;
} }
/* otherwise return EOL */ /* otherwise return EOL */
return TOKEN_EOL; return TOKEN_EOL;
} }
haswhite = true; haswhite = true;
if (!lex_tokench(lex, ch)) lex_tokench(lex, ch);
return TOKEN_FATAL;
} }
ch = lex_getch(lex); ch = lex_getch(lex);
} }
@ -424,22 +412,18 @@ static int lex_skipwhite(lex_file *lex)
if (lex->flags.preprocessing) { if (lex->flags.preprocessing) {
haswhite = true; haswhite = true;
if (!lex_tokench(lex, '/') || lex_tokench(lex, '/');
!lex_tokench(lex, '/')) lex_tokench(lex, '/');
{
return TOKEN_FATAL;
}
} }
while (ch != EOF && ch != '\n') { while (ch != EOF && ch != '\n') {
if (lex->flags.preprocessing && !lex_tokench(lex, ch)) if (lex->flags.preprocessing)
return TOKEN_FATAL; lex_tokench(lex, ch);
ch = lex_getch(lex); ch = lex_getch(lex);
} }
if (lex->flags.preprocessing) { if (lex->flags.preprocessing) {
lex_ungetch(lex, '\n'); lex_ungetch(lex, '\n');
if (!lex_endtoken(lex)) lex_endtoken(lex);
return TOKEN_FATAL;
return TOKEN_WHITE; return TOKEN_WHITE;
} }
continue; continue;
@ -449,11 +433,8 @@ static int lex_skipwhite(lex_file *lex)
/* multiline comment */ /* multiline comment */
if (lex->flags.preprocessing) { if (lex->flags.preprocessing) {
haswhite = true; haswhite = true;
if (!lex_tokench(lex, '/') || lex_tokench(lex, '/');
!lex_tokench(lex, '*')) lex_tokench(lex, '*');
{
return TOKEN_FATAL;
}
} }
while (ch != EOF) while (ch != EOF)
@ -463,18 +444,14 @@ static int lex_skipwhite(lex_file *lex)
ch = lex_getch(lex); ch = lex_getch(lex);
if (ch == '/') { if (ch == '/') {
if (lex->flags.preprocessing) { if (lex->flags.preprocessing) {
if (!lex_tokench(lex, '*') || lex_tokench(lex, '*');
!lex_tokench(lex, '/')) lex_tokench(lex, '/');
{
return TOKEN_FATAL;
}
} }
break; break;
} }
} }
if (lex->flags.preprocessing) { if (lex->flags.preprocessing) {
if (!lex_tokench(lex, ch)) lex_tokench(lex, ch);
return TOKEN_FATAL;
} }
} }
ch = ' '; /* cause TRUE in the isspace check */ ch = ' '; /* cause TRUE in the isspace check */
@ -488,8 +465,7 @@ static int lex_skipwhite(lex_file *lex)
} while (ch != EOF && isspace(ch)); } while (ch != EOF && isspace(ch));
if (haswhite) { if (haswhite) {
if (!lex_endtoken(lex)) lex_endtoken(lex);
return TOKEN_FATAL;
lex_ungetch(lex, ch); lex_ungetch(lex, ch);
return TOKEN_WHITE; return TOKEN_WHITE;
} }
@ -504,8 +480,7 @@ static bool GMQCC_WARN lex_finish_ident(lex_file *lex)
ch = lex_getch(lex); ch = lex_getch(lex);
while (ch != EOF && isident(ch)) while (ch != EOF && isident(ch))
{ {
if (!lex_tokench(lex, ch)) lex_tokench(lex, ch);
return (lex->tok.ttype = TOKEN_FATAL);
ch = lex_getch(lex); ch = lex_getch(lex);
} }
@ -534,12 +509,10 @@ static int lex_parse_frame(lex_file *lex)
return -1; return -1;
} }
if (!lex_tokench(lex, ch)) lex_tokench(lex, ch);
return -1;
if (!lex_finish_ident(lex)) if (!lex_finish_ident(lex))
return -1; return -1;
if (!lex_endtoken(lex)) lex_endtoken(lex);
return -1;
return 0; return 0;
} }
@ -557,7 +530,7 @@ static bool lex_finish_frames(lex_file *lex)
if (rc < 0) /* error */ if (rc < 0) /* error */
return false; return false;
for (i = 0; i < lex->frames_count; ++i) { for (i = 0; i < vec_size(lex->frames); ++i) {
if (!strcmp(lex->tok.value, lex->frames[i].name)) { if (!strcmp(lex->tok.value, lex->frames[i].name)) {
lex->frames[i].value = lex->framevalue++; lex->frames[i].value = lex->framevalue++;
if (lexwarn(lex, WARN_FRAME_MACROS, "duplicate frame macro defined: `%s`", lex->tok.value)) if (lexwarn(lex, WARN_FRAME_MACROS, "duplicate frame macro defined: `%s`", lex->tok.value))
@ -565,17 +538,13 @@ static bool lex_finish_frames(lex_file *lex)
break; break;
} }
} }
if (i < lex->frames_count) if (i < vec_size(lex->frames))
continue; continue;
m.value = lex->framevalue++; m.value = lex->framevalue++;
m.name = lex->tok.value; m.name = util_strdup(lex->tok.value);
lex->tok.value = NULL; vec_shrinkto(lex->tok.value, 0);
lex->tok.value_alloc = lex->tok.value_count = 0; vec_push(lex->frames, m);
if (!lex_file_frames_add(lex, m)) {
lexerror(lex, "out of memory");
return false;
}
} while (true); } while (true);
} }
@ -609,15 +578,13 @@ static int GMQCC_WARN lex_finish_string(lex_file *lex, int quote)
default: default:
lexwarn(lex, WARN_UNKNOWN_CONTROL_SEQUENCE, "unrecognized control sequence: \\%c", ch); lexwarn(lex, WARN_UNKNOWN_CONTROL_SEQUENCE, "unrecognized control sequence: \\%c", ch);
/* so we just add the character plus backslash no matter what it actually is */ /* so we just add the character plus backslash no matter what it actually is */
if (!lex_tokench(lex, '\\')) lex_tokench(lex, '\\');
return (lex->tok.ttype = TOKEN_FATAL);
} }
/* add the character finally */ /* add the character finally */
if (!lex_tokench(lex, ch)) lex_tokench(lex, ch);
return (lex->tok.ttype = TOKEN_FATAL);
} }
else if (!lex_tokench(lex, ch)) else
return (lex->tok.ttype = TOKEN_FATAL); lex_tokench(lex, ch);
} }
lexerror(lex, "unexpected end of file within string constant"); lexerror(lex, "unexpected end of file within string constant");
lex_ungetch(lex, EOF); /* next token to be TOKEN_EOF */ lex_ungetch(lex, EOF); /* next token to be TOKEN_EOF */
@ -633,8 +600,7 @@ static int GMQCC_WARN lex_finish_digit(lex_file *lex, int lastch)
/* parse a number... */ /* parse a number... */
lex->tok.ttype = TOKEN_INTCONST; lex->tok.ttype = TOKEN_INTCONST;
if (!lex_tokench(lex, ch)) lex_tokench(lex, ch);
return (lex->tok.ttype = TOKEN_FATAL);
ch = lex_getch(lex); ch = lex_getch(lex);
if (ch != '.' && !isdigit(ch)) if (ch != '.' && !isdigit(ch))
@ -643,8 +609,7 @@ static int GMQCC_WARN lex_finish_digit(lex_file *lex, int lastch)
{ {
/* end of the number or EOF */ /* end of the number or EOF */
lex_ungetch(lex, ch); lex_ungetch(lex, ch);
if (!lex_endtoken(lex)) lex_endtoken(lex);
return (lex->tok.ttype = TOKEN_FATAL);
lex->tok.constval.i = lastch - '0'; lex->tok.constval.i = lastch - '0';
return lex->tok.ttype; return lex->tok.ttype;
@ -657,13 +622,11 @@ static int GMQCC_WARN lex_finish_digit(lex_file *lex, int lastch)
if (ch != '.') if (ch != '.')
{ {
if (!lex_tokench(lex, ch)) lex_tokench(lex, ch);
return (lex->tok.ttype = TOKEN_FATAL);
ch = lex_getch(lex); ch = lex_getch(lex);
while (isdigit(ch) || (ishex && isxdigit_only(ch))) while (isdigit(ch) || (ishex && isxdigit_only(ch)))
{ {
if (!lex_tokench(lex, ch)) lex_tokench(lex, ch);
return (lex->tok.ttype = TOKEN_FATAL);
ch = lex_getch(lex); ch = lex_getch(lex);
} }
} }
@ -672,15 +635,13 @@ static int GMQCC_WARN lex_finish_digit(lex_file *lex, int lastch)
{ {
/* Allow floating comma in non-hex mode */ /* Allow floating comma in non-hex mode */
lex->tok.ttype = TOKEN_FLOATCONST; lex->tok.ttype = TOKEN_FLOATCONST;
if (!lex_tokench(lex, ch)) lex_tokench(lex, ch);
return (lex->tok.ttype = TOKEN_FATAL);
/* continue digits-only */ /* continue digits-only */
ch = lex_getch(lex); ch = lex_getch(lex);
while (isdigit(ch)) while (isdigit(ch))
{ {
if (!lex_tokench(lex, ch)) lex_tokench(lex, ch);
return (lex->tok.ttype = TOKEN_FATAL);
ch = lex_getch(lex); ch = lex_getch(lex);
} }
} }
@ -696,8 +657,7 @@ static int GMQCC_WARN lex_finish_digit(lex_file *lex, int lastch)
} }
lex_ungetch(lex, ch); lex_ungetch(lex, ch);
if (!lex_endtoken(lex)) lex_endtoken(lex);
return (lex->tok.ttype = TOKEN_FATAL);
if (lex->tok.ttype == TOKEN_FLOATCONST) if (lex->tok.ttype == TOKEN_FLOATCONST)
lex->tok.constval.f = strtod(lex->tok.value, NULL); lex->tok.constval.f = strtod(lex->tok.value, NULL);
else else
@ -742,12 +702,10 @@ int lex_do(lex_file *lex)
lexerror(lex, "hanging '$' modelgen/spritegen command line"); lexerror(lex, "hanging '$' modelgen/spritegen command line");
return lex_do(lex); return lex_do(lex);
} }
if (!lex_tokench(lex, ch)) lex_tokench(lex, ch);
return (lex->tok.ttype = TOKEN_FATAL);
if (!lex_finish_ident(lex)) if (!lex_finish_ident(lex))
return (lex->tok.ttype = TOKEN_ERROR); return (lex->tok.ttype = TOKEN_ERROR);
if (!lex_endtoken(lex)) lex_endtoken(lex);
return (lex->tok.ttype = TOKEN_FATAL);
/* skip the known commands */ /* skip the known commands */
v = lex->tok.value; v = lex->tok.value;
@ -776,8 +734,7 @@ int lex_do(lex_file *lex)
lex_token_new(lex); lex_token_new(lex);
lex->tok.ttype = lex_finish_digit(lex, ch); lex->tok.ttype = lex_finish_digit(lex, ch);
if (!lex_endtoken(lex)) lex_endtoken(lex);
return (lex->tok.ttype = TOKEN_FATAL);
if (lex->tok.ttype != TOKEN_INTCONST) { if (lex->tok.ttype != TOKEN_INTCONST) {
lexerror(lex, "$framevalue requires an integer parameter"); lexerror(lex, "$framevalue requires an integer parameter");
return lex_do(lex); return lex_do(lex);
@ -802,7 +759,7 @@ int lex_do(lex_file *lex)
return (lex->tok.ttype = TOKEN_FATAL); return (lex->tok.ttype = TOKEN_FATAL);
v = lex->tok.value; v = lex->tok.value;
for (frame = 0; frame < lex->frames_count; ++frame) { for (frame = 0; frame < vec_size(lex->frames); ++frame) {
if (!strcmp(v, lex->frames[frame].name)) { if (!strcmp(v, lex->frames[frame].name)) {
lex->framevalue = lex->frames[frame].value; lex->framevalue = lex->frames[frame].value;
return lex_do(lex); return lex_do(lex);
@ -821,7 +778,7 @@ int lex_do(lex_file *lex)
rc = lex_parse_frame(lex); rc = lex_parse_frame(lex);
if (rc > 0) { if (rc > 0) {
lexerror(lex, "$framerestore requires a framename parameter"); lexerror(lex, "$modelname requires a parameter");
return lex_do(lex); return lex_do(lex);
} }
if (rc < 0) if (rc < 0)
@ -833,29 +790,19 @@ int lex_do(lex_file *lex)
m.value = lex->framevalue; m.value = lex->framevalue;
m.name = lex->modelname; m.name = lex->modelname;
lex->modelname = NULL; lex->modelname = NULL;
if (!lex_file_frames_add(lex, m)) { vec_push(lex->frames, m);
lexerror(lex, "out of memory");
return (lex->tok.ttype = TOKEN_FATAL);
}
} }
lex->modelname = lex->tok.value; lex->modelname = lex->tok.value;
lex->tok.value = NULL; lex->tok.value = NULL;
lex->tok.value_alloc = lex->tok.value_count = 0;
for (frame = 0; frame < lex->frames_count; ++frame) {
if (!strcmp(v, lex->frames[frame].name)) {
lex->framevalue = lex->frames[frame].value;
break;
}
}
return lex_do(lex); return lex_do(lex);
} }
if (!strcmp(v, "flush")) if (!strcmp(v, "flush"))
{ {
size_t frame; size_t frame;
for (frame = 0; frame < lex->frames_count; ++frame) for (frame = 0; frame < vec_size(lex->frames); ++frame)
mem_d(lex->frames[frame].name); mem_d(lex->frames[frame].name);
MEM_VECTOR_CLEAR(lex, frames); vec_free(lex->frames);
/* skip line (fteqcc does it too) */ /* skip line (fteqcc does it too) */
ch = lex_getch(lex); ch = lex_getch(lex);
while (ch != EOF && ch != '\n') while (ch != EOF && ch != '\n')
@ -877,7 +824,7 @@ int lex_do(lex_file *lex)
return lex_do(lex); return lex_do(lex);
} }
for (frame = 0; frame < lex->frames_count; ++frame) { for (frame = 0; frame < vec_size(lex->frames); ++frame) {
if (!strcmp(v, lex->frames[frame].name)) { if (!strcmp(v, lex->frames[frame].name)) {
lex->tok.constval.i = lex->frames[frame].value; lex->tok.constval.i = lex->frames[frame].value;
return (lex->tok.ttype = TOKEN_INTCONST); return (lex->tok.ttype = TOKEN_INTCONST);
@ -893,11 +840,8 @@ int lex_do(lex_file *lex)
{ {
case '[': case '[':
case '(': case '(':
if (!lex_tokench(lex, ch) || lex_tokench(lex, ch);
!lex_endtoken(lex)) lex_endtoken(lex);
{
return (lex->tok.ttype = TOKEN_FATAL);
}
if (lex->flags.noops) if (lex->flags.noops)
return (lex->tok.ttype = ch); return (lex->tok.ttype = ch);
else else
@ -909,11 +853,8 @@ int lex_do(lex_file *lex)
case ']': case ']':
case '#': case '#':
if (!lex_tokench(lex, ch) || lex_tokench(lex, ch);
!lex_endtoken(lex)) lex_endtoken(lex);
{
return (lex->tok.ttype = TOKEN_FATAL);
}
return (lex->tok.ttype = ch); return (lex->tok.ttype = ch);
default: default:
break; break;
@ -939,11 +880,8 @@ int lex_do(lex_file *lex)
case '~': case '~':
case ',': case ',':
case '!': case '!':
if (!lex_tokench(lex, ch) || lex_tokench(lex, ch);
!lex_endtoken(lex)) lex_endtoken(lex);
{
return (lex->tok.ttype = TOKEN_FATAL);
}
return (lex->tok.ttype = ch); return (lex->tok.ttype = ch);
default: default:
break; break;
@ -951,14 +889,12 @@ int lex_do(lex_file *lex)
if (ch == '.') if (ch == '.')
{ {
if (!lex_tokench(lex, ch)) lex_tokench(lex, ch);
return (lex->tok.ttype = TOKEN_FATAL);
/* peak ahead once */ /* peak ahead once */
nextch = lex_getch(lex); nextch = lex_getch(lex);
if (nextch != '.') { if (nextch != '.') {
lex_ungetch(lex, nextch); lex_ungetch(lex, nextch);
if (!lex_endtoken(lex)) lex_endtoken(lex);
return (lex->tok.ttype = TOKEN_FATAL);
return (lex->tok.ttype = ch); return (lex->tok.ttype = ch);
} }
/* peak ahead again */ /* peak ahead again */
@ -966,27 +902,20 @@ int lex_do(lex_file *lex)
if (nextch != '.') { if (nextch != '.') {
lex_ungetch(lex, nextch); lex_ungetch(lex, nextch);
lex_ungetch(lex, nextch); lex_ungetch(lex, nextch);
if (!lex_endtoken(lex)) lex_endtoken(lex);
return (lex->tok.ttype = TOKEN_FATAL);
return (lex->tok.ttype = ch); return (lex->tok.ttype = ch);
} }
/* fill the token to be "..." */ /* fill the token to be "..." */
if (!lex_tokench(lex, ch) || lex_tokench(lex, ch);
!lex_tokench(lex, ch) || lex_tokench(lex, ch);
!lex_endtoken(lex)) lex_endtoken(lex);
{
return (lex->tok.ttype = TOKEN_FATAL);
}
return (lex->tok.ttype = TOKEN_DOTS); return (lex->tok.ttype = TOKEN_DOTS);
} }
} }
if (ch == ',' || ch == '.') { if (ch == ',' || ch == '.') {
if (!lex_tokench(lex, ch) || lex_tokench(lex, ch);
!lex_endtoken(lex)) lex_endtoken(lex);
{
return (lex->tok.ttype = TOKEN_FATAL);
}
return (lex->tok.ttype = TOKEN_OPERATOR); return (lex->tok.ttype = TOKEN_OPERATOR);
} }
@ -995,50 +924,40 @@ int lex_do(lex_file *lex)
ch == '=' || ch == '!' || /* ==, != */ ch == '=' || ch == '!' || /* ==, != */
ch == '&' || ch == '|') /* &&, ||, &=, |= */ ch == '&' || ch == '|') /* &&, ||, &=, |= */
{ {
if (!lex_tokench(lex, ch)) lex_tokench(lex, ch);
return (lex->tok.ttype = TOKEN_FATAL);
nextch = lex_getch(lex); nextch = lex_getch(lex);
if (nextch == ch || nextch == '=') { if (nextch == ch || nextch == '=') {
if (!lex_tokench(lex, nextch)) lex_tokench(lex, nextch);
return (lex->tok.ttype = TOKEN_FATAL);
} else if (ch == '-' && nextch == '>') { } else if (ch == '-' && nextch == '>') {
if (!lex_tokench(lex, nextch)) lex_tokench(lex, nextch);
return (lex->tok.ttype = TOKEN_FATAL);
} else } else
lex_ungetch(lex, nextch); lex_ungetch(lex, nextch);
if (!lex_endtoken(lex)) lex_endtoken(lex);
return (lex->tok.ttype = TOKEN_FATAL);
return (lex->tok.ttype = TOKEN_OPERATOR); return (lex->tok.ttype = TOKEN_OPERATOR);
} }
/* /*
if (ch == '^' || ch == '~' || ch == '!') if (ch == '^' || ch == '~' || ch == '!')
{ {
if (!lex_tokench(lex, ch) || lex_tokench(lex, ch);
!lex_endtoken(lex)) lex_endtoken(lex);
{
return (lex->tok.ttype = TOKEN_FATAL);
}
return (lex->tok.ttype = TOKEN_OPERATOR); return (lex->tok.ttype = TOKEN_OPERATOR);
} }
*/ */
if (ch == '*' || ch == '/') /* *=, /= */ if (ch == '*' || ch == '/') /* *=, /= */
{ {
if (!lex_tokench(lex, ch)) lex_tokench(lex, ch);
return (lex->tok.ttype = TOKEN_FATAL);
nextch = lex_getch(lex); nextch = lex_getch(lex);
if (nextch == '=') { if (nextch == '=') {
if (!lex_tokench(lex, nextch)) lex_tokench(lex, nextch);
return (lex->tok.ttype = TOKEN_FATAL);
} else } else
lex_ungetch(lex, nextch); lex_ungetch(lex, nextch);
if (!lex_endtoken(lex)) lex_endtoken(lex);
return (lex->tok.ttype = TOKEN_FATAL);
return (lex->tok.ttype = TOKEN_OPERATOR); return (lex->tok.ttype = TOKEN_OPERATOR);
} }
@ -1046,14 +965,12 @@ int lex_do(lex_file *lex)
{ {
const char *v; const char *v;
if (!lex_tokench(lex, ch)) lex_tokench(lex, ch);
return (lex->tok.ttype = TOKEN_FATAL);
if (!lex_finish_ident(lex)) { if (!lex_finish_ident(lex)) {
/* error? */ /* error? */
return (lex->tok.ttype = TOKEN_ERROR); return (lex->tok.ttype = TOKEN_ERROR);
} }
if (!lex_endtoken(lex)) lex_endtoken(lex);
return (lex->tok.ttype = TOKEN_FATAL);
lex->tok.ttype = TOKEN_IDENT; lex->tok.ttype = TOKEN_IDENT;
v = lex->tok.value; v = lex->tok.value;
@ -1107,11 +1024,11 @@ int lex_do(lex_file *lex)
if (ch == '"') if (ch == '"')
{ {
lex->flags.nodigraphs = true; lex->flags.nodigraphs = true;
if (lex->flags.preprocessing && !lex_tokench(lex, ch)) if (lex->flags.preprocessing)
return TOKEN_FATAL; lex_tokench(lex, ch);
lex->tok.ttype = lex_finish_string(lex, '"'); lex->tok.ttype = lex_finish_string(lex, '"');
if (lex->flags.preprocessing && !lex_tokench(lex, ch)) if (lex->flags.preprocessing)
return TOKEN_FATAL; lex_tokench(lex, ch);
while (!lex->flags.preprocessing && lex->tok.ttype == TOKEN_STRINGCONST) while (!lex->flags.preprocessing && lex->tok.ttype == TOKEN_STRINGCONST)
{ {
/* Allow c style "string" "continuation" */ /* Allow c style "string" "continuation" */
@ -1124,8 +1041,7 @@ int lex_do(lex_file *lex)
lex->tok.ttype = lex_finish_string(lex, '"'); lex->tok.ttype = lex_finish_string(lex, '"');
} }
lex->flags.nodigraphs = false; lex->flags.nodigraphs = false;
if (!lex_endtoken(lex)) lex_endtoken(lex);
return (lex->tok.ttype = TOKEN_FATAL);
return lex->tok.ttype; return lex->tok.ttype;
} }
@ -1136,13 +1052,12 @@ int lex_do(lex_file *lex)
* Likewise actual unescaping has to be done by the parser. * Likewise actual unescaping has to be done by the parser.
* The difference is we don't allow 'char' 'continuation'. * The difference is we don't allow 'char' 'continuation'.
*/ */
if (lex->flags.preprocessing && !lex_tokench(lex, ch)) if (lex->flags.preprocessing)
return TOKEN_FATAL; lex_tokench(lex, ch);
lex->tok.ttype = lex_finish_string(lex, '\''); lex->tok.ttype = lex_finish_string(lex, '\'');
if (lex->flags.preprocessing && !lex_tokench(lex, ch)) if (lex->flags.preprocessing)
return TOKEN_FATAL; lex_tokench(lex, ch);
if (!lex_endtoken(lex)) lex_endtoken(lex);
return (lex->tok.ttype = TOKEN_FATAL);
/* It's a vector if we can successfully scan 3 floats */ /* It's a vector if we can successfully scan 3 floats */
#ifdef WIN32 #ifdef WIN32
@ -1163,8 +1078,7 @@ int lex_do(lex_file *lex)
if (isdigit(ch)) if (isdigit(ch))
{ {
lex->tok.ttype = lex_finish_digit(lex, ch); lex->tok.ttype = lex_finish_digit(lex, ch);
if (!lex_endtoken(lex)) lex_endtoken(lex);
return (lex->tok.ttype = TOKEN_FATAL);
return lex->tok.ttype; return lex->tok.ttype;
} }

6
lexer.h
View file

@ -8,7 +8,7 @@ typedef struct token_s token;
struct token_s { struct token_s {
int ttype; int ttype;
MEM_VECTOR_MAKE(char, value); char *value;
union { union {
vector v; vector v;
@ -122,12 +122,10 @@ typedef struct {
} flags; } flags;
int framevalue; int framevalue;
MEM_VECTOR_MAKE(frame_macro, frames); frame_macro *frames;
char *modelname; char *modelname;
} lex_file; } lex_file;
MEM_VECTOR_PROTO(lex_file, char, token);
lex_file* lex_open (const char *file); lex_file* lex_open (const char *file);
lex_file* lex_open_string(const char *str, size_t len, const char *name); lex_file* lex_open_string(const char *str, size_t len, const char *name);
void lex_close(lex_file *lex); void lex_close(lex_file *lex);