| /* | |
| * stream.c - Stream handling for writing source code. | |
| * | |
| * 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 "info.h" | |
| #include "errors.h" | |
| #ifdef __cplusplus | |
| extern "C" { | |
| #endif | |
| char *TreeCCDupString(char *str) | |
| { | |
| char *newstr = (char *)malloc(strlen(str) + 1); | |
| if(!newstr) | |
| { | |
| TreeCCOutOfMemory(0); | |
| } | |
| strcpy(newstr, str); | |
| return newstr; | |
| } | |
| char *TreeCCResolvePathname(char *absolute, char *relative) | |
| { | |
| int len; | |
| char *path; | |
| if(!absolute) | |
| { | |
| return TreeCCDupString(relative); | |
| } | |
| len = strlen(absolute); | |
| while(len > 0 && absolute[len - 1] != '/' && absolute[len - 1] != '\\') | |
| { | |
| --len; | |
| } | |
| if(len <= 0) | |
| { | |
| return TreeCCDupString(relative); | |
| } | |
| path = (char *)malloc(len + strlen(relative) + 1); | |
| if(!path) | |
| { | |
| TreeCCOutOfMemory(0); | |
| } | |
| strncpy(path, absolute, len); | |
| strcpy(path + len, relative); | |
| return path; | |
| } | |
| TreeCCStream *TreeCCStreamCreate(PTreeCCContext context, | |
| char *filename, char *embedName, | |
| int isHeader) | |
| { | |
| TreeCCStream *stream; | |
| char *path; | |
| /* Resolve the filename into a path */ | |
| if(isHeader < 0) | |
| { | |
| /* Already resolved by TreeCCStreamGetJava */ | |
| isHeader = 0; | |
| path = TreeCCDupString(filename); | |
| } | |
| else | |
| { | |
| path = TreeCCResolvePathname(context->input->filename, filename); | |
| } | |
| /* Search for an existing stream for the file */ | |
| stream = context->streamList; | |
| while(stream != 0) | |
| { | |
| if(!strcmp(stream->filename, path)) | |
| { | |
| free(path); | |
| return stream; | |
| } | |
| stream = stream->nextStream; | |
| } | |
| /* Create a new stream */ | |
| stream = (TreeCCStream *)malloc(sizeof(TreeCCStream)); | |
| if(!stream) | |
| { | |
| TreeCCOutOfMemory(0); | |
| } | |
| stream->context = context; | |
| stream->filename = path; | |
| stream->embedName = (embedName ? TreeCCDupString(embedName) : | |
| TreeCCDupString(filename)); | |
| stream->linenum = 1; | |
| stream->firstBuf = 0; | |
| stream->lastBuf = 0; | |
| stream->posn = TREECC_STREAM_BUFSIZ; | |
| stream->forceCreate = context->force; | |
| stream->readOnly = 0; | |
| stream->isHeader = isHeader; | |
| stream->defaultFile = 0; | |
| stream->dirty = 0; | |
| stream->firstDefn = 0; | |
| stream->lastDefn = 0; | |
| stream->nextStream = context->streamList; | |
| context->streamList = stream; | |
| return stream; | |
| } | |
| TreeCCStream *TreeCCStreamGetJava(PTreeCCContext context, char *className) | |
| { | |
| char *filename; | |
| int len; | |
| TreeCCStream *stream; | |
| if(context->outputDirectory) | |
| { | |
| len = strlen(context->outputDirectory) + strlen(className) + 7; | |
| if((filename = (char *)malloc(len)) == 0) | |
| { | |
| TreeCCOutOfMemory(context->input); | |
| } | |
| strcpy(filename, context->outputDirectory); | |
| len = strlen(context->outputDirectory); | |
| filename[len] = '/'; | |
| strcpy(filename + len + 1, className); | |
| strcat(filename, ".java"); | |
| ++len; | |
| } | |
| else | |
| { | |
| len = strlen(className) + 6; | |
| if((filename = (char *)malloc(len)) == 0) | |
| { | |
| TreeCCOutOfMemory(context->input); | |
| } | |
| strcpy(filename, className); | |
| strcat(filename, ".java"); | |
| len = 0; | |
| } | |
| stream = TreeCCStreamCreate(context, filename, filename + len, -1); | |
| free(filename); | |
| return stream; | |
| } | |
| void TreeCCStreamDestroy(TreeCCStream *stream) | |
| { | |
| TreeCCStreamDefn *defn, *nextDefn; | |
| /* Free the data buffers for the stream */ | |
| TreeCCStreamClear(stream); | |
| /* Free the definition list for the stream */ | |
| defn = stream->firstDefn; | |
| while(defn != 0) | |
| { | |
| nextDefn = defn->next; | |
| if(!(defn->refOnly)) | |
| { | |
| free(defn->code); | |
| } | |
| free(defn); | |
| defn = nextDefn; | |
| } | |
| /* Free the filenames */ | |
| free(stream->filename); | |
| free(stream->embedName); | |
| /* Free the stream itself */ | |
| free(stream); | |
| } | |
| void TreeCCStreamClear(TreeCCStream *stream) | |
| { | |
| TreeCCStreamBuf *buffer, *nextBuffer; | |
| buffer = stream->firstBuf; | |
| while(buffer != 0) | |
| { | |
| nextBuffer = buffer->next; | |
| free(buffer); | |
| buffer = nextBuffer; | |
| } | |
| stream->firstBuf = 0; | |
| stream->lastBuf = 0; | |
| stream->dirty = 0; | |
| stream->posn = TREECC_STREAM_BUFSIZ; | |
| stream->linenum = 1; | |
| } | |
| /* | |
| * Define the "MemCmp" function. | |
| */ | |
| #if HAVE_MEMCMP | |
| #define MemCmp(s1,s2,size) (memcmp((s1),(s2),(size))) | |
| #else | |
| static int MemCmp(const char *s1, const char *s2, int size) | |
| { | |
| while(size > 0) | |
| { | |
| if(*s1 < *s2) | |
| { | |
| return -1; | |
| } | |
| else if(*s1 > *s2) | |
| { | |
| return 1; | |
| } | |
| ++s1; | |
| ++s2; | |
| --size; | |
| } | |
| return 0; | |
| } | |
| #endif | |
| int TreeCCStreamFlush(TreeCCStream *stream) | |
| { | |
| int result; | |
| FILE *file; | |
| TreeCCStreamBuf *buffer; | |
| char tempbuf[TREECC_STREAM_BUFSIZ]; | |
| int size, changed; | |
| /* Ignore default streams with no contents */ | |
| if(stream->defaultFile && !(stream->firstBuf)) | |
| { | |
| return 1; | |
| } | |
| /* Validate that the contents have changed non-trivially */ | |
| if(!(stream->forceCreate) || stream->readOnly) | |
| { | |
| if((file = fopen(stream->filename, "r")) != NULL) | |
| { | |
| buffer = stream->firstBuf; | |
| changed = 0; | |
| while((size = fread(tempbuf, 1, TREECC_STREAM_BUFSIZ, file)) != 0) | |
| { | |
| if(!buffer) | |
| { | |
| changed = 1; | |
| break; | |
| } | |
| if(buffer == stream->lastBuf) | |
| { | |
| if(stream->posn != size) | |
| { | |
| changed = 1; | |
| break; | |
| } | |
| if(MemCmp(buffer->data, tempbuf, size) != 0) | |
| { | |
| changed = 1; | |
| break; | |
| } | |
| } | |
| else | |
| { | |
| if(size != TREECC_STREAM_BUFSIZ) | |
| { | |
| changed = 1; | |
| break; | |
| } | |
| if(MemCmp(buffer->data, tempbuf, TREECC_STREAM_BUFSIZ) != 0) | |
| { | |
| changed = 1; | |
| break; | |
| } | |
| } | |
| buffer = buffer->next; | |
| if(size < TREECC_STREAM_BUFSIZ) | |
| { | |
| size = 0; | |
| break; | |
| } | |
| } | |
| if(size == 0 && buffer != 0) | |
| { | |
| changed = 1; | |
| } | |
| fclose(file); | |
| if(!changed) | |
| { | |
| return 1; | |
| } | |
| } | |
| if(stream->readOnly) | |
| { | |
| fprintf(stderr, "%s: read-only file has different contents\n", | |
| stream->filename); | |
| return 0; | |
| } | |
| } | |
| /* Open the output file */ | |
| if((file = fopen(stream->filename, "w")) == NULL) | |
| { | |
| perror(stream->filename); | |
| return 0; | |
| } | |
| /* Flush the data to the output file */ | |
| result = TreeCCStreamFlushStdio(stream, file); | |
| /* Close the output file */ | |
| fclose(file); | |
| return result; | |
| } | |
| int TreeCCStreamFlushStdio(TreeCCStream *stream, FILE *file) | |
| { | |
| TreeCCStreamBuf *buffer = stream->firstBuf; | |
| while(buffer != 0) | |
| { | |
| if(buffer == stream->lastBuf) | |
| { | |
| if(fwrite(buffer->data, 1, stream->posn, file) != stream->posn) | |
| { | |
| return 0; | |
| } | |
| } | |
| else | |
| { | |
| if(fwrite(buffer->data, 1, TREECC_STREAM_BUFSIZ, file) != | |
| TREECC_STREAM_BUFSIZ) | |
| { | |
| return 0; | |
| } | |
| } | |
| buffer = buffer->next; | |
| } | |
| return (fflush(file) == 0); | |
| } | |
| /* | |
| * Write the contents of a buffer to a stream. | |
| */ | |
| static void WriteBuffer(TreeCCStream *stream, const char *buf) | |
| { | |
| int len = strlen(buf); | |
| int templen; | |
| TreeCCStreamBuf *buffer; | |
| stream->dirty = 1; | |
| while(len > 0) | |
| { | |
| /* Add another buffer to the stream if necessary */ | |
| if(stream->posn >= TREECC_STREAM_BUFSIZ) | |
| { | |
| buffer = (TreeCCStreamBuf *)malloc(sizeof(TreeCCStreamBuf)); | |
| if(!buffer) | |
| { | |
| TreeCCOutOfMemory(0); | |
| } | |
| buffer->next = 0; | |
| if(stream->lastBuf) | |
| { | |
| stream->lastBuf->next = buffer; | |
| } | |
| else | |
| { | |
| stream->firstBuf = buffer; | |
| } | |
| stream->lastBuf = buffer; | |
| stream->posn = 0; | |
| templen = TREECC_STREAM_BUFSIZ; | |
| } | |
| else | |
| { | |
| buffer = stream->lastBuf; | |
| templen = TREECC_STREAM_BUFSIZ - stream->posn; | |
| } | |
| /* Copy the data to the stream buffer */ | |
| if(templen > len) | |
| { | |
| templen = len; | |
| } | |
| #if HAVE_MEMCPY | |
| memcpy(buffer->data + stream->posn, buf, templen); | |
| #else | |
| { | |
| char *s1 = buffer->data + stream->posn; | |
| const char *s2 = buf; | |
| int size = templen; | |
| while(size > 0) | |
| { | |
| *s1++ = *s2++; | |
| --size; | |
| } | |
| } | |
| #endif | |
| /* Advance to the next part of the buffer to be written */ | |
| buf += templen; | |
| len -= templen; | |
| stream->posn += templen; | |
| } | |
| } | |
| /* | |
| * Update the line number position of a stream. | |
| */ | |
| static void UpdateLineNum(TreeCCStream *stream, const char *buf) | |
| { | |
| #if HAVE_STRCHR | |
| while((buf = strchr(buf, '\n')) != 0) | |
| { | |
| ++buf; | |
| ++(stream->linenum); | |
| } | |
| #else | |
| while(*buf != '\0') | |
| { | |
| if(*buf == '\n') | |
| { | |
| ++(stream->linenum); | |
| } | |
| ++buf; | |
| } | |
| #endif | |
| } | |
| void TreeCCStreamPrint(TreeCCStream *stream, const char *format, ...) | |
| { | |
| char tempbuf[4096]; | |
| /* Print the formatted data to tempbuf */ | |
| VA_START; | |
| #if HAVE_VSNPRINTF | |
| vsnprintf(tempbuf, sizeof(tempbuf), format, VA_GET_LIST); | |
| #elif HAVE__VSNPRINTF | |
| _vsnprintf(tempbuf, sizeof(tempbuf), format, VA_GET_LIST); | |
| #else | |
| vsprintf(tempbuf, format, VA_GET_LIST); | |
| #endif | |
| VA_END; | |
| /* Write the contents of "tempbuf" to the stream */ | |
| WriteBuffer(stream, tempbuf); | |
| /* Count newlines in the buffer to update the line number */ | |
| UpdateLineNum(stream, tempbuf); | |
| } | |
| void TreeCCStreamCode(TreeCCStream *stream, char *code) | |
| { | |
| WriteBuffer(stream, code); | |
| UpdateLineNum(stream, code); | |
| } | |
| /* | |
| * Put a single character to a stream buffer. | |
| */ | |
| static void _StreamPut(int ch, TreeCCStream *stream) | |
| { | |
| char buf[2]; | |
| buf[0] = (char)ch; | |
| buf[1] = '\0'; | |
| WriteBuffer(stream, buf); | |
| } | |
| #define StreamPut(ch,stream) \ | |
| do { \ | |
| if((stream)->posn < TREECC_STREAM_BUFSIZ) \ | |
| { \ | |
| (stream)->lastBuf->data[((stream)->posn)++] = (ch); \ | |
| (stream)->dirty = 1; \ | |
| } \ | |
| else \ | |
| { \ | |
| _StreamPut((ch), (stream)); \ | |
| } \ | |
| } while (0) | |
| void TreeCCStreamCodeIndent(TreeCCStream *stream, char *code, int indent) | |
| { | |
| int temp; | |
| while(*code != '\0') | |
| { | |
| StreamPut(*code, stream); | |
| if(*code == '\n') | |
| { | |
| ++(stream->linenum); | |
| for(temp = 0; temp < indent; ++temp) | |
| { | |
| StreamPut('\t', stream); | |
| } | |
| } | |
| ++code; | |
| } | |
| } | |
| void TreeCCStreamCodeIndentCustom(TreeCCStream *stream, char *code, | |
| char indentchar, int indent) | |
| { | |
| int temp; | |
| while(*code != '\0') | |
| { | |
| StreamPut(*code, stream); | |
| if(*code == '\n') | |
| { | |
| ++(stream->linenum); | |
| for(temp = 0; temp < indent; ++temp) | |
| { | |
| StreamPut(indentchar, stream); | |
| } | |
| } | |
| ++code; | |
| } | |
| } | |
| void TreeCCStreamFixLine(TreeCCStream *stream) | |
| { | |
| TreeCCStreamLine(stream, stream->linenum + 1, stream->embedName); | |
| } | |
| void TreeCCStreamAddLiteral(TreeCCStream *stream, char *code, | |
| char *filename, long linenum, | |
| int atEnd, int refOnly) | |
| { | |
| TreeCCStreamDefn *defn; | |
| /* Bail out if the stream is NULL (can happen in "test_parse" sometimes) */ | |
| if(!stream) | |
| { | |
| return; | |
| } | |
| /* Allocate space for a definition block */ | |
| defn = (TreeCCStreamDefn *)malloc(sizeof(TreeCCStreamDefn)); | |
| if(!defn) | |
| { | |
| TreeCCOutOfMemory(0); | |
| } | |
| /* Initialize the definition block */ | |
| defn->code = code; | |
| defn->filename = filename; | |
| defn->linenum = linenum; | |
| defn->atEnd = atEnd; | |
| defn->refOnly = refOnly; | |
| defn->next = 0; | |
| /* Add the definition block to the stream's definition list */ | |
| if(stream->lastDefn) | |
| { | |
| stream->lastDefn->next = defn; | |
| } | |
| else | |
| { | |
| stream->firstDefn = defn; | |
| } | |
| stream->lastDefn = defn; | |
| } | |
| /* | |
| * Output a macro name that has been generated from a filename. | |
| */ | |
| static void OutputMacroName(TreeCCStream *stream, const char *filename) | |
| { | |
| while(*filename != '\0') | |
| { | |
| if((*filename >= 'A' && *filename <= 'Z') || | |
| (*filename >= 'a' && *filename <= 'z') || | |
| (*filename >= '0' && *filename <= '9')) | |
| { | |
| StreamPut(*filename, stream); | |
| } | |
| else | |
| { | |
| StreamPut('_', stream); | |
| } | |
| ++filename; | |
| } | |
| StreamPut('\n', stream); | |
| ++(stream->linenum); | |
| } | |
| /* | |
| * Output a list of definitions to a header or source stream. | |
| */ | |
| static void OutputDefns(TreeCCStream *stream, int atEnd) | |
| { | |
| TreeCCStreamDefn *defn = stream->firstDefn; | |
| int sawDefn = 0; | |
| while(defn != 0) | |
| { | |
| if(defn->atEnd == atEnd) | |
| { | |
| TreeCCStreamLine(stream, defn->linenum, defn->filename); | |
| WriteBuffer(stream, defn->code); | |
| UpdateLineNum(stream, defn->code); | |
| if(*(defn->code) != '\0' && | |
| defn->code[strlen(defn->code) - 1] != '\n') | |
| { | |
| /* Terminate the final line */ | |
| StreamPut('\n', stream); | |
| ++(stream->linenum); | |
| } | |
| sawDefn = 1; | |
| } | |
| defn = defn->next; | |
| } | |
| if(sawDefn) | |
| { | |
| TreeCCStreamFixLine(stream); | |
| } | |
| } | |
| void TreeCCStreamHeaderTop(TreeCCStream *stream) | |
| { | |
| char *filename = stream->embedName; | |
| TreeCCStreamPrint(stream, | |
| "/* %s. Generated automatically by treecc */\n", filename); | |
| TreeCCStreamPrint(stream, "#ifndef __%s_", stream->context->yy_replacement); | |
| OutputMacroName(stream, filename); | |
| TreeCCStreamPrint(stream, "#define __%s_", stream->context->yy_replacement); | |
| OutputMacroName(stream, filename); | |
| OutputDefns(stream, 0); | |
| } | |
| void TreeCCStreamHeaderBottom(TreeCCStream *stream) | |
| { | |
| OutputDefns(stream, 1); | |
| TreeCCStreamPrint(stream, "#endif\n"); | |
| } | |
| void TreeCCStreamSourceTop(TreeCCStream *stream) | |
| { | |
| TreeCCStreamPrint(stream, "/* %s. Generated automatically by treecc */\n", | |
| stream->embedName); | |
| OutputDefns(stream, 0); | |
| } | |
| void TreeCCStreamSourceTopCS(TreeCCStream *stream) | |
| { | |
| OutputDefns(stream, 0); | |
| } | |
| void TreeCCStreamSourceBottom(TreeCCStream *stream) | |
| { | |
| OutputDefns(stream, 1); | |
| } | |
| void TreeCCStreamLine(TreeCCStream *stream, long linenum, | |
| const char *filename) | |
| { | |
| if(stream->context->print_lines) | |
| { | |
| int len; | |
| if(stream->context->strip_filenames) | |
| { | |
| len = strlen(filename); | |
| while(len > 0 && filename[len - 1] != '/' && | |
| filename[len - 1] != '\\') | |
| { | |
| --len; | |
| } | |
| filename += len; | |
| } | |
| TreeCCStreamPrint(stream, "#line %ld \"%s\"\n", linenum, filename); | |
| } | |
| } | |
| #ifdef __cplusplus | |
| }; | |
| #endif |