From: Wolfgang (Blub) Bumiller Date: Sat, 18 Aug 2012 12:27:19 +0000 (+0200) Subject: Fix indentation of lexer.c - was still using some tabs there X-Git-Tag: 0.1-rc1~229 X-Git-Url: https://git.rm.cloudns.org/?a=commitdiff_plain;h=d3492d4a13a97c4a3a9c155b53323709cd8ac7fa;p=xonotic%2Fgmqcc.git Fix indentation of lexer.c - was still using some tabs there --- diff --git a/lexer.c b/lexer.c index 1adedc2..222ed84 100644 --- a/lexer.c +++ b/lexer.c @@ -11,151 +11,151 @@ MEM_VEC_FUNCTIONS(lex_file, frame_macro, frames) void lexerror(lex_file *lex, const char *fmt, ...) { - va_list ap; + va_list ap; - if (lex) - printf("error %s:%lu: ", lex->name, (unsigned long)lex->sline); - else - printf("error: "); + if (lex) + printf("error %s:%lu: ", lex->name, (unsigned long)lex->sline); + else + printf("error: "); - va_start(ap, fmt); - vprintf(fmt, ap); - va_end(ap); + va_start(ap, fmt); + vprintf(fmt, ap); + va_end(ap); - printf("\n"); + printf("\n"); } void lexwarn(lex_file *lex, int warn, const char *fmt, ...) { - va_list ap; + va_list ap; - if (!OPTS_WARN(warn)) - return; + if (!OPTS_WARN(warn)) + return; - if (lex) - printf("warning %s:%lu: ", lex->name, (unsigned long)lex->sline); - else - printf("warning: "); + if (lex) + printf("warning %s:%lu: ", lex->name, (unsigned long)lex->sline); + else + printf("warning: "); - va_start(ap, fmt); - vprintf(fmt, ap); - va_end(ap); + va_start(ap, fmt); + vprintf(fmt, ap); + va_end(ap); - printf("\n"); + printf("\n"); } token* token_new() { - token *tok = (token*)mem_a(sizeof(token)); - if (!tok) - return NULL; - memset(tok, 0, sizeof(*tok)); - return tok; + token *tok = (token*)mem_a(sizeof(token)); + if (!tok) + return NULL; + memset(tok, 0, sizeof(*tok)); + return tok; } void token_delete(token *self) { - if (self->next && self->next->prev == self) - self->next->prev = self->prev; - if (self->prev && self->prev->next == self) - self->prev->next = self->next; - MEM_VECTOR_CLEAR(self, value); - mem_d(self); + if (self->next && self->next->prev == self) + self->next->prev = self->prev; + if (self->prev && self->prev->next == self) + self->prev->next = self->next; + MEM_VECTOR_CLEAR(self, value); + mem_d(self); } token* token_copy(const token *cp) { - token* self = token_new(); - if (!self) - return NULL; - /* copy the value */ - self->value_alloc = cp->value_count + 1; - self->value_count = cp->value_count; - self->value = (char*)mem_a(self->value_alloc); - if (!self->value) { - mem_d(self); - return NULL; - } - memcpy(self->value, cp->value, cp->value_count); - self->value[self->value_alloc-1] = 0; - - /* rest */ - self->ctx = cp->ctx; - self->ttype = cp->ttype; - memcpy(&self->constval, &cp->constval, sizeof(self->constval)); - return self; + token* self = token_new(); + if (!self) + return NULL; + /* copy the value */ + self->value_alloc = cp->value_count + 1; + self->value_count = cp->value_count; + self->value = (char*)mem_a(self->value_alloc); + if (!self->value) { + mem_d(self); + return NULL; + } + memcpy(self->value, cp->value, cp->value_count); + self->value[self->value_alloc-1] = 0; + + /* rest */ + self->ctx = cp->ctx; + self->ttype = cp->ttype; + memcpy(&self->constval, &cp->constval, sizeof(self->constval)); + return self; } void token_delete_all(token *t) { - token *n; + token *n; - do { - n = t->next; - token_delete(t); - t = n; - } while(t); + do { + n = t->next; + token_delete(t); + t = n; + } while(t); } token* token_copy_all(const token *cp) { - token *cur; - token *out; - - out = cur = token_copy(cp); - if (!out) - return NULL; - - while (cp->next) { - cp = cp->next; - cur->next = token_copy(cp); - if (!cur->next) { - token_delete_all(out); - return NULL; - } - cur->next->prev = cur; - cur = cur->next; - } - - return out; + token *cur; + token *out; + + out = cur = token_copy(cp); + if (!out) + return NULL; + + while (cp->next) { + cp = cp->next; + cur->next = token_copy(cp); + if (!cur->next) { + token_delete_all(out); + return NULL; + } + cur->next->prev = cur; + cur = cur->next; + } + + return out; } lex_file* lex_open(const char *file) { - lex_file *lex; - FILE *in = util_fopen(file, "rb"); + lex_file *lex; + FILE *in = util_fopen(file, "rb"); - if (!in) { - lexerror(NULL, "open failed: '%s'\n", file); - return NULL; - } + if (!in) { + lexerror(NULL, "open failed: '%s'\n", file); + return NULL; + } - lex = (lex_file*)mem_a(sizeof(*lex)); - if (!lex) { - fclose(in); - lexerror(NULL, "out of memory\n"); - return NULL; - } + lex = (lex_file*)mem_a(sizeof(*lex)); + if (!lex) { + fclose(in); + lexerror(NULL, "out of memory\n"); + return NULL; + } - memset(lex, 0, sizeof(*lex)); + memset(lex, 0, sizeof(*lex)); - lex->file = in; - lex->name = util_strdup(file); - lex->line = 1; /* we start counting at 1 */ + lex->file = in; + lex->name = util_strdup(file); + lex->line = 1; /* we start counting at 1 */ - lex->peekpos = 0; + lex->peekpos = 0; - return lex; + return lex; } void lex_close(lex_file *lex) { - if (lex->file) - fclose(lex->file); - if (lex->tok) - token_delete(lex->tok); - mem_d(lex->name); - mem_d(lex); + if (lex->file) + fclose(lex->file); + if (lex->tok) + token_delete(lex->tok); + mem_d(lex->name); + mem_d(lex); } /* Get or put-back data @@ -165,26 +165,26 @@ void lex_close(lex_file *lex) */ static int lex_getch(lex_file *lex) { - int ch; - - if (lex->peekpos) { - lex->peekpos--; - if (lex->peek[lex->peekpos] == '\n') - lex->line++; - return lex->peek[lex->peekpos]; - } - - ch = fgetc(lex->file); - if (ch == '\n') - lex->line++; - return ch; + int ch; + + if (lex->peekpos) { + lex->peekpos--; + if (lex->peek[lex->peekpos] == '\n') + lex->line++; + return lex->peek[lex->peekpos]; + } + + ch = fgetc(lex->file); + if (ch == '\n') + lex->line++; + return ch; } static void lex_ungetch(lex_file *lex, int ch) { - lex->peek[lex->peekpos++] = ch; - if (ch == '\n') - lex->line--; + lex->peek[lex->peekpos++] = ch; + if (ch == '\n') + lex->line--; } /* classify characters @@ -194,12 +194,12 @@ static void lex_ungetch(lex_file *lex, int ch) /* Idents are alphanumberic, but they start with alpha or _ */ static bool isident_start(int ch) { - return isalpha(ch) || ch == '_'; + return isalpha(ch) || ch == '_'; } static bool isident(int ch) { - return isident_start(ch) || isdigit(ch); + return isident_start(ch) || isdigit(ch); } /* isxdigit_only is used when we already know it's not a digit @@ -207,7 +207,7 @@ static bool isident(int ch) */ static bool isxdigit_only(int ch) { - return (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F'); + return (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F'); } /* Skip whitespace and comments and return the first @@ -244,103 +244,103 @@ printf( "line one\n" */ static int lex_skipwhite(lex_file *lex) { - int ch = 0; - - do - { - ch = lex_getch(lex); - while (ch != EOF && isspace(ch)) ch = lex_getch(lex); - - if (ch == '/') { - ch = lex_getch(lex); - if (ch == '/') - { - /* one line comment */ - ch = lex_getch(lex); - - /* check for special: '/', '/', '*', '/' */ - if (ch == '*') { - ch = lex_getch(lex); - if (ch == '/') { - ch = ' '; - continue; - } - } - - while (ch != EOF && ch != '\n') { - ch = lex_getch(lex); - } - continue; - } - if (ch == '*') - { - /* multiline comment */ - while (ch != EOF) - { - ch = lex_getch(lex); - if (ch == '*') { - ch = lex_getch(lex); - if (ch == '/') { - ch = lex_getch(lex); - break; - } - } - } - if (ch == '/') /* allow *//* direct following comment */ - { - lex_ungetch(lex, ch); - ch = ' '; /* cause TRUE in the isspace check */ - } - continue; - } - /* Otherwise roll back to the slash and break out of the loop */ - lex_ungetch(lex, ch); - ch = '/'; - break; - } - } while (ch != EOF && isspace(ch)); - - return ch; + int ch = 0; + + do + { + ch = lex_getch(lex); + while (ch != EOF && isspace(ch)) ch = lex_getch(lex); + + if (ch == '/') { + ch = lex_getch(lex); + if (ch == '/') + { + /* one line comment */ + ch = lex_getch(lex); + + /* check for special: '/', '/', '*', '/' */ + if (ch == '*') { + ch = lex_getch(lex); + if (ch == '/') { + ch = ' '; + continue; + } + } + + while (ch != EOF && ch != '\n') { + ch = lex_getch(lex); + } + continue; + } + if (ch == '*') + { + /* multiline comment */ + while (ch != EOF) + { + ch = lex_getch(lex); + if (ch == '*') { + ch = lex_getch(lex); + if (ch == '/') { + ch = lex_getch(lex); + break; + } + } + } + if (ch == '/') /* allow *//* direct following comment */ + { + lex_ungetch(lex, ch); + ch = ' '; /* cause TRUE in the isspace check */ + } + continue; + } + /* Otherwise roll back to the slash and break out of the loop */ + lex_ungetch(lex, ch); + ch = '/'; + break; + } + } while (ch != EOF && isspace(ch)); + + return ch; } /* Append a character to the token buffer */ static bool GMQCC_WARN lex_tokench(lex_file *lex, int ch) { - if (!token_value_add(lex->tok, ch)) { - lexerror(lex, "out of memory"); - return false; - } - return true; + if (!token_value_add(lex->tok, ch)) { + lexerror(lex, "out of memory"); + return false; + } + return true; } /* Append a trailing null-byte */ static bool GMQCC_WARN lex_endtoken(lex_file *lex) { - if (!token_value_add(lex->tok, 0)) { - lexerror(lex, "out of memory"); - return false; - } - lex->tok->value_count--; - return true; + if (!token_value_add(lex->tok, 0)) { + lexerror(lex, "out of memory"); + return false; + } + lex->tok->value_count--; + return true; } /* Get a token */ static bool GMQCC_WARN lex_finish_ident(lex_file *lex) { - int ch; + int ch; - ch = lex_getch(lex); - while (ch != EOF && isident(ch)) - { - if (!lex_tokench(lex, ch)) - return (lex->tok->ttype = TOKEN_FATAL); - ch = lex_getch(lex); - } + ch = lex_getch(lex); + while (ch != EOF && isident(ch)) + { + if (!lex_tokench(lex, ch)) + return (lex->tok->ttype = TOKEN_FATAL); + ch = lex_getch(lex); + } - /* last ch was not an ident ch: */ - lex_ungetch(lex, ch); + /* last ch was not an ident ch: */ + lex_ungetch(lex, ch); - return true; + return true; } /* read one ident for the frame list */ @@ -398,21 +398,21 @@ static bool lex_finish_frames(lex_file *lex) static int GMQCC_WARN lex_finish_string(lex_file *lex, int quote) { - int ch = 0; - - while (ch != EOF) - { - ch = lex_getch(lex); - if (ch == quote) - return TOKEN_STRINGCONST; - - if (ch == '\\') { - ch = lex_getch(lex); - if (ch == EOF) { - lexerror(lex, "unexpected end of file"); - lex_ungetch(lex, EOF); /* next token to be TOKEN_EOF */ - return (lex->tok->ttype = TOKEN_ERROR); - } + int ch = 0; + + while (ch != EOF) + { + ch = lex_getch(lex); + if (ch == quote) + return TOKEN_STRINGCONST; + + if (ch == '\\') { + ch = lex_getch(lex); + if (ch == EOF) { + lexerror(lex, "unexpected end of file"); + lex_ungetch(lex, EOF); /* next token to be TOKEN_EOF */ + return (lex->tok->ttype = TOKEN_ERROR); + } switch (ch) { case '\\': break; @@ -425,139 +425,139 @@ static int GMQCC_WARN lex_finish_string(lex_file *lex, int quote) case 'v': ch = '\v'; break; default: 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 */ - if (!lex_tokench(lex, '\\')) - return (lex->tok->ttype = TOKEN_FATAL); + /* so we just add the character plus backslash no matter what it actually is */ + if (!lex_tokench(lex, '\\')) + return (lex->tok->ttype = TOKEN_FATAL); } /* add the character finally */ - if (!lex_tokench(lex, ch)) - return (lex->tok->ttype = TOKEN_FATAL); - } - else if (!lex_tokench(lex, ch)) - return (lex->tok->ttype = TOKEN_FATAL); - } - lexerror(lex, "unexpected end of file within string constant"); - lex_ungetch(lex, EOF); /* next token to be TOKEN_EOF */ - return (lex->tok->ttype = TOKEN_ERROR); + if (!lex_tokench(lex, ch)) + return (lex->tok->ttype = TOKEN_FATAL); + } + else if (!lex_tokench(lex, ch)) + return (lex->tok->ttype = TOKEN_FATAL); + } + lexerror(lex, "unexpected end of file within string constant"); + lex_ungetch(lex, EOF); /* next token to be TOKEN_EOF */ + return (lex->tok->ttype = TOKEN_ERROR); } static int GMQCC_WARN lex_finish_digit(lex_file *lex, int lastch) { - bool ishex = false; - - int ch = lastch; - - /* parse a number... */ - lex->tok->ttype = TOKEN_INTCONST; - - if (!lex_tokench(lex, ch)) - return (lex->tok->ttype = TOKEN_FATAL); - - ch = lex_getch(lex); - if (ch != '.' && !isdigit(ch)) - { - if (lastch != '0' || ch != 'x') - { - /* end of the number or EOF */ - lex_ungetch(lex, ch); - if (!lex_endtoken(lex)) - return (lex->tok->ttype = TOKEN_FATAL); - - lex->tok->constval.i = lastch - '0'; - return lex->tok->ttype; - } - - ishex = true; - } - - /* EOF would have been caught above */ - - if (ch != '.') - { - if (!lex_tokench(lex, ch)) - return (lex->tok->ttype = TOKEN_FATAL); - ch = lex_getch(lex); - while (isdigit(ch) || (ishex && isxdigit_only(ch))) - { - if (!lex_tokench(lex, ch)) - return (lex->tok->ttype = TOKEN_FATAL); - ch = lex_getch(lex); - } - } - /* NOT else, '.' can come from above as well */ - if (ch == '.' && !ishex) - { - /* Allow floating comma in non-hex mode */ - lex->tok->ttype = TOKEN_FLOATCONST; - if (!lex_tokench(lex, ch)) - return (lex->tok->ttype = TOKEN_FATAL); - - /* continue digits-only */ - ch = lex_getch(lex); - while (isdigit(ch)) - { - if (!lex_tokench(lex, ch)) - return (lex->tok->ttype = TOKEN_FATAL); - ch = lex_getch(lex); - } - } - /* put back the last character */ - /* but do not put back the trailing 'f' or a float */ - if (lex->tok->ttype == TOKEN_FLOATCONST && ch == 'f') - ch = lex_getch(lex); - - /* generally we don't want words to follow numbers: */ - if (isident(ch)) { - lexerror(lex, "unexpected trailing characters after number"); - return (lex->tok->ttype = TOKEN_ERROR); - } - lex_ungetch(lex, ch); - - if (!lex_endtoken(lex)) - return (lex->tok->ttype = TOKEN_FATAL); - if (lex->tok->ttype == TOKEN_FLOATCONST) - lex->tok->constval.f = strtod(lex->tok->value, NULL); - else - lex->tok->constval.i = strtol(lex->tok->value, NULL, 0); - return lex->tok->ttype; + bool ishex = false; + + int ch = lastch; + + /* parse a number... */ + lex->tok->ttype = TOKEN_INTCONST; + + if (!lex_tokench(lex, ch)) + return (lex->tok->ttype = TOKEN_FATAL); + + ch = lex_getch(lex); + if (ch != '.' && !isdigit(ch)) + { + if (lastch != '0' || ch != 'x') + { + /* end of the number or EOF */ + lex_ungetch(lex, ch); + if (!lex_endtoken(lex)) + return (lex->tok->ttype = TOKEN_FATAL); + + lex->tok->constval.i = lastch - '0'; + return lex->tok->ttype; + } + + ishex = true; + } + + /* EOF would have been caught above */ + + if (ch != '.') + { + if (!lex_tokench(lex, ch)) + return (lex->tok->ttype = TOKEN_FATAL); + ch = lex_getch(lex); + while (isdigit(ch) || (ishex && isxdigit_only(ch))) + { + if (!lex_tokench(lex, ch)) + return (lex->tok->ttype = TOKEN_FATAL); + ch = lex_getch(lex); + } + } + /* NOT else, '.' can come from above as well */ + if (ch == '.' && !ishex) + { + /* Allow floating comma in non-hex mode */ + lex->tok->ttype = TOKEN_FLOATCONST; + if (!lex_tokench(lex, ch)) + return (lex->tok->ttype = TOKEN_FATAL); + + /* continue digits-only */ + ch = lex_getch(lex); + while (isdigit(ch)) + { + if (!lex_tokench(lex, ch)) + return (lex->tok->ttype = TOKEN_FATAL); + ch = lex_getch(lex); + } + } + /* put back the last character */ + /* but do not put back the trailing 'f' or a float */ + if (lex->tok->ttype == TOKEN_FLOATCONST && ch == 'f') + ch = lex_getch(lex); + + /* generally we don't want words to follow numbers: */ + if (isident(ch)) { + lexerror(lex, "unexpected trailing characters after number"); + return (lex->tok->ttype = TOKEN_ERROR); + } + lex_ungetch(lex, ch); + + if (!lex_endtoken(lex)) + return (lex->tok->ttype = TOKEN_FATAL); + if (lex->tok->ttype == TOKEN_FLOATCONST) + lex->tok->constval.f = strtod(lex->tok->value, NULL); + else + lex->tok->constval.i = strtol(lex->tok->value, NULL, 0); + return lex->tok->ttype; } int lex_do(lex_file *lex) { - int ch, nextch; - - if (lex->tok) - token_delete(lex->tok); - lex->tok = token_new(); - if (!lex->tok) - return TOKEN_FATAL; - - ch = lex_skipwhite(lex); - lex->sline = lex->line; - lex->tok->ctx.line = lex->sline; - lex->tok->ctx.file = lex->name; - - if (ch == EOF) - return (lex->tok->ttype = TOKEN_EOF); - - /* modelgen / spiritgen commands */ - if (ch == '$') { - const char *v; - size_t frame; - - ch = lex_getch(lex); - if (!isident_start(ch)) { - lexerror(lex, "hanging '$' modelgen/spritegen command line"); - return lex_do(lex); - } - if (!lex_tokench(lex, ch)) - return (lex->tok->ttype = TOKEN_FATAL); - if (!lex_finish_ident(lex)) - return (lex->tok->ttype = TOKEN_ERROR); - if (!lex_endtoken(lex)) - return (lex->tok->ttype = TOKEN_FATAL); - /* skip the known commands */ - v = lex->tok->value; + int ch, nextch; + + if (lex->tok) + token_delete(lex->tok); + lex->tok = token_new(); + if (!lex->tok) + return TOKEN_FATAL; + + ch = lex_skipwhite(lex); + lex->sline = lex->line; + lex->tok->ctx.line = lex->sline; + lex->tok->ctx.file = lex->name; + + if (ch == EOF) + return (lex->tok->ttype = TOKEN_EOF); + + /* modelgen / spiritgen commands */ + if (ch == '$') { + const char *v; + size_t frame; + + ch = lex_getch(lex); + if (!isident_start(ch)) { + lexerror(lex, "hanging '$' modelgen/spritegen command line"); + return lex_do(lex); + } + if (!lex_tokench(lex, ch)) + return (lex->tok->ttype = TOKEN_FATAL); + if (!lex_finish_ident(lex)) + return (lex->tok->ttype = TOKEN_ERROR); + if (!lex_endtoken(lex)) + return (lex->tok->ttype = TOKEN_FATAL); + /* skip the known commands */ + v = lex->tok->value; if (!strcmp(v, "frame") || !strcmp(v, "framesave")) { @@ -582,8 +582,8 @@ int lex_do(lex_file *lex) return lex_do(lex); } - token_delete(lex->tok); - lex->tok = token_new(); + token_delete(lex->tok); + lex->tok = token_new(); lex->tok->ttype = lex_finish_digit(lex, ch); if (!lex_endtoken(lex)) return (lex->tok->ttype = TOKEN_FATAL); @@ -599,8 +599,8 @@ int lex_do(lex_file *lex) { int rc; - token_delete(lex->tok); - lex->tok = token_new(); + token_delete(lex->tok); + lex->tok = token_new(); rc = lex_parse_frame(lex); @@ -626,8 +626,8 @@ int lex_do(lex_file *lex) { int rc; - token_delete(lex->tok); - lex->tok = token_new(); + token_delete(lex->tok); + lex->tok = token_new(); rc = lex_parse_frame(lex); @@ -666,26 +666,26 @@ int lex_do(lex_file *lex) for (frame = 0; frame < lex->frames_count; ++frame) mem_d(lex->frames[frame].name); MEM_VECTOR_CLEAR(lex, frames); - /* skip line (fteqcc does it too) */ - ch = lex_getch(lex); - while (ch != EOF && ch != '\n') - ch = lex_getch(lex); + /* skip line (fteqcc does it too) */ + ch = lex_getch(lex); + while (ch != EOF && ch != '\n') + ch = lex_getch(lex); return lex_do(lex); } - if (!strcmp(v, "cd") || - !strcmp(v, "origin") || - !strcmp(v, "base") || - !strcmp(v, "flags") || - !strcmp(v, "scale") || - !strcmp(v, "skin")) - { - /* skip line */ - ch = lex_getch(lex); - while (ch != EOF && ch != '\n') - ch = lex_getch(lex); - return lex_do(lex); - } + if (!strcmp(v, "cd") || + !strcmp(v, "origin") || + !strcmp(v, "base") || + !strcmp(v, "flags") || + !strcmp(v, "scale") || + !strcmp(v, "skin")) + { + /* skip line */ + ch = lex_getch(lex); + while (ch != EOF && ch != '\n') + ch = lex_getch(lex); + return lex_do(lex); + } for (frame = 0; frame < lex->frames_count; ++frame) { if (!strcmp(v, lex->frames[frame].name)) { @@ -696,231 +696,231 @@ int lex_do(lex_file *lex) lexerror(lex, "invalid frame macro"); return lex_do(lex); - } - - /* single-character tokens */ - switch (ch) - { - case '(': - if (!lex_tokench(lex, ch) || - !lex_endtoken(lex)) - { - return (lex->tok->ttype = TOKEN_FATAL); - } - if (lex->flags.noops) - return (lex->tok->ttype = ch); - else - return (lex->tok->ttype = TOKEN_OPERATOR); - case ')': - case ';': - case '{': - case '}': - case '[': - case ']': - - case '#': - if (!lex_tokench(lex, ch) || - !lex_endtoken(lex)) - { - return (lex->tok->ttype = TOKEN_FATAL); - } - return (lex->tok->ttype = ch); - default: - break; - } - - if (lex->flags.noops) - { - /* Detect characters early which are normally - * operators OR PART of an operator. - */ - switch (ch) - { - case '+': - case '-': - case '*': - case '/': - case '<': - case '>': - case '=': - case '&': - case '|': - case '^': - case '~': - case ',': - case '.': - case '!': - if (!lex_tokench(lex, ch) || - !lex_endtoken(lex)) - { - return (lex->tok->ttype = TOKEN_FATAL); - } - return (lex->tok->ttype = ch); - default: - break; - } - } - - if (ch == ',' || ch == '.') { - if (!lex_tokench(lex, ch) || - !lex_endtoken(lex)) - { - return (lex->tok->ttype = TOKEN_FATAL); - } - return (lex->tok->ttype = TOKEN_OPERATOR); - } - - if (ch == '+' || ch == '-' || /* ++, --, +=, -= and -> as well! */ - ch == '>' || ch == '<' || /* <<, >>, <=, >= */ - ch == '=' || ch == '!' || /* ==, != */ - ch == '&' || ch == '|') /* &&, ||, &=, |= */ - { - if (!lex_tokench(lex, ch)) - return (lex->tok->ttype = TOKEN_FATAL); - - nextch = lex_getch(lex); - if (nextch == ch || nextch == '=') { - if (!lex_tokench(lex, nextch)) - return (lex->tok->ttype = TOKEN_FATAL); - } else if (ch == '-' && nextch == '>') { - if (!lex_tokench(lex, nextch)) - return (lex->tok->ttype = TOKEN_FATAL); - } else - lex_ungetch(lex, nextch); - - if (!lex_endtoken(lex)) - return (lex->tok->ttype = TOKEN_FATAL); - return (lex->tok->ttype = TOKEN_OPERATOR); - } + } + + /* single-character tokens */ + switch (ch) + { + case '(': + if (!lex_tokench(lex, ch) || + !lex_endtoken(lex)) + { + return (lex->tok->ttype = TOKEN_FATAL); + } + if (lex->flags.noops) + return (lex->tok->ttype = ch); + else + return (lex->tok->ttype = TOKEN_OPERATOR); + case ')': + case ';': + case '{': + case '}': + case '[': + case ']': + + case '#': + if (!lex_tokench(lex, ch) || + !lex_endtoken(lex)) + { + return (lex->tok->ttype = TOKEN_FATAL); + } + return (lex->tok->ttype = ch); + default: + break; + } + + if (lex->flags.noops) + { + /* Detect characters early which are normally + * operators OR PART of an operator. + */ + switch (ch) + { + case '+': + case '-': + case '*': + case '/': + case '<': + case '>': + case '=': + case '&': + case '|': + case '^': + case '~': + case ',': + case '.': + case '!': + if (!lex_tokench(lex, ch) || + !lex_endtoken(lex)) + { + return (lex->tok->ttype = TOKEN_FATAL); + } + return (lex->tok->ttype = ch); + default: + break; + } + } + + if (ch == ',' || ch == '.') { + if (!lex_tokench(lex, ch) || + !lex_endtoken(lex)) + { + return (lex->tok->ttype = TOKEN_FATAL); + } + return (lex->tok->ttype = TOKEN_OPERATOR); + } + + if (ch == '+' || ch == '-' || /* ++, --, +=, -= and -> as well! */ + ch == '>' || ch == '<' || /* <<, >>, <=, >= */ + ch == '=' || ch == '!' || /* ==, != */ + ch == '&' || ch == '|') /* &&, ||, &=, |= */ + { + if (!lex_tokench(lex, ch)) + return (lex->tok->ttype = TOKEN_FATAL); + + nextch = lex_getch(lex); + if (nextch == ch || nextch == '=') { + if (!lex_tokench(lex, nextch)) + return (lex->tok->ttype = TOKEN_FATAL); + } else if (ch == '-' && nextch == '>') { + if (!lex_tokench(lex, nextch)) + return (lex->tok->ttype = TOKEN_FATAL); + } else + lex_ungetch(lex, nextch); + + if (!lex_endtoken(lex)) + return (lex->tok->ttype = TOKEN_FATAL); + return (lex->tok->ttype = TOKEN_OPERATOR); + } /* - if (ch == '^' || ch == '~' || ch == '!') - { - if (!lex_tokench(lex, ch) || - !lex_endtoken(lex)) - { - return (lex->tok->ttype = TOKEN_FATAL); - } - return (lex->tok->ttype = TOKEN_OPERATOR); - } - */ - - if (ch == '*' || ch == '/') /* *=, /= */ - { - if (!lex_tokench(lex, ch)) - return (lex->tok->ttype = TOKEN_FATAL); - - nextch = lex_getch(lex); - if (nextch == '=') { - if (!lex_tokench(lex, nextch)) - return (lex->tok->ttype = TOKEN_FATAL); - } else - lex_ungetch(lex, nextch); - - if (!lex_endtoken(lex)) - return (lex->tok->ttype = TOKEN_FATAL); - return (lex->tok->ttype = TOKEN_OPERATOR); - } - - if (isident_start(ch)) - { - const char *v; - - if (!lex_tokench(lex, ch)) - return (lex->tok->ttype = TOKEN_FATAL); - if (!lex_finish_ident(lex)) { - /* error? */ - return (lex->tok->ttype = TOKEN_ERROR); - } - if (!lex_endtoken(lex)) - return (lex->tok->ttype = TOKEN_FATAL); - lex->tok->ttype = TOKEN_IDENT; - - v = lex->tok->value; - if (!strcmp(v, "void")) { - lex->tok->ttype = TOKEN_TYPENAME; - lex->tok->constval.t = TYPE_VOID; - } else if (!strcmp(v, "int")) { - lex->tok->ttype = TOKEN_TYPENAME; - lex->tok->constval.t = TYPE_INTEGER; - } else if (!strcmp(v, "float")) { - lex->tok->ttype = TOKEN_TYPENAME; - lex->tok->constval.t = TYPE_FLOAT; - } else if (!strcmp(v, "string")) { - lex->tok->ttype = TOKEN_TYPENAME; - lex->tok->constval.t = TYPE_STRING; - } else if (!strcmp(v, "entity")) { - lex->tok->ttype = TOKEN_TYPENAME; - lex->tok->constval.t = TYPE_ENTITY; - } else if (!strcmp(v, "vector")) { - lex->tok->ttype = TOKEN_TYPENAME; - lex->tok->constval.t = TYPE_VECTOR; - } else if (!strcmp(v, "for") || - !strcmp(v, "while") || - !strcmp(v, "do") || - !strcmp(v, "if") || - !strcmp(v, "else") || - !strcmp(v, "local") || - !strcmp(v, "return") || - !strcmp(v, "const")) - lex->tok->ttype = TOKEN_KEYWORD; - - return lex->tok->ttype; - } - - if (ch == '"') - { - lex->tok->ttype = lex_finish_string(lex, '"'); - while (lex->tok->ttype == TOKEN_STRINGCONST) - { - /* Allow c style "string" "continuation" */ - ch = lex_skipwhite(lex); - if (ch != '"') { - lex_ungetch(lex, ch); - break; - } - - lex->tok->ttype = lex_finish_string(lex, '"'); - } - if (!lex_endtoken(lex)) - return (lex->tok->ttype = TOKEN_FATAL); - return lex->tok->ttype; - } - - if (ch == '\'') - { - /* we parse character constants like string, - * but return TOKEN_CHARCONST, or a vector type if it fits... - * Likewise actual unescaping has to be done by the parser. - * The difference is we don't allow 'char' 'continuation'. - */ - lex->tok->ttype = lex_finish_string(lex, '\''); - if (!lex_endtoken(lex)) - return (lex->tok->ttype = TOKEN_FATAL); - - /* It's a vector if we can successfully scan 3 floats */ + if (ch == '^' || ch == '~' || ch == '!') + { + if (!lex_tokench(lex, ch) || + !lex_endtoken(lex)) + { + return (lex->tok->ttype = TOKEN_FATAL); + } + return (lex->tok->ttype = TOKEN_OPERATOR); + } + */ + + if (ch == '*' || ch == '/') /* *=, /= */ + { + if (!lex_tokench(lex, ch)) + return (lex->tok->ttype = TOKEN_FATAL); + + nextch = lex_getch(lex); + if (nextch == '=') { + if (!lex_tokench(lex, nextch)) + return (lex->tok->ttype = TOKEN_FATAL); + } else + lex_ungetch(lex, nextch); + + if (!lex_endtoken(lex)) + return (lex->tok->ttype = TOKEN_FATAL); + return (lex->tok->ttype = TOKEN_OPERATOR); + } + + if (isident_start(ch)) + { + const char *v; + + if (!lex_tokench(lex, ch)) + return (lex->tok->ttype = TOKEN_FATAL); + if (!lex_finish_ident(lex)) { + /* error? */ + return (lex->tok->ttype = TOKEN_ERROR); + } + if (!lex_endtoken(lex)) + return (lex->tok->ttype = TOKEN_FATAL); + lex->tok->ttype = TOKEN_IDENT; + + v = lex->tok->value; + if (!strcmp(v, "void")) { + lex->tok->ttype = TOKEN_TYPENAME; + lex->tok->constval.t = TYPE_VOID; + } else if (!strcmp(v, "int")) { + lex->tok->ttype = TOKEN_TYPENAME; + lex->tok->constval.t = TYPE_INTEGER; + } else if (!strcmp(v, "float")) { + lex->tok->ttype = TOKEN_TYPENAME; + lex->tok->constval.t = TYPE_FLOAT; + } else if (!strcmp(v, "string")) { + lex->tok->ttype = TOKEN_TYPENAME; + lex->tok->constval.t = TYPE_STRING; + } else if (!strcmp(v, "entity")) { + lex->tok->ttype = TOKEN_TYPENAME; + lex->tok->constval.t = TYPE_ENTITY; + } else if (!strcmp(v, "vector")) { + lex->tok->ttype = TOKEN_TYPENAME; + lex->tok->constval.t = TYPE_VECTOR; + } else if (!strcmp(v, "for") || + !strcmp(v, "while") || + !strcmp(v, "do") || + !strcmp(v, "if") || + !strcmp(v, "else") || + !strcmp(v, "local") || + !strcmp(v, "return") || + !strcmp(v, "const")) + lex->tok->ttype = TOKEN_KEYWORD; + + return lex->tok->ttype; + } + + if (ch == '"') + { + lex->tok->ttype = lex_finish_string(lex, '"'); + while (lex->tok->ttype == TOKEN_STRINGCONST) + { + /* Allow c style "string" "continuation" */ + ch = lex_skipwhite(lex); + if (ch != '"') { + lex_ungetch(lex, ch); + break; + } + + lex->tok->ttype = lex_finish_string(lex, '"'); + } + if (!lex_endtoken(lex)) + return (lex->tok->ttype = TOKEN_FATAL); + return lex->tok->ttype; + } + + if (ch == '\'') + { + /* we parse character constants like string, + * but return TOKEN_CHARCONST, or a vector type if it fits... + * Likewise actual unescaping has to be done by the parser. + * The difference is we don't allow 'char' 'continuation'. + */ + lex->tok->ttype = lex_finish_string(lex, '\''); + if (!lex_endtoken(lex)) + return (lex->tok->ttype = TOKEN_FATAL); + + /* It's a vector if we can successfully scan 3 floats */ #ifdef WIN32 - if (sscanf_s(lex->tok->value, " %f %f %f ", - &lex->tok->constval.v.x, &lex->tok->constval.v.y, &lex->tok->constval.v.z) == 3) + if (sscanf_s(lex->tok->value, " %f %f %f ", + &lex->tok->constval.v.x, &lex->tok->constval.v.y, &lex->tok->constval.v.z) == 3) #else - if (sscanf(lex->tok->value, " %f %f %f ", - &lex->tok->constval.v.x, &lex->tok->constval.v.y, &lex->tok->constval.v.z) == 3) + if (sscanf(lex->tok->value, " %f %f %f ", + &lex->tok->constval.v.x, &lex->tok->constval.v.y, &lex->tok->constval.v.z) == 3) #endif - { - lex->tok->ttype = TOKEN_VECTORCONST; - } - - return lex->tok->ttype; - } - - if (isdigit(ch)) - { - lex->tok->ttype = lex_finish_digit(lex, ch); - if (!lex_endtoken(lex)) - return (lex->tok->ttype = TOKEN_FATAL); - return lex->tok->ttype; - } - - lexerror(lex, "unknown token"); - return (lex->tok->ttype = TOKEN_ERROR); + { + lex->tok->ttype = TOKEN_VECTORCONST; + } + + return lex->tok->ttype; + } + + if (isdigit(ch)) + { + lex->tok->ttype = lex_finish_digit(lex, ch); + if (!lex_endtoken(lex)) + return (lex->tok->ttype = TOKEN_FATAL); + return lex->tok->ttype; + } + + lexerror(lex, "unknown token"); + return (lex->tok->ttype = TOKEN_ERROR); }