diff options
Diffstat (limited to 'impl/antlr/libantlr3c-3.4/src/antlr3filestream.c')
| -rw-r--r-- | impl/antlr/libantlr3c-3.4/src/antlr3filestream.c | 474 |
1 files changed, 474 insertions, 0 deletions
diff --git a/impl/antlr/libantlr3c-3.4/src/antlr3filestream.c b/impl/antlr/libantlr3c-3.4/src/antlr3filestream.c new file mode 100644 index 0000000..4430ffe --- /dev/null +++ b/impl/antlr/libantlr3c-3.4/src/antlr3filestream.c @@ -0,0 +1,474 @@ +/** \file + * \brief The ANTLR3 C filestream is used when the source character stream + * is a filesystem based input set and all the characters in the filestream + * can be loaded at once into memory and away the lexer goes. + * + * A number of initializers are provided in order that various character + * sets can be supported from input files. The ANTLR3 C runtime expects + * to deal with UTF32 characters only (the reasons for this are to + * do with the simplification of C code when using this form of Unicode + * encoding, though this is not a panacea. More information can be + * found on this by consulting: + * - http://www.unicode.org/versions/Unicode4.0.0/ch02.pdf#G11178 + * Where a well grounded discussion of the encoding formats available + * may be found. + * + */ + +// [The "BSD licence"] +// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC +// http://www.temporal-wave.com +// http://www.linkedin.com/in/jimidle +// +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// 3. The name of the author may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#include <antlr3.h> + +static void setupInputStream (pANTLR3_INPUT_STREAM input); +static pANTLR3_INPUT_STREAM antlr3CreateFileStream (pANTLR3_UINT8 fileName); +static pANTLR3_INPUT_STREAM antlr3CreateStringStream (pANTLR3_UINT8 data); + +ANTLR3_API pANTLR3_INPUT_STREAM +antlr3FileStreamNew(pANTLR3_UINT8 fileName, ANTLR3_UINT32 encoding) +{ + pANTLR3_INPUT_STREAM input; + + // First order of business is to read the file into some buffer space + // as just straight 8 bit bytes. Then we will work out the encoding and + // byte order and adjust the API functions that are installed for the + // default 8Bit stream accordingly. + // + input = antlr3CreateFileStream(fileName); + if (input == NULL) + { + return NULL; + } + + // We have the data in memory now so we can deal with it according to + // the encoding scheme we were given by the user. + // + input->encoding = encoding; + + // Now we need to work out the endian type and install any + // API functions that differ from 8Bit + // + setupInputStream(input); + + // Now we can set up the file name + // + input->istream->streamName = input->strFactory->newStr8(input->strFactory, fileName); + input->fileName = input->istream->streamName; + + return input; +} + + +ANTLR3_API pANTLR3_INPUT_STREAM +antlr3StringStreamNew(pANTLR3_UINT8 data, ANTLR3_UINT32 encoding, ANTLR3_UINT32 size, pANTLR3_UINT8 name) +{ + pANTLR3_INPUT_STREAM input; + + // First order of business is to set up the stream and install the data pointer. + // Then we will work out the encoding and byte order and adjust the API functions that are installed for the + // default 8Bit stream accordingly. + // + input = antlr3CreateStringStream(data); + if (input == NULL) + { + return NULL; + } + + // Size (in bytes) of the given 'string' + // + input->sizeBuf = size; + + // We have the data in memory now so we can deal with it according to + // the encoding scheme we were given by the user. + // + input->encoding = encoding; + + // Now we need to work out the endian type and install any + // API functions that differ from 8Bit + // + setupInputStream(input); + + // Now we can set up the file name + // + input->istream->streamName = input->strFactory->newStr8(input->strFactory, name); + input->fileName = input->istream->streamName; + + return input; +} + + +/// Determine endianess of the input stream and install the +/// API required for the encoding in that format. +/// +static void +setupInputStream(pANTLR3_INPUT_STREAM input) +{ + ANTLR3_BOOLEAN isBigEndian; + + // Used to determine the endianness of the machine we are currently + // running on. + // + ANTLR3_UINT16 bomTest = 0xFEFF; + + // What endianess is the machine we are running on? If the incoming + // encoding endianess is the same as this machine's natural byte order + // then we can use more efficient API calls. + // + if (*((pANTLR3_UINT8)(&bomTest)) == 0xFE) + { + isBigEndian = ANTLR3_TRUE; + } + else + { + isBigEndian = ANTLR3_FALSE; + } + + // What encoding did the user tell us {s}he thought it was? I am going + // to get sick of the questions on antlr-interest, I know I am. + // + switch (input->encoding) + { + case ANTLR3_ENC_UTF8: + + // See if there is a BOM at the start of this UTF-8 sequence + // and just eat it if there is. Windows .TXT files have this for instance + // as it identifies UTF-8 even though it is of no consequence for byte order + // as UTF-8 does not have a byte order. + // + if ( (ANTLR3_UINT8)(*((pANTLR3_UINT8)input->nextChar)) == 0xEF + && (ANTLR3_UINT8)(*((pANTLR3_UINT8)input->nextChar+1)) == 0xBB + && (ANTLR3_UINT8)(*((pANTLR3_UINT8)input->nextChar+2)) == 0xBF + ) + { + // The UTF8 BOM is present so skip it + // + input->nextChar = (void *)((pANTLR3_UINT8)input->nextChar + 3); + } + + // Install the UTF8 input routines + // + antlr3UTF8SetupStream(input); + break; + + case ANTLR3_ENC_UTF16: + + // See if there is a BOM at the start of the input. If not then + // we assume that the byte order is the natural order of this + // machine (or it is really UCS2). If there is a BOM we determine if the encoding + // is the same as the natural order of this machine. + // + if ( (ANTLR3_UINT8)(*((pANTLR3_UINT8)input->nextChar)) == 0xFE + && (ANTLR3_UINT8)(*((pANTLR3_UINT8)input->nextChar+1)) == 0xFF + ) + { + // BOM Present, indicates Big Endian + // + input->nextChar = (void *)((pANTLR3_UINT8)input->nextChar + 2); + + antlr3UTF16SetupStream(input, isBigEndian, ANTLR3_TRUE); + } + else if ( (ANTLR3_UINT8)(*((pANTLR3_UINT8)input->nextChar)) == 0xFF + && (ANTLR3_UINT8)(*((pANTLR3_UINT8)input->nextChar+1)) == 0xFE + ) + { + // BOM present, indicates Little Endian + // + input->nextChar = (void *)((pANTLR3_UINT8)input->nextChar + 2); + + antlr3UTF16SetupStream(input, isBigEndian, ANTLR3_FALSE); + } + else + { + // No BOM present, assume local computer byte order + // + antlr3UTF16SetupStream(input, isBigEndian, isBigEndian); + } + break; + + case ANTLR3_ENC_UTF32: + + // See if there is a BOM at the start of the input. If not then + // we assume that the byte order is the natural order of this + // machine. If there is we determine if the encoding + // is the same as the natural order of this machine. + // + if ( (ANTLR3_UINT8)(*((pANTLR3_UINT8)input->nextChar)) == 0x00 + && (ANTLR3_UINT8)(*((pANTLR3_UINT8)input->nextChar+1)) == 0x00 + && (ANTLR3_UINT8)(*((pANTLR3_UINT8)input->nextChar+2)) == 0xFE + && (ANTLR3_UINT8)(*((pANTLR3_UINT8)input->nextChar+3)) == 0xFF + ) + { + // BOM Present, indicates Big Endian + // + input->nextChar = (void *)((pANTLR3_UINT8)input->nextChar + 4); + + antlr3UTF32SetupStream(input, isBigEndian, ANTLR3_TRUE); + } + else if ( (ANTLR3_UINT8)(*((pANTLR3_UINT8)input->nextChar)) == 0xFF + && (ANTLR3_UINT8)(*((pANTLR3_UINT8)input->nextChar+1)) == 0xFE + && (ANTLR3_UINT8)(*((pANTLR3_UINT8)input->nextChar+1)) == 0x00 + && (ANTLR3_UINT8)(*((pANTLR3_UINT8)input->nextChar+1)) == 0x00 + ) + { + // BOM present, indicates Little Endian + // + input->nextChar = (void *)((pANTLR3_UINT8)input->nextChar + 4); + + antlr3UTF32SetupStream(input, isBigEndian, ANTLR3_FALSE); + } + else + { + // No BOM present, assume local computer byte order + // + antlr3UTF32SetupStream(input, isBigEndian, isBigEndian); + } + break; + + case ANTLR3_ENC_UTF16BE: + + // Encoding is definately Big Endian with no BOM + // + antlr3UTF16SetupStream(input, isBigEndian, ANTLR3_TRUE); + break; + + case ANTLR3_ENC_UTF16LE: + + // Encoding is definately Little Endian with no BOM + // + antlr3UTF16SetupStream(input, isBigEndian, ANTLR3_FALSE); + break; + + case ANTLR3_ENC_UTF32BE: + + // Encoding is definately Big Endian with no BOM + // + antlr3UTF32SetupStream(input, isBigEndian, ANTLR3_TRUE); + break; + + case ANTLR3_ENC_UTF32LE: + + // Encoding is definately Little Endian with no BOM + // + antlr3UTF32SetupStream(input, isBigEndian, ANTLR3_FALSE); + break; + + case ANTLR3_ENC_EBCDIC: + + // EBCDIC is basically the same as ASCII but with an on the + // fly translation to ASCII + // + antlr3EBCDICSetupStream(input); + break; + + case ANTLR3_ENC_8BIT: + default: + + // Standard 8bit/ASCII + // + antlr38BitSetupStream(input); + break; + } +} + +/** \brief Use the contents of an operating system file as the input + * for an input stream. + * + * \param fileName Name of operating system file to read. + * \return + * - Pointer to new input stream context upon success + * - One of the ANTLR3_ERR_ defines on error. + */ +static pANTLR3_INPUT_STREAM +antlr3CreateFileStream(pANTLR3_UINT8 fileName) +{ + // Pointer to the input stream we are going to create + // + pANTLR3_INPUT_STREAM input; + ANTLR3_UINT32 status; + + if (fileName == NULL) + { + return NULL; + } + + // Allocate memory for the input stream structure + // + input = (pANTLR3_INPUT_STREAM) + ANTLR3_CALLOC(1, sizeof(ANTLR3_INPUT_STREAM)); + + if (input == NULL) + { + return NULL; + } + + // Structure was allocated correctly, now we can read the file. + // + status = antlr3read8Bit(input, fileName); + + // Call the common 8 bit input stream handler + // initialization. + // + antlr3GenericSetupStream(input); + + // However if the file was not there or something then we + // need to close. Have to wait until here as we cannot call + // close until the API is installed of course. + // + if (status != ANTLR3_SUCCESS) + { + input->close(input); + return NULL; + } + + return input; +} + +ANTLR3_API ANTLR3_UINT32 +antlr3read8Bit(pANTLR3_INPUT_STREAM input, pANTLR3_UINT8 fileName) +{ + ANTLR3_FDSC infile; + ANTLR3_UINT32 fSize; + + /* Open the OS file in read binary mode + */ + infile = antlr3Fopen(fileName, "rb"); + + /* Check that it was there + */ + if (infile == NULL) + { + return (ANTLR3_UINT32)ANTLR3_ERR_NOFILE; + } + + /* It was there, so we can read the bytes now + */ + fSize = antlr3Fsize(fileName); /* Size of input file */ + + /* Allocate buffer for this input set + */ + input->data = ANTLR3_MALLOC((size_t)fSize); + input->sizeBuf = fSize; + + if (input->data == NULL) + { + return (ANTLR3_UINT32)ANTLR3_ERR_NOMEM; + } + + input->isAllocated = ANTLR3_TRUE; + + /* Now we read the file. Characters are not converted to + * the internal ANTLR encoding until they are read from the buffer + */ + antlr3Fread(infile, fSize, input->data); + + /* And close the file handle + */ + antlr3Fclose(infile); + + return ANTLR3_SUCCESS; +} + +/** \brief Open an operating system file and return the descriptor + * We just use the common open() and related functions here. + * Later we might find better ways on systems + * such as Windows and OpenVMS for instance. But the idea is to read the + * while file at once anyway, so it may be irrelevant. + */ +ANTLR3_API ANTLR3_FDSC +antlr3Fopen(pANTLR3_UINT8 filename, const char * mode) +{ + return (ANTLR3_FDSC)fopen((const char *)filename, mode); +} + +/** \brief Close an operating system file and free any handles + * etc. + */ +ANTLR3_API void +antlr3Fclose(ANTLR3_FDSC fd) +{ + fclose(fd); +} +ANTLR3_API ANTLR3_UINT32 +antlr3Fsize(pANTLR3_UINT8 fileName) +{ + struct _stat statbuf; + + _stat((const char *)fileName, &statbuf); + + return (ANTLR3_UINT32)statbuf.st_size; +} + +ANTLR3_API ANTLR3_UINT32 +antlr3Fread(ANTLR3_FDSC fdsc, ANTLR3_UINT32 count, void * data) +{ + return (ANTLR3_UINT32)fread(data, (size_t)count, 1, fdsc); +} + + +/** \brief Use the supplied 'string' as input to the stream + * + * \param data Pointer to the input data + * \return + * - Pointer to new input stream context upon success + * - NULL defines on error. + */ +static pANTLR3_INPUT_STREAM +antlr3CreateStringStream(pANTLR3_UINT8 data) +{ + // Pointer to the input stream we are going to create + // + pANTLR3_INPUT_STREAM input; + + if (data == NULL) + { + return NULL; + } + + // Allocate memory for the input stream structure + // + input = (pANTLR3_INPUT_STREAM) + ANTLR3_CALLOC(1, sizeof(ANTLR3_INPUT_STREAM)); + + if (input == NULL) + { + return NULL; + } + + // Structure was allocated correctly, now we can install the pointer + // + input->data = data; + input->isAllocated = ANTLR3_FALSE; + + // Call the common 8 bit input stream handler + // initialization. + // + antlr3GenericSetupStream(input); + + return input; +}
\ No newline at end of file |