| /** \file |
| * Defines the basic structures used to manipulate character |
| * streams from any input source. Any character size and encoding |
| * can in theory be used, so long as a set of functinos is provided that |
| * can return a 32 bit Integer representation of their characters amd efficiently mark and revert |
| * to specific offsets into their input streams. |
| */ |
| #ifndef _ANTLR3_INPUT_H |
| #define _ANTLR3_INPUT_H |
| |
| // [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 <antlr3defs.h> |
| #include <antlr3string.h> |
| #include <antlr3commontoken.h> |
| #include <antlr3intstream.h> |
| #include <antlr3convertutf.h> |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| |
| |
| /// Master context structure for an ANTLR3 C runtime based input stream. |
| /// \ingroup apistructures |
| /// |
| typedef struct ANTLR3_INPUT_STREAM_struct |
| { |
| /** Interfaces that provide streams must all provide |
| * a generic ANTLR3_INT_STREAM interface and an ANTLR3_INPUT_STREAM |
| * is no different. |
| */ |
| pANTLR3_INT_STREAM istream; |
| |
| /** Whatever super structure is providing the INPUT stream needs a pointer to itself |
| * so that this can be passed back to it whenever the api functions |
| * are called back from this interface. |
| */ |
| void * super; |
| |
| /** Pointer the start of the input string, characters may be |
| * taken as offsets from here and in original input format encoding. |
| */ |
| void * data; |
| |
| /** Indicates if the data pointer was allocated by us, and so should be freed |
| * when the stream dies. |
| */ |
| int isAllocated; |
| |
| /** String factory for this input stream |
| */ |
| pANTLR3_STRING_FACTORY strFactory; |
| |
| |
| /** Pointer to the next character to be consumed from the input data |
| * This is cast to point at the encoding of the original file that |
| * was read by the functions installed as pointer in this input stream |
| * context instance at file/string/whatever load time. |
| */ |
| void * nextChar; |
| |
| /** Number of characters that can be consumed at this point in time. |
| * Mostly this is just what is left in the pre-read buffer, but if the |
| * input source is a stream such as a socket or something then we may |
| * call special read code to wait for more input. |
| */ |
| ANTLR3_UINT32 sizeBuf; |
| |
| /** The line number we are traversing in the input file. This gets incremented |
| * by a newline() call in the lexer grammar actions. |
| */ |
| ANTLR3_UINT32 line; |
| |
| /** Pointer into the input buffer where the current line |
| * started. |
| */ |
| void * currentLine; |
| |
| /** The offset within the current line of the current character |
| */ |
| ANTLR3_INT32 charPositionInLine; |
| |
| /** Tracks how deep mark() calls are nested |
| */ |
| ANTLR3_UINT32 markDepth; |
| |
| /** List of mark() points in the input stream |
| */ |
| pANTLR3_VECTOR markers; |
| |
| /** File name string, set to pointer to memory if |
| * you set it manually as it will be free()d |
| */ |
| pANTLR3_STRING fileName; |
| |
| /** File number, needs to be set manually to some file index of your devising. |
| */ |
| ANTLR3_UINT32 fileNo; |
| |
| /* API */ |
| |
| |
| /** Pointer to function that closes the input stream |
| */ |
| void (*close) (struct ANTLR3_INPUT_STREAM_struct * input); |
| void (*free) (struct ANTLR3_INPUT_STREAM_struct * input); |
| |
| /** Pointer to function that resets the input stream |
| */ |
| void (*reset) (struct ANTLR3_INPUT_STREAM_struct * input); |
| |
| /** Pointer to a function that reuses and resets an input stream by |
| * supplying a new 'source' |
| */ |
| void (*reuse) (struct ANTLR3_INPUT_STREAM_struct * input, pANTLR3_UINT8 inString, ANTLR3_UINT32 size, pANTLR3_UINT8 name); |
| |
| /** |
| * Pointer to function that installs a version of LA that always |
| * returns upper case. Only valid for character streams and creates a case |
| * insensitive lexer if the lexer tokens are described in upper case. The |
| * tokens will preserve case in the token text. |
| */ |
| void (*setUcaseLA) (pANTLR3_INPUT_STREAM input, ANTLR3_BOOLEAN flag); |
| |
| /** Pointer to function to return input stream element at 1 based |
| * offset from nextChar. Same as _LA for char stream, but token |
| * streams etc. have one of these that does other stuff of course. |
| */ |
| void * (*_LT) (struct ANTLR3_INPUT_STREAM_struct * input, ANTLR3_INT32 lt); |
| |
| /** Pointer to function to return the total size of the input buffer. For streams |
| * this may be just the total we have available so far. This means of course that |
| * the input stream must be careful to accumulate enough input so that any backtracking |
| * can be satisfied. |
| */ |
| ANTLR3_UINT32 (*size) (struct ANTLR3_INPUT_STREAM_struct * input); |
| |
| /** Pointer to function to return a substring of the input stream. String is returned in allocated |
| * memory and is in same encoding as the input stream itself, NOT internal ANTLR3_UCHAR form. |
| */ |
| pANTLR3_STRING (*substr) (struct ANTLR3_INPUT_STREAM_struct * input, ANTLR3_MARKER start, ANTLR3_MARKER stop); |
| |
| /** Pointer to function to return the current line number in the input stream |
| */ |
| ANTLR3_UINT32 (*getLine) (struct ANTLR3_INPUT_STREAM_struct * input); |
| |
| /** Pointer to function to return the current line buffer in the input stream |
| * The pointer returned is directly into the input stream so you must copy |
| * it if you wish to manipulate it without damaging the input stream. Encoding |
| * is obviously in the same form as the input stream. |
| * \remark |
| * - Note taht this function wil lbe inaccurate if setLine is called as there |
| * is no way at the moment to position the input stream at a particular line |
| * number offset. |
| */ |
| void * (*getLineBuf) (struct ANTLR3_INPUT_STREAM_struct * input); |
| |
| /** Pointer to function to return the current offset in the current input stream line |
| */ |
| ANTLR3_UINT32 (*getCharPositionInLine) (struct ANTLR3_INPUT_STREAM_struct * input); |
| |
| /** Pointer to function to set the current line number in the input stream |
| */ |
| void (*setLine) (struct ANTLR3_INPUT_STREAM_struct * input, ANTLR3_UINT32 line); |
| |
| /** Pointer to function to set the current position in the current line. |
| */ |
| void (*setCharPositionInLine) (struct ANTLR3_INPUT_STREAM_struct * input, ANTLR3_UINT32 position); |
| |
| /** Pointer to function to override the default newline character that the input stream |
| * looks for to trigger the line/offset and line buffer recording information. |
| * \remark |
| * - By default the chracter '\n' will be installed as the newline trigger character. When this |
| * character is seen by the consume() function then the current line number is incremented and the |
| * current line offset is reset to 0. The Pointer for the line of input we are consuming |
| * is updated to point to the next character after this one in the input stream (which means it |
| * may become invalid if the last newline character in the file is seen (so watch out). |
| * - If for some reason you do not want the counters and pointers to be restee, you can set the |
| * chracter to some impossible character such as '\0' or whatever. |
| * - This is a single character only, so choose the last character in a sequence of two or more. |
| * - This is only a simple aid to error reporting - if you have a complicated binary input structure |
| * it may not be adequate, but you can always override every function in the input stream with your |
| * own of course, and can even write your own complete input stream set if you like. |
| * - It is your responsiblity to set a valid character for the input stream type. There is no point |
| * setting this to 0xFFFFFFFF if the input stream is 8 bit ASCII, as this will just be truncated and never |
| * trigger as the comparison will be (INT32)0xFF == (INT32)0xFFFFFFFF |
| */ |
| void (*SetNewLineChar) (struct ANTLR3_INPUT_STREAM_struct * input, ANTLR3_UINT32 newlineChar); |
| |
| /// Character that automatically causes an internal line count |
| /// increment. |
| /// |
| ANTLR3_UCHAR newlineChar; |
| |
| /// Indicates the size, in 8 bit units, of a single character. Note that |
| /// the C runtime does not deal with surrogates as this would be |
| /// slow and complicated. If this is a UTF-8 stream then this field |
| /// will be set to 0. Generally you are best working internally with 32 bit characters |
| /// as this is the most efficient. |
| /// |
| ANTLR3_UINT8 charByteSize; |
| |
| /// Indicates the encoding scheme used in this input stream |
| /// |
| ANTLR3_UINT32 encoding; |
| } |
| |
| ANTLR3_INPUT_STREAM; |
| |
| |
| /** \brief Structure for track lex input states as part of mark() |
| * and rewind() of lexer. |
| */ |
| typedef struct ANTLR3_LEX_STATE_struct |
| { |
| /** Pointer to the next character to be consumed from the input data |
| * This is cast to point at the encoding of the original file that |
| * was read by the functions installed as pointer in this input stream |
| * context instance at file/string/whatever load time. |
| */ |
| void * nextChar; |
| |
| /** The line number we are traversing in the input file. This gets incremented |
| * by a newline() call in the lexer grammer actions. |
| */ |
| ANTLR3_UINT32 line; |
| |
| /** Pointer into the input buffer where the current line |
| * started. |
| */ |
| void * currentLine; |
| |
| /** The offset within the current line of the current character |
| */ |
| ANTLR3_INT32 charPositionInLine; |
| |
| } |
| ANTLR3_LEX_STATE; |
| |
| /* Prototypes |
| */ |
| void antlr38BitSetupStream (pANTLR3_INPUT_STREAM input); |
| void antlr3UTF16SetupStream (pANTLR3_INPUT_STREAM input, ANTLR3_BOOLEAN machineBigEndian, ANTLR3_BOOLEAN inputBigEndian); |
| void antlr3UTF32SetupStream (pANTLR3_INPUT_STREAM input, ANTLR3_BOOLEAN machineBigEndian, ANTLR3_BOOLEAN inputBigEndian); |
| void antlr3UTF8SetupStream (pANTLR3_INPUT_STREAM input); |
| void antlr3EBCDICSetupStream (pANTLR3_INPUT_STREAM input); |
| void antlr3GenericSetupStream (pANTLR3_INPUT_STREAM input); |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| #endif /* _ANTLR3_INPUT_H */ |