| /* | |
| * input.c - Process input files for "treecc". | |
| * | |
| * Copyright (C) 2001 Southern Storm Software, Pty Ltd. | |
| * | |
| * This program is free software; you can redistribute it and/or modify | |
| * it under the terms of the GNU General Public License as published by | |
| * the Free Software Foundation; either version 2 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * This program is distributed in the hope that it will be useful, | |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| * GNU General Public License for more details. | |
| * | |
| * You should have received a copy of the GNU General Public License | |
| * along with this program; if not, write to the Free Software | |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
| */ | |
| #include "system.h" | |
| #include "input.h" | |
| #include "errors.h" | |
| #ifdef __cplusplus | |
| extern "C" { | |
| #endif | |
| void TreeCCOpen(TreeCCInput *input, char *progname, | |
| FILE *stream, char *filename) | |
| { | |
| input->token = TREECC_TOKEN_IDENTIFIER; | |
| input->text = 0; | |
| input->progname = progname; | |
| input->stream = stream; | |
| input->filename = filename; | |
| input->linenum = 1; | |
| input->nextline = 1; | |
| input->errors = 0; | |
| input->sawEOF = 0; | |
| input->parseLiteral = 1; | |
| input->readOnly = 0; | |
| } | |
| void TreeCCClose(TreeCCInput *input, int closeRaw) | |
| { | |
| if(input->text && input->text != input->buffer) | |
| { | |
| free(input->text); | |
| } | |
| if(closeRaw) | |
| { | |
| fclose(input->stream); | |
| } | |
| } | |
| /* | |
| * Determine if the next character looks like part of an identifier. | |
| */ | |
| #define IS_START_IDENT(ch) (((ch) >= 'A' && (ch) <= 'Z') || \ | |
| ((ch) >= 'a' && (ch) <= 'z') || \ | |
| (ch) == '_') | |
| #define IS_IDENT(ch) (((ch) >= 'A' && (ch) <= 'Z') || \ | |
| ((ch) >= 'a' && (ch) <= 'z') || \ | |
| ((ch) >= '0' && (ch) <= '9') || \ | |
| (ch) == '_') | |
| /* | |
| * Report an invalid character error. | |
| */ | |
| static void InvalidChar(TreeCCInput *input, int ch) | |
| { | |
| if(ch >= ' ' && ch <= (char)0x7E) | |
| { | |
| TreeCCError(input, "invalid `%c' character in input", ch); | |
| } | |
| else | |
| { | |
| TreeCCError(input, "invalid `\\x%02X' character in input", ch); | |
| } | |
| } | |
| /* | |
| * Report EOF inside a literal code block. | |
| */ | |
| static void LiteralEOF(TreeCCInput *input) | |
| { | |
| TreeCCError(input, "end of file inside literal code block"); | |
| } | |
| /* | |
| * Recognise an identifier from an input stream. | |
| */ | |
| static void RecogIdentifier(TreeCCInput *input, int ch, const char *name) | |
| { | |
| int len = 0; | |
| int overflow = 0; | |
| for(;;) | |
| { | |
| /* Add the character to the buffer */ | |
| if(len < (TREECC_BUFSIZ - 1)) | |
| { | |
| input->buffer[len++] = ch; | |
| } | |
| else | |
| { | |
| overflow = 1; | |
| } | |
| /* Get the next character */ | |
| ch = getc(input->stream); | |
| if(ch == EOF) | |
| { | |
| input->sawEOF = 1; | |
| break; | |
| } | |
| else if(!IS_IDENT(ch)) | |
| { | |
| ungetc(ch, input->stream); | |
| break; | |
| } | |
| } | |
| if(overflow) | |
| { | |
| TreeCCError(input, "%s is too long", name); | |
| } | |
| input->buffer[len] = '\0'; | |
| input->text = input->buffer; | |
| } | |
| /* | |
| * Flush a buffer of data to "input->text". | |
| */ | |
| static int FlushBuffer(TreeCCInput *input, int len, int currlen) | |
| { | |
| char *newText; | |
| /* Ignore the request if "len" is zero */ | |
| if(!len) | |
| { | |
| return currlen; | |
| } | |
| /* Reallocate the text buffer to the new length */ | |
| if((newText = (char *)realloc(input->text, currlen + len + 1)) == 0) | |
| { | |
| TreeCCOutOfMemory(input); | |
| } | |
| input->text = newText; | |
| /* Copy the data to the buffer */ | |
| strncpy(newText + currlen, input->buffer, len); | |
| newText[currlen + len] = '\0'; | |
| return currlen + len; | |
| } | |
| /* | |
| * Finalize the text buffer. | |
| */ | |
| static void FinalizeBuffer(TreeCCInput *input, int len, int currlen) | |
| { | |
| if(currlen != 0) | |
| { | |
| FlushBuffer(input, len, currlen); | |
| } | |
| else | |
| { | |
| input->buffer[len] = '\0'; | |
| input->text = input->buffer; | |
| } | |
| } | |
| /* | |
| * Recognise a literal code definition section. | |
| */ | |
| static void LiteralCodeDefn(TreeCCInput *input, int tillEnd) | |
| { | |
| int len = 0; | |
| int currlen = 0; | |
| int ch; | |
| /* Read characters until EOF or "%}" */ | |
| for(;;) | |
| { | |
| ch = getc(input->stream); | |
| if(ch == EOF) | |
| { | |
| input->sawEOF = 1; | |
| if(!tillEnd) | |
| { | |
| LiteralEOF(input); | |
| } | |
| break; | |
| } | |
| else if(ch == '%' && !tillEnd) | |
| { | |
| /* Check for the "%}" terminating sequence */ | |
| ch = getc(input->stream); | |
| if(ch == '}') | |
| { | |
| break; | |
| } | |
| else if(ch == EOF) | |
| { | |
| input->buffer[len++] = '%'; | |
| input->sawEOF = 1; | |
| LiteralEOF(input); | |
| break; | |
| } | |
| else | |
| { | |
| ungetc(ch, input->stream); | |
| input->buffer[len++] = '%'; | |
| if(len >= (TREECC_BUFSIZ - 1)) | |
| { | |
| currlen = FlushBuffer(input, len, currlen); | |
| len = 0; | |
| } | |
| } | |
| } | |
| else | |
| { | |
| if(ch == '\n') | |
| { | |
| /* Unix-style end of line sequence */ | |
| ++(input->nextline); | |
| input->buffer[len++] = '\n'; | |
| } | |
| else if(ch == '\r') | |
| { | |
| /* MS-DOS or Mac-style end of line sequence */ | |
| ++(input->nextline); | |
| input->buffer[len++] = '\n'; | |
| ch = getc(input->stream); | |
| if(ch == EOF) | |
| { | |
| input->sawEOF = 1; | |
| if(!tillEnd) | |
| { | |
| LiteralEOF(input); | |
| } | |
| break; | |
| } | |
| else if(ch != '\n') | |
| { | |
| ungetc(ch, input->stream); | |
| } | |
| } | |
| else if(ch == '\0') | |
| { | |
| /* Strip out embedded NUL's */ | |
| InvalidChar(input, ch); | |
| } | |
| else | |
| { | |
| /* Ordinary character */ | |
| input->buffer[len++] = (char)ch; | |
| } | |
| if(len >= (TREECC_BUFSIZ - 1)) | |
| { | |
| currlen = FlushBuffer(input, len, currlen); | |
| len = 0; | |
| } | |
| } | |
| } | |
| /* Finalize the text return buffer */ | |
| FinalizeBuffer(input, len, currlen); | |
| } | |
| /* | |
| * Recognise a literal code section. This version is a little | |
| * harder because we need to find a matching '}', while handling | |
| * C-style and C++-style comments and strings. | |
| */ | |
| static void LiteralCode(TreeCCInput *input) | |
| { | |
| unsigned long level = 0; | |
| int len = 0; | |
| int currlen = 0; | |
| int ch, quotech; | |
| /* Parse input until the next matching '}' */ | |
| for(;;) | |
| { | |
| ch = getc(input->stream); | |
| if(ch == EOF) | |
| { | |
| /* Premate end of file within the code block */ | |
| input->sawEOF = 1; | |
| LiteralEOF(input); | |
| break; | |
| } | |
| else if(ch == '}') | |
| { | |
| /* Go out one code level */ | |
| if(level == 0) | |
| { | |
| break; | |
| } | |
| --level; | |
| input->buffer[len++] = '}'; | |
| } | |
| else if(ch == '{') | |
| { | |
| /* Go in one code level */ | |
| ++level; | |
| input->buffer[len++] = '{'; | |
| } | |
| else if(ch == '"' || ch == '\'') | |
| { | |
| /* Skip to the end of this string */ | |
| quotech = ch; | |
| input->buffer[len++] = (char)ch; | |
| if(len >= (TREECC_BUFSIZ - 1)) | |
| { | |
| currlen = FlushBuffer(input, len, currlen); | |
| len = 0; | |
| } | |
| while((ch = getc(input->stream)) != EOF && ch != quotech) | |
| { | |
| if(ch == '\\') | |
| { | |
| input->buffer[len++] = (char)ch; | |
| if(len >= (TREECC_BUFSIZ - 1)) | |
| { | |
| currlen = FlushBuffer(input, len, currlen); | |
| len = 0; | |
| } | |
| ch = getc(input->stream); | |
| if(ch == EOF) | |
| { | |
| break; | |
| } | |
| } | |
| if(ch == '\n' || ch == '\r') | |
| { | |
| TreeCCError(input, "end of line inside string"); | |
| ungetc(ch, input->stream); | |
| break; | |
| } | |
| input->buffer[len++] = (char)ch; | |
| if(len >= (TREECC_BUFSIZ - 1)) | |
| { | |
| currlen = FlushBuffer(input, len, currlen); | |
| len = 0; | |
| } | |
| } | |
| if(ch == EOF) | |
| { | |
| input->sawEOF = 1; | |
| TreeCCError(input, "end of file inside string"); | |
| break; | |
| } | |
| else | |
| { | |
| input->buffer[len++] = (char)quotech; | |
| } | |
| } | |
| else if(ch == '/') | |
| { | |
| /* May be the start of a comment */ | |
| input->buffer[len++] = '/'; | |
| if(len >= (TREECC_BUFSIZ - 1)) | |
| { | |
| currlen = FlushBuffer(input, len, currlen); | |
| len = 0; | |
| } | |
| ch = getc(input->stream); | |
| if(ch == EOF) | |
| { | |
| /* EOF in the middle of a code block */ | |
| input->sawEOF = 1; | |
| LiteralEOF(input); | |
| break; | |
| } | |
| else if(ch == '/') | |
| { | |
| /* Single-line comment */ | |
| input->buffer[len++] = '/'; | |
| if(len >= (TREECC_BUFSIZ - 1)) | |
| { | |
| currlen = FlushBuffer(input, len, currlen); | |
| len = 0; | |
| } | |
| while((ch = getc(input->stream)) != '\n' && | |
| ch != '\r' && ch != EOF) | |
| { | |
| if(ch != '\0') | |
| { | |
| input->buffer[len++] = (char)ch; | |
| if(len >= (TREECC_BUFSIZ - 1)) | |
| { | |
| currlen = FlushBuffer(input, len, currlen); | |
| len = 0; | |
| } | |
| } | |
| else | |
| { | |
| InvalidChar(input, ch); | |
| } | |
| } | |
| if(ch == EOF) | |
| { | |
| input->sawEOF = 1; | |
| LiteralEOF(input); | |
| break; | |
| } | |
| ungetc(ch, input->stream); | |
| } | |
| else if(ch == '*') | |
| { | |
| /* Multi-line comment */ | |
| input->buffer[len++] = '*'; | |
| if(len >= (TREECC_BUFSIZ - 1)) | |
| { | |
| currlen = FlushBuffer(input, len, currlen); | |
| len = 0; | |
| } | |
| for(;;) | |
| { | |
| ch = getc(input->stream); | |
| if(ch == EOF) | |
| { | |
| /* EOF encountered in a comment */ | |
| input->sawEOF = 1; | |
| LiteralEOF(input); | |
| goto finalize; | |
| } | |
| else if(ch == '*') | |
| { | |
| /* Check for the end of the comment */ | |
| input->buffer[len++] = '*'; | |
| if(len >= (TREECC_BUFSIZ - 1)) | |
| { | |
| currlen = FlushBuffer(input, len, currlen); | |
| len = 0; | |
| } | |
| ch = getc(input->stream); | |
| if(ch == '/') | |
| { | |
| input->buffer[len++] = '/'; | |
| break; | |
| } | |
| else if(ch == EOF) | |
| { | |
| input->sawEOF = 1; | |
| LiteralEOF(input); | |
| goto finalize; | |
| } | |
| else | |
| { | |
| ungetc(ch, input->stream); | |
| continue; | |
| } | |
| } | |
| else if(ch == '\n') | |
| { | |
| /* Unix-style end of line in a comment */ | |
| ++(input->nextline); | |
| } | |
| else if(ch == '\r') | |
| { | |
| /* MS-DOS or Mac-style end of line in a comment */ | |
| ++(input->nextline); | |
| ch = getc(input->stream); | |
| if(ch == EOF) | |
| { | |
| input->buffer[len++] = '\n'; | |
| input->sawEOF = 1; | |
| LiteralEOF(input); | |
| goto finalize; | |
| } | |
| else if(ch != '\n') | |
| { | |
| ungetc(ch, input->stream); | |
| } | |
| ch = '\n'; | |
| } | |
| input->buffer[len++] = (char)ch; | |
| if(len >= (TREECC_BUFSIZ - 1)) | |
| { | |
| currlen = FlushBuffer(input, len, currlen); | |
| len = 0; | |
| } | |
| } | |
| } | |
| else | |
| { | |
| /* Simple '/' character */ | |
| ungetc(ch, input->stream); | |
| } | |
| } | |
| else if(ch == '\n') | |
| { | |
| /* Unix-like end of line sequence */ | |
| ++(input->nextline); | |
| input->buffer[len++] = '\n'; | |
| } | |
| else if(ch == '\r') | |
| { | |
| /* MS-DOS or Mac-like end of line sequence */ | |
| ++(input->nextline); | |
| input->buffer[len++] = '\n'; | |
| ch = getc(input->stream); | |
| if(ch == EOF) | |
| { | |
| input->sawEOF = 1; | |
| LiteralEOF(input); | |
| break; | |
| } | |
| else if(ch != '\n') | |
| { | |
| ungetc(ch, input->stream); | |
| } | |
| } | |
| else if(ch == '\0') | |
| { | |
| /* NUL characters are invalid in literal code blocks */ | |
| InvalidChar(input, ch); | |
| } | |
| else | |
| { | |
| /* Normal character */ | |
| input->buffer[len++] = (char)ch; | |
| } | |
| if(len >= (TREECC_BUFSIZ - 1)) | |
| { | |
| currlen = FlushBuffer(input, len, currlen); | |
| len = 0; | |
| } | |
| } | |
| /* Finalize the text return buffer */ | |
| finalize: | |
| FinalizeBuffer(input, len, currlen); | |
| } | |
| /* | |
| * Recognise a string from an input file. Escape sequences | |
| * are not supported in this type of string. | |
| */ | |
| static void RecogString(TreeCCInput *input, int quotech) | |
| { | |
| int len = 0; | |
| int currlen = 0; | |
| int ch; | |
| /* Parse the contents of the string */ | |
| for(;;) | |
| { | |
| ch = getc(input->stream); | |
| if(ch == quotech) | |
| { | |
| /* Terminating quote for the string */ | |
| break; | |
| } | |
| else if(ch == EOF) | |
| { | |
| /* EOF embedded in the string */ | |
| input->sawEOF = 1; | |
| TreeCCError(input, "end of file inside string"); | |
| break; | |
| } | |
| else if(ch == '\n' || ch == '\r') | |
| { | |
| /* End of line embedding in the string */ | |
| ungetc(ch, input->stream); | |
| TreeCCError(input, "end of line inside string"); | |
| break; | |
| } | |
| else if(ch == '\0') | |
| { | |
| /* NUL characters are invalid inside a string */ | |
| InvalidChar(input, ch); | |
| } | |
| else | |
| { | |
| /* Ordinary character */ | |
| input->buffer[len++] = (char)ch; | |
| if(len >= (TREECC_BUFSIZ - 1)) | |
| { | |
| currlen = FlushBuffer(input, len, currlen); | |
| len = 0; | |
| } | |
| } | |
| } | |
| /* Finalize the text return buffer */ | |
| FinalizeBuffer(input, len, currlen); | |
| } | |
| /* | |
| * Keyword table. Must be sorted into ascending order. | |
| */ | |
| static struct | |
| { | |
| const char *keyword; | |
| TreeCCToken token; | |
| } const KeywordTable[] = { | |
| {"abstract", TREECC_TOKEN_ABSTRACT}, | |
| {"both", TREECC_TOKEN_BOTH}, | |
| {"common", TREECC_TOKEN_COMMON}, | |
| {"decls", TREECC_TOKEN_DECLS}, | |
| {"end", TREECC_TOKEN_END}, | |
| {"enum", TREECC_TOKEN_ENUM}, | |
| {"header", TREECC_TOKEN_HEADER}, | |
| {"include", TREECC_TOKEN_INCLUDE}, | |
| {"inline", TREECC_TOKEN_INLINE}, | |
| {"nocreate", TREECC_TOKEN_NOCREATE}, | |
| {"node", TREECC_TOKEN_NODE}, | |
| {"operation", TREECC_TOKEN_OPERATION}, | |
| {"option", TREECC_TOKEN_OPTION}, | |
| {"outdir", TREECC_TOKEN_OUTDIR}, | |
| {"output", TREECC_TOKEN_OUTPUT}, | |
| {"readonly", TREECC_TOKEN_READONLY}, | |
| {"split", TREECC_TOKEN_SPLIT}, | |
| {"typedef", TREECC_TOKEN_TYPEDEF}, | |
| {"virtual", TREECC_TOKEN_VIRTUAL}, | |
| }; | |
| #define KeywordTableSize (sizeof(KeywordTable) / sizeof(KeywordTable[0])) | |
| int TreeCCNextToken(TreeCCInput *input) | |
| { | |
| int ch; | |
| int low, middle, high; | |
| /* If we have seen EOF already, then bail out now */ | |
| if(input->sawEOF) | |
| { | |
| input->linenum = input->nextline; | |
| input->token = TREECC_TOKEN_EOF; | |
| return 0; | |
| } | |
| /* Free the text input buffer used by the previous token */ | |
| if(input->text && input->text != input->buffer) | |
| { | |
| free(input->text); | |
| } | |
| input->text = 0; | |
| /* Determine what kind of token we have from the next character */ | |
| for(;;) | |
| { | |
| input->linenum = input->nextline; | |
| ch = getc(input->stream); | |
| if(ch == EOF) | |
| { | |
| break; | |
| } | |
| else if(ch == '%') | |
| { | |
| ch = getc(input->stream); | |
| if(ch == '{') | |
| { | |
| /* Start of a literal code definition section that | |
| extends until the next occurrence of "%}" */ | |
| LiteralCodeDefn(input, 0); | |
| input->token = TREECC_TOKEN_LITERAL_DEFNS; | |
| return 1; | |
| } | |
| else if(ch == '%') | |
| { | |
| /* Start of a literal code definition section that | |
| extends until the end of the file */ | |
| LiteralCodeDefn(input, 1); | |
| input->token = TREECC_TOKEN_LITERAL_END; | |
| return 1; | |
| } | |
| else if(IS_START_IDENT(ch)) | |
| { | |
| /* Start of a keyword */ | |
| RecogIdentifier(input, ch, "keyword"); | |
| low = 0; | |
| high = KeywordTableSize - 1; | |
| while(low <= high) | |
| { | |
| middle = ((low + high) / 2); | |
| ch = strcmp(input->text, KeywordTable[middle].keyword); | |
| if(!ch) | |
| { | |
| input->token = KeywordTable[middle].token; | |
| return 1; | |
| } | |
| else if(ch < 0) | |
| { | |
| high = middle - 1; | |
| } | |
| else | |
| { | |
| low = middle + 1; | |
| } | |
| } | |
| TreeCCError(input, "unknown keyword `%%%s'", input->text); | |
| input->token = TREECC_TOKEN_UNKNOWN; | |
| return 1; | |
| } | |
| else | |
| { | |
| TreeCCError(input, | |
| "`%%' must be followed by a keyword, `{', or `%%'"); | |
| if(ch == EOF) | |
| { | |
| break; | |
| } | |
| else | |
| { | |
| ungetc(ch, input->stream); | |
| } | |
| } | |
| } | |
| else if(IS_START_IDENT(ch)) | |
| { | |
| /* Start of an identifier */ | |
| RecogIdentifier(input, ch, "identifier"); | |
| input->token = TREECC_TOKEN_IDENTIFIER; | |
| return 1; | |
| } | |
| else if(ch == '(') | |
| { | |
| input->token = TREECC_TOKEN_LPAREN; | |
| return 1; | |
| } | |
| else if(ch == ')') | |
| { | |
| input->token = TREECC_TOKEN_RPAREN; | |
| return 1; | |
| } | |
| else if(ch == '}') | |
| { | |
| input->token = TREECC_TOKEN_RBRACE; | |
| return 1; | |
| } | |
| else if(ch == '[') | |
| { | |
| input->token = TREECC_TOKEN_LSQUARE; | |
| return 1; | |
| } | |
| else if(ch == ']') | |
| { | |
| input->token = TREECC_TOKEN_RSQUARE; | |
| return 1; | |
| } | |
| else if(ch == ',') | |
| { | |
| input->token = TREECC_TOKEN_COMMA; | |
| return 1; | |
| } | |
| else if(ch == '=') | |
| { | |
| input->token = TREECC_TOKEN_EQUALS; | |
| return 1; | |
| } | |
| else if(ch == '*') | |
| { | |
| input->token = TREECC_TOKEN_STAR; | |
| return 1; | |
| } | |
| else if(ch == '&') | |
| { | |
| input->token = TREECC_TOKEN_REF; | |
| return 1; | |
| } | |
| else if(ch == ';') | |
| { | |
| input->token = TREECC_TOKEN_SEMI; | |
| return 1; | |
| } | |
| else if(ch == ':') | |
| { | |
| ch = getc(input->stream); | |
| if(ch == ':') | |
| { | |
| input->token = TREECC_TOKEN_COLON_COLON; | |
| return 1; | |
| } | |
| else if(ch == EOF) | |
| { | |
| InvalidChar(input, ':'); | |
| input->sawEOF = 1; | |
| input->linenum = input->nextline; | |
| input->token = TREECC_TOKEN_EOF; | |
| return 0; | |
| } | |
| else | |
| { | |
| ungetc(ch, input->stream); | |
| InvalidChar(input, ':'); | |
| } | |
| } | |
| else if(ch == '"' || ch == '\'') | |
| { | |
| RecogString(input, ch); | |
| input->token = TREECC_TOKEN_STRING; | |
| return 1; | |
| } | |
| else if(ch == '\n') | |
| { | |
| /* Unix-like end of line sequence */ | |
| ++(input->nextline); | |
| } | |
| else if(ch == '\r') | |
| { | |
| /* MS-DOS or Mac-like end of line sequence */ | |
| ch = getc(input->stream); | |
| if(ch == EOF) | |
| { | |
| input->sawEOF = 1; | |
| } | |
| else if(ch != '\n') | |
| { | |
| ungetc(ch, input->stream); | |
| } | |
| ++(input->nextline); | |
| } | |
| else if(ch == '{') | |
| { | |
| if(input->parseLiteral) | |
| { | |
| /* Start of a literal code block */ | |
| LiteralCode(input); | |
| input->token = TREECC_TOKEN_LITERAL_CODE; | |
| return 1; | |
| } | |
| else | |
| { | |
| /* Probably a field definition block */ | |
| input->token = TREECC_TOKEN_LBRACE; | |
| return 1; | |
| } | |
| } | |
| else if(ch == ' ' || ch == '\t' || ch == '\f' || ch == '\v') | |
| { | |
| /* Ignore white space on the current line */ | |
| } | |
| else if(ch == '/') | |
| { | |
| /* May be the start of a comment */ | |
| ch = getc(input->stream); | |
| if(ch == '*') | |
| { | |
| /* Multi-line comment */ | |
| for(;;) | |
| { | |
| ch = getc(input->stream); | |
| if(ch == EOF) | |
| { | |
| eofInComment: | |
| TreeCCError(input, "end of file inside comment"); | |
| input->sawEOF = 1; | |
| input->linenum = input->nextline; | |
| input->token = TREECC_TOKEN_EOF; | |
| return 0; | |
| } | |
| else if(ch == '*') | |
| { | |
| for(;;) | |
| { | |
| ch = getc(input->stream); | |
| if(ch == EOF) | |
| { | |
| goto eofInComment; | |
| } | |
| else if(ch == '/') | |
| { | |
| goto endComment; | |
| } | |
| else if(ch != '*') | |
| { | |
| ungetc(ch, input->stream); | |
| break; | |
| } | |
| } | |
| } | |
| else if(ch == '\n') | |
| { | |
| ++(input->nextline); | |
| } | |
| else if(ch == '\r') | |
| { | |
| ++(input->nextline); | |
| ch = getc(input->stream); | |
| if(ch == EOF) | |
| { | |
| goto eofInComment; | |
| } | |
| else if(ch != '\n') | |
| { | |
| ungetc(ch, input->stream); | |
| } | |
| } | |
| } | |
| endComment: ; | |
| } | |
| else if(ch == '/') | |
| { | |
| /* Single-line comment */ | |
| for(;;) | |
| { | |
| ch = getc(input->stream); | |
| if(ch == EOF) | |
| { | |
| input->sawEOF = 1; | |
| input->linenum = input->nextline; | |
| input->token = TREECC_TOKEN_EOF; | |
| return 0; | |
| } | |
| else if(ch == '\n') | |
| { | |
| break; | |
| } | |
| else if(ch == '\r') | |
| { | |
| ch = getc(input->stream); | |
| if(ch == EOF) | |
| { | |
| input->sawEOF = 1; | |
| } | |
| else if(ch != '\n') | |
| { | |
| ungetc(ch, input->stream); | |
| } | |
| break; | |
| } | |
| } | |
| ++(input->nextline); | |
| } | |
| else | |
| { | |
| /* Invalid comment sequence */ | |
| InvalidChar(input, '/'); | |
| if(ch == EOF) | |
| { | |
| break; | |
| } | |
| else | |
| { | |
| ungetc(ch, input->stream); | |
| } | |
| } | |
| } | |
| else | |
| { | |
| /* Invalid character in the input stream */ | |
| InvalidChar(input, ch); | |
| } | |
| } | |
| /* If we get here, then we have reached EOF */ | |
| input->linenum = input->nextline; | |
| input->token = TREECC_TOKEN_EOF; | |
| input->sawEOF = 1; | |
| return 0; | |
| } | |
| char *TreeCCValue(TreeCCInput *input) | |
| { | |
| char *result; | |
| if(!(input->text)) | |
| { | |
| /* We don't have a text version of this token */ | |
| TreeCCAbort(input, "no text for token type %d", input->token); | |
| return 0; | |
| } | |
| else if(input->text != input->buffer) | |
| { | |
| /* The text is already malloc'ed, so return that */ | |
| result = input->text; | |
| input->text = 0; | |
| return result; | |
| } | |
| else | |
| { | |
| /* Copy the text into a malloc'ed buffer */ | |
| result = (char *)malloc(strlen(input->buffer) + 1); | |
| if(!result) | |
| { | |
| TreeCCOutOfMemory(input); | |
| } | |
| strcpy(result, input->buffer); | |
| input->text = 0; | |
| return result; | |
| } | |
| } | |
| #ifdef __cplusplus | |
| }; | |
| #endif |