diff options
Diffstat (limited to 'impl/antlr/libantlr3c-3.4/include')
30 files changed, 0 insertions, 6142 deletions
diff --git a/impl/antlr/libantlr3c-3.4/include/antlr3.h b/impl/antlr/libantlr3c-3.4/include/antlr3.h deleted file mode 100644 index 2ead975..0000000 --- a/impl/antlr/libantlr3c-3.4/include/antlr3.h +++ /dev/null @@ -1,56 +0,0 @@ -#ifndef _ANTLR3_H -#define _ANTLR3_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 <antlr3errors.h> -#include <antlr3exception.h> -#include <antlr3encodings.h> -#include <antlr3string.h> -#include <antlr3input.h> -#include <antlr3cyclicdfa.h> -#include <antlr3intstream.h> -#include <antlr3filestream.h> -#include <antlr3collections.h> -#include <antlr3recognizersharedstate.h> -#include <antlr3baserecognizer.h> -#include <antlr3commontoken.h> -#include <antlr3tokenstream.h> -#include <antlr3bitset.h> -#include <antlr3lexer.h> -#include <antlr3parser.h> -#include <antlr3basetreeadaptor.h> -#include <antlr3commontreeadaptor.h> -#include <antlr3rewritestreams.h> -#include <antlr3debugeventlistener.h> - -#endif diff --git a/impl/antlr/libantlr3c-3.4/include/antlr3baserecognizer.h b/impl/antlr/libantlr3c-3.4/include/antlr3baserecognizer.h deleted file mode 100644 index 0a269d4..0000000 --- a/impl/antlr/libantlr3c-3.4/include/antlr3baserecognizer.h +++ /dev/null @@ -1,371 +0,0 @@ -/** \file - * Defines the basic structure to support recognizing by either a lexer, - * parser, or tree parser. - * \addtogroup ANTLR3_BASE_RECOGNIZER - * @{ - */ -#ifndef _ANTLR3_BASERECOGNIZER_H -#define _ANTLR3_BASERECOGNIZER_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 <antlr3exception.h> -#include <antlr3input.h> -#include <antlr3tokenstream.h> -#include <antlr3commontoken.h> -#include <antlr3commontreenodestream.h> -#include <antlr3debugeventlistener.h> -#include <antlr3recognizersharedstate.h> - -/** Type indicator for a lexer recognizer - */ -#define ANTLR3_TYPE_LEXER 0x0001 - -/** Type indicator for a parser recognizer - */ -#define ANTLR3_TYPE_PARSER 0x0002 - -/** Type indicator for a tree parser recognizer - */ -#define ANTLR3_TYPE_TREE_PARSER 0x0004 - -#ifdef __cplusplus -extern "C" { -#endif - -/** \brief Base tracking context structure for all types of - * recognizers. - */ -typedef struct ANTLR3_BASE_RECOGNIZER_struct -{ - /// Whatever super structure is providing this interface needs a pointer to itself - /// so that this can be passed back to it whenever the api functions - /// are called back from here. - /// - void * super; - - /// Indicates the type of recognizer that we are an instance of. - /// The programmer may set this to anything of course, but the default - /// implementations of the interface only really understand the built in - /// types, so new error handlers etc would probably be required to as well. - /// - /// Valid types are: - /// - /// - #ANTLR3_TYPE_LEXER - /// - #ANTLR3_TYPE_PARSER - /// - #ANTLR3_TYPE_TREE_PARSER - /// - ANTLR3_UINT32 type; - - /// A pointer to the shared recognizer state, such that multiple - /// recognizers can use the same inputs streams and so on (in - /// the case of grammar inheritance for instance. - /// - pANTLR3_RECOGNIZER_SHARED_STATE state; - - /// If set to something other than NULL, then this structure is - /// points to an instance of the debugger interface. In general, the - /// debugger is only referenced internally in recovery/error operations - /// so that it does not cause overhead by having to check this pointer - /// in every function/method - /// - pANTLR3_DEBUG_EVENT_LISTENER debugger; - - - /// Pointer to a function that matches the current input symbol - /// against the supplied type. the function causes an error if a - /// match is not found and the default implementation will also - /// attempt to perform one token insertion or deletion if that is - /// possible with the input stream. You can override the default - /// implementation by installing a pointer to your own function - /// in this interface after the recognizer has initialized. This can - /// perform different recovery options or not recover at all and so on. - /// To ignore recovery altogether, see the comments in the default - /// implementation of this function in antlr3baserecognizer.c - /// - /// Note that errors are signalled by setting the error flag below - /// and creating a new exception structure and installing it in the - /// exception pointer below (you can chain these if you like and handle them - /// in some customized way). - /// - void * (*match) (struct ANTLR3_BASE_RECOGNIZER_struct * recognizer, - ANTLR3_UINT32 ttype, pANTLR3_BITSET_LIST follow); - - /// Pointer to a function that matches the next token/char in the input stream - /// regardless of what it actually is. - /// - void (*matchAny) (struct ANTLR3_BASE_RECOGNIZER_struct * recognizer); - - /// Pointer to a function that decides if the token ahead of the current one is the - /// one we were loking for, in which case the curernt one is very likely extraneous - /// and can be reported that way. - /// - ANTLR3_BOOLEAN - (*mismatchIsUnwantedToken) (struct ANTLR3_BASE_RECOGNIZER_struct * recognizer, pANTLR3_INT_STREAM input, ANTLR3_UINT32 ttype); - - /// Pointer to a function that decides if the current token is one that can logically - /// follow the one we were looking for, in which case the one we were looking for is - /// probably missing from the input. - /// - ANTLR3_BOOLEAN - (*mismatchIsMissingToken) (struct ANTLR3_BASE_RECOGNIZER_struct * recognizer, pANTLR3_INT_STREAM input, pANTLR3_BITSET_LIST follow); - - /** Pointer to a function that works out what to do when a token mismatch - * occurs, so that Tree parsers can behave differently to other recognizers. - */ - void (*mismatch) (struct ANTLR3_BASE_RECOGNIZER_struct * recognizer, - ANTLR3_UINT32 ttype, pANTLR3_BITSET_LIST follow); - - /** Pointer to a function to call to report a recognition problem. You may override - * this function with your own function, but refer to the standard implementation - * in antlr3baserecognizer.c for guidance. The function should recognize whether - * error recovery is in force, so that it does not print out more than one error messages - * for the same error. From the java comments in BaseRecognizer.java: - * - * This method sets errorRecovery to indicate the parser is recovering - * not parsing. Once in recovery mode, no errors are generated. - * To get out of recovery mode, the parser must successfully match - * a token (after a resync). So it will go: - * - * 1. error occurs - * 2. enter recovery mode, report error - * 3. consume until token found in resynch set - * 4. try to resume parsing - * 5. next match() will reset errorRecovery mode - */ - void (*reportError) (struct ANTLR3_BASE_RECOGNIZER_struct * recognizer); - - /** Pointer to a function that is called to display a recognition error message. You may - * override this function independently of (*reportError)() above as that function calls - * this one to do the actual exception printing. - */ - void (*displayRecognitionError) (struct ANTLR3_BASE_RECOGNIZER_struct * recognizer, pANTLR3_UINT8 * tokenNames); - - /// Get number of recognition errors (lexer, parser, tree parser). Each - /// recognizer tracks its own number. So parser and lexer each have - /// separate count. Does not count the spurious errors found between - /// an error and next valid token match - /// - /// \see reportError() - /// - ANTLR3_UINT32 - (*getNumberOfSyntaxErrors) (struct ANTLR3_BASE_RECOGNIZER_struct * recognizer); - - /** Pointer to a function that recovers from an error found in the input stream. - * Generally, this will be a #ANTLR3_EXCEPTION_NOVIABLE_ALT but it could also - * be from a mismatched token that the (*match)() could not recover from. - */ - void (*recover) (struct ANTLR3_BASE_RECOGNIZER_struct * recognizer); - - /** Pointer to a function that is a hook to listen to token consumption during error recovery. - * This is mainly used by the debug parser to send events to the listener. - */ - void (*beginResync) (struct ANTLR3_BASE_RECOGNIZER_struct * recognizer); - - /** Pointer to a function that is a hook to listen to token consumption during error recovery. - * This is mainly used by the debug parser to send events to the listener. - */ - void (*endResync) (struct ANTLR3_BASE_RECOGNIZER_struct * recognizer); - - /** Pointer to a function that is a hook to listen to token consumption during error recovery. - * This is mainly used by the debug parser to send events to the listener. - */ - void (*beginBacktrack) (struct ANTLR3_BASE_RECOGNIZER_struct * recognizer, ANTLR3_UINT32 level); - - /** Pointer to a function that is a hook to listen to token consumption during error recovery. - * This is mainly used by the debug parser to send events to the listener. - */ - void (*endBacktrack) (struct ANTLR3_BASE_RECOGNIZER_struct * recognizer, ANTLR3_UINT32 level, ANTLR3_BOOLEAN successful); - - /** Pointer to a function to computer the error recovery set for the current rule. - * \see antlr3ComputeErrorRecoverySet() for details. - */ - pANTLR3_BITSET (*computeErrorRecoverySet) (struct ANTLR3_BASE_RECOGNIZER_struct * recognizer); - - /** Pointer to a function that computes the context-sensitive FOLLOW set for the - * current rule. - * \see antlr3ComputeCSRuleFollow() for details. - */ - pANTLR3_BITSET (*computeCSRuleFollow) (struct ANTLR3_BASE_RECOGNIZER_struct * recognizer); - - /** Pointer to a function to combine follow bitsets. - * \see antlr3CombineFollows() for details. - */ - pANTLR3_BITSET (*combineFollows) (struct ANTLR3_BASE_RECOGNIZER_struct * recognizer, - ANTLR3_BOOLEAN exact); - - /** Pointer to a function that recovers from a mismatched token in the input stream. - * \see antlr3RecoverMismatch() for details. - */ - void * (*recoverFromMismatchedToken) - (struct ANTLR3_BASE_RECOGNIZER_struct * recognizer, - ANTLR3_UINT32 ttype, - pANTLR3_BITSET_LIST follow); - - /** Pointer to a function that recovers from a mismatched set in the token stream, in a similar manner - * to (*recoverFromMismatchedToken) - */ - void * (*recoverFromMismatchedSet) (struct ANTLR3_BASE_RECOGNIZER_struct * recognizer, - pANTLR3_BITSET_LIST follow); - - /** Pointer to common routine to handle single token insertion for recovery functions. - */ - ANTLR3_BOOLEAN (*recoverFromMismatchedElement) - (struct ANTLR3_BASE_RECOGNIZER_struct * recognizer, - pANTLR3_BITSET_LIST follow); - - /** Pointer to function that consumes input until the next token matches - * the given token. - */ - void (*consumeUntil) (struct ANTLR3_BASE_RECOGNIZER_struct * recognizer, - ANTLR3_UINT32 tokenType); - - /** Pointer to function that consumes input until the next token matches - * one in the given set. - */ - void (*consumeUntilSet) (struct ANTLR3_BASE_RECOGNIZER_struct * recognizer, - pANTLR3_BITSET set); - - /** Pointer to function that returns an ANTLR3_LIST of the strings that identify - * the rules in the parser that got you to this point. Can be overridden by installing your - * own function set. - * - * \todo Document how to override invocation stack functions. - */ - pANTLR3_STACK (*getRuleInvocationStack) (struct ANTLR3_BASE_RECOGNIZER_struct * recognizer); - pANTLR3_STACK (*getRuleInvocationStackNamed) (struct ANTLR3_BASE_RECOGNIZER_struct * recognizer, - pANTLR3_UINT8 name); - - /** Pointer to a function that converts an ANLR3_LIST of tokens to an ANTLR3_LIST of - * string token names. As this is mostly used in string template processing it may not be useful - * in the C runtime. - */ - pANTLR3_HASH_TABLE (*toStrings) (struct ANTLR3_BASE_RECOGNIZER_struct * recognizer, - pANTLR3_HASH_TABLE); - - /** Pointer to a function to return whether the rule has parsed input starting at the supplied - * start index before. If the rule has not parsed input starting from the supplied start index, - * then it will return ANTLR3_MEMO_RULE_UNKNOWN. If it has parsed from the suppled start point - * then it will return the point where it last stopped parsing after that start point. - */ - ANTLR3_MARKER (*getRuleMemoization) (struct ANTLR3_BASE_RECOGNIZER_struct * recognizer, - ANTLR3_INTKEY ruleIndex, - ANTLR3_MARKER ruleParseStart); - - /** Pointer to function that determines whether the rule has parsed input at the current index - * in the input stream - */ - ANTLR3_BOOLEAN (*alreadyParsedRule) (struct ANTLR3_BASE_RECOGNIZER_struct * recognizer, - ANTLR3_MARKER ruleIndex); - - /** Pointer to function that records whether the rule has parsed the input at a - * current position successfully or not. - */ - void (*memoize) (struct ANTLR3_BASE_RECOGNIZER_struct * recognizer, - ANTLR3_MARKER ruleIndex, - ANTLR3_MARKER ruleParseStart); - - /// Pointer to a function that returns the current input symbol. - /// The is placed into any label for the associated token ref; e.g., x=ID. Token - /// and tree parsers need to return different objects. Rather than test - /// for input stream type or change the IntStream interface, I use - /// a simple method to ask the recognizer to tell me what the current - /// input symbol is. - /// - /// This is ignored for lexers and the lexer implementation of this - /// function should return NULL. - /// - void * (*getCurrentInputSymbol) ( struct ANTLR3_BASE_RECOGNIZER_struct * recognizer, - pANTLR3_INT_STREAM istream); - - /// Conjure up a missing token during error recovery. - /// - /// The recognizer attempts to recover from single missing - /// symbols. But, actions might refer to that missing symbol. - /// For example, x=ID {f($x);}. The action clearly assumes - /// that there has been an identifier matched previously and that - /// $x points at that token. If that token is missing, but - /// the next token in the stream is what we want we assume that - /// this token is missing and we keep going. Because we - /// have to return some token to replace the missing token, - /// we have to conjure one up. This method gives the user control - /// over the tokens returned for missing tokens. Mostly, - /// you will want to create something special for identifier - /// tokens. For literals such as '{' and ',', the default - /// action in the parser or tree parser works. It simply creates - /// a CommonToken of the appropriate type. The text will be the token. - /// If you change what tokens must be created by the lexer, - /// override this method to create the appropriate tokens. - /// - void * (*getMissingSymbol) ( struct ANTLR3_BASE_RECOGNIZER_struct * recognizer, - pANTLR3_INT_STREAM istream, - pANTLR3_EXCEPTION e, - ANTLR3_UINT32 expectedTokenType, - pANTLR3_BITSET_LIST follow); - - /** Pointer to a function that returns whether the supplied grammar function - * will parse the current input stream or not. This is the way that syntactic - * predicates are evaluated. Unlike java, C is perfectly happy to invoke code - * via a pointer to a function (hence that's what all the ANTLR3 C interfaces - * do. - */ - ANTLR3_BOOLEAN (*synpred) ( struct ANTLR3_BASE_RECOGNIZER_struct * recognizer, void * ctx, - void (*predicate)(void * ctx)); - - /** Pointer to a function that can construct a generic exception structure - * with such information as the input stream can provide. - */ - void (*exConstruct) (struct ANTLR3_BASE_RECOGNIZER_struct * recognizer); - - /** Reset the recognizer - */ - void (*reset) (struct ANTLR3_BASE_RECOGNIZER_struct * recognizer); - - /** Pointer to a function that knows how to free the resources of a base recognizer. - */ - void (*free) (struct ANTLR3_BASE_RECOGNIZER_struct * recognizer); - -} - ANTLR3_BASE_RECOGNIZER; - -#ifdef __cplusplus -} -#endif - -#include <antlr3lexer.h> -#include <antlr3parser.h> -#include <antlr3treeparser.h> - -/// @} -/// - -#endif /* _ANTLR3_BASERECOGNIZER_H */ - diff --git a/impl/antlr/libantlr3c-3.4/include/antlr3basetree.h b/impl/antlr/libantlr3c-3.4/include/antlr3basetree.h deleted file mode 100644 index 023c4c2..0000000 --- a/impl/antlr/libantlr3c-3.4/include/antlr3basetree.h +++ /dev/null @@ -1,143 +0,0 @@ -/// \file -/// Definition of the ANTLR3 base tree. -/// - -#ifndef _ANTLR3_BASE_TREE_H -#define _ANTLR3_BASE_TREE_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 <antlr3collections.h> -#include <antlr3string.h> - -#ifdef __cplusplus -extern "C" { -#endif - -/// A generic tree implementation with no payload. You must subclass to -/// actually have any user data. ANTLR v3 uses a list of children approach -/// instead of the child-sibling approach in v2. A flat tree (a list) is -/// an empty node whose children represent the list. An empty (as in it does not -/// have payload itself), but non-null node is called "nil". -/// -typedef struct ANTLR3_BASE_TREE_struct -{ - - /// Implementers of this interface sometimes require a pointer to their selves. - /// - void * super; - - /// Generic void pointer allows the grammar programmer to attach any structure they - /// like to a tree node, in many cases saving the need to create their own tree - /// and tree adaptors. ANTLR does not use this pointer, but will copy it for you and so on. - /// - void * u; - - /// The list of all the children that belong to this node. They are not part of the node - /// as they belong to the common tree node that implements this. - /// - pANTLR3_VECTOR children; - - /// This is used to store the current child index position while descending - /// and ascending trees as the tree walk progresses. - /// - ANTLR3_MARKER savedIndex; - - /// A string factory to produce strings for toString etc - /// - pANTLR3_STRING_FACTORY strFactory; - - /// A pointer to a function that returns the common token pointer - /// for the payload in the supplied tree. - /// - pANTLR3_COMMON_TOKEN (*getToken) (struct ANTLR3_BASE_TREE_struct * tree); - - void (*addChild) (struct ANTLR3_BASE_TREE_struct * tree, void * child); - - void (*addChildren) (struct ANTLR3_BASE_TREE_struct * tree, pANTLR3_LIST kids); - - void (*createChildrenList) (struct ANTLR3_BASE_TREE_struct * tree); - - void * (*deleteChild) (struct ANTLR3_BASE_TREE_struct * tree, ANTLR3_UINT32 i); - - void (*replaceChildren) (struct ANTLR3_BASE_TREE_struct * parent, ANTLR3_INT32 startChildIndex, ANTLR3_INT32 stopChildIndex, struct ANTLR3_BASE_TREE_struct * t); - - void * (*dupNode) (struct ANTLR3_BASE_TREE_struct * dupNode); - - void * (*dupTree) (struct ANTLR3_BASE_TREE_struct * tree); - - ANTLR3_UINT32 (*getCharPositionInLine) (struct ANTLR3_BASE_TREE_struct * tree); - - void * (*getChild) (struct ANTLR3_BASE_TREE_struct * tree, ANTLR3_UINT32 i); - - void (*setChildIndex) (struct ANTLR3_BASE_TREE_struct * tree, ANTLR3_INT32 ); - - ANTLR3_INT32 (*getChildIndex) (struct ANTLR3_BASE_TREE_struct * tree ); - - ANTLR3_UINT32 (*getChildCount) (struct ANTLR3_BASE_TREE_struct * tree); - - struct ANTLR3_BASE_TREE_struct * (*getParent) (struct ANTLR3_BASE_TREE_struct * tree); - - void (*setParent) (struct ANTLR3_BASE_TREE_struct * tree, struct ANTLR3_BASE_TREE_struct * parent); - - ANTLR3_UINT32 (*getType) (struct ANTLR3_BASE_TREE_struct * tree); - - void * (*getFirstChildWithType) (struct ANTLR3_BASE_TREE_struct * tree, ANTLR3_UINT32 type); - - ANTLR3_UINT32 (*getLine) (struct ANTLR3_BASE_TREE_struct * tree); - - pANTLR3_STRING (*getText) (struct ANTLR3_BASE_TREE_struct * tree); - - ANTLR3_BOOLEAN (*isNilNode) (struct ANTLR3_BASE_TREE_struct * tree); - - void (*setChild) (struct ANTLR3_BASE_TREE_struct * tree, ANTLR3_UINT32 i, void * child); - - pANTLR3_STRING (*toStringTree) (struct ANTLR3_BASE_TREE_struct * tree); - - pANTLR3_STRING (*toString) (struct ANTLR3_BASE_TREE_struct * tree); - - void (*freshenPACIndexesAll) (struct ANTLR3_BASE_TREE_struct * tree); - - void (*freshenPACIndexes) (struct ANTLR3_BASE_TREE_struct * tree, ANTLR3_UINT32 offset); - - void (*reuse) (struct ANTLR3_BASE_TREE_struct * tree); - - void (*free) (struct ANTLR3_BASE_TREE_struct * tree); - -} - ANTLR3_BASE_TREE; - -#ifdef __cplusplus -} -#endif - - -#endif diff --git a/impl/antlr/libantlr3c-3.4/include/antlr3basetreeadaptor.h b/impl/antlr/libantlr3c-3.4/include/antlr3basetreeadaptor.h deleted file mode 100644 index bf9a72a..0000000 --- a/impl/antlr/libantlr3c-3.4/include/antlr3basetreeadaptor.h +++ /dev/null @@ -1,152 +0,0 @@ -/** \file - * Definition of the ANTLR3 base tree adaptor. - */ - -#ifndef _ANTLR3_BASE_TREE_ADAPTOR_H -#define _ANTLR3_BASE_TREE_ADAPTOR_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 <antlr3collections.h> -#include <antlr3string.h> -#include <antlr3basetree.h> -#include <antlr3commontoken.h> -#include <antlr3debugeventlistener.h> - -#ifdef __cplusplus -extern "C" { -#endif - -typedef struct ANTLR3_BASE_TREE_ADAPTOR_struct -{ - /** Pointer to any enclosing structure/interface that - * contains this structure. - */ - void * super; - - /** We need a string factory for creating imaginary tokens, we take this - * from the stream we are supplied to walk. - */ - pANTLR3_STRING_FACTORY strFactory; - - /* And we also need a token factory for creating imaginary tokens - * this is also taken from the input source. - */ - pANTLR3_TOKEN_FACTORY tokenFactory; - - /// If set to something other than NULL, then this structure is - /// points to an instance of the debugger interface. In general, the - /// debugger is only referenced internally in recovery/error operations - /// so that it does not cause overhead by having to check this pointer - /// in every function/method - /// - pANTLR3_DEBUG_EVENT_LISTENER debugger; - - void * (*nilNode) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor); - - - void * (*dupTree) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, void * tree); - void * (*dupTreeTT) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, void * t, void * tree); - - void (*addChild) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, void * t, void * child); - void (*addChildToken) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, void * t, pANTLR3_COMMON_TOKEN child); - void (*setParent) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, void * child, void * parent); - void * (*getParent) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, void * child); - - void * (*errorNode) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, pANTLR3_TOKEN_STREAM tnstream, pANTLR3_COMMON_TOKEN startToken, pANTLR3_COMMON_TOKEN stopToken, pANTLR3_EXCEPTION e); - ANTLR3_BOOLEAN (*isNilNode) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, void * t); - - void * (*becomeRoot) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, void * newRoot, void * oldRoot); - - void * (*rulePostProcessing) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, void * root); - - void * (*becomeRootToken) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, void * newRoot, void * oldRoot); - - void * (*create) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, pANTLR3_COMMON_TOKEN payload); - void * (*createTypeToken) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, ANTLR3_UINT32 tokenType, pANTLR3_COMMON_TOKEN fromToken); - void * (*createTypeTokenText) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, ANTLR3_UINT32 tokenType, pANTLR3_COMMON_TOKEN fromToken, pANTLR3_UINT8 text); - void * (*createTypeText) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, ANTLR3_UINT32 tokenType, pANTLR3_UINT8 text); - - void * (*dupNode) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, void * treeNode); - - ANTLR3_UINT32 (*getType) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, void * t); - - void (*setType) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, void * t, ANTLR3_UINT32 type); - - pANTLR3_STRING (*getText) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, void * t); - - void (*setText) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, pANTLR3_STRING t); - void (*setText8) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, pANTLR3_UINT8 t); - - void * (*getChild) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, void * t, ANTLR3_UINT32 i); - void (*setChild) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, void * t, ANTLR3_UINT32 i, void * child); - void (*deleteChild) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, void * t, ANTLR3_UINT32 i); - void (*setChildIndex) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, void * t, ANTLR3_UINT32 i); - ANTLR3_INT32 (*getChildIndex) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, void * t); - - ANTLR3_UINT32 (*getChildCount) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, void *); - - ANTLR3_UINT32 (*getUniqueID) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, void *); - - pANTLR3_COMMON_TOKEN (*createToken) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, ANTLR3_UINT32 tokenType, pANTLR3_UINT8 text); - pANTLR3_COMMON_TOKEN (*createTokenFromToken) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, pANTLR3_COMMON_TOKEN fromToken); - pANTLR3_COMMON_TOKEN (*getToken) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, void * t); - - void (*setTokenBoundaries) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, void * t, pANTLR3_COMMON_TOKEN startToken, pANTLR3_COMMON_TOKEN stopToken); - - ANTLR3_MARKER (*getTokenStartIndex) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, void * t); - - ANTLR3_MARKER (*getTokenStopIndex) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, void * t); - - void (*setDebugEventListener)(struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, pANTLR3_DEBUG_EVENT_LISTENER debugger); - - /// Produce a DOT (see graphviz freeware suite) from a base tree - /// - pANTLR3_STRING (*makeDot) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, void * theTree); - - /// Replace from start to stop child index of parent with t, which might - /// be a list. Number of children may be different - /// after this call. - /// - /// If parent is null, don't do anything; must be at root of overall tree. - /// Can't replace whatever points to the parent externally. Do nothing. - /// - void (*replaceChildren) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor, void * parent, ANTLR3_INT32 startChildIndex, ANTLR3_INT32 stopChildIndex, void * t); - - void (*free) (struct ANTLR3_BASE_TREE_ADAPTOR_struct * adaptor); - -} - ANTLR3_TREE_ADAPTOR, *pANTLR3_TREE_ADAPTOR; -#ifdef __cplusplus -} -#endif - -#endif diff --git a/impl/antlr/libantlr3c-3.4/include/antlr3bitset.h b/impl/antlr/libantlr3c-3.4/include/antlr3bitset.h deleted file mode 100644 index 7d816ab..0000000 --- a/impl/antlr/libantlr3c-3.4/include/antlr3bitset.h +++ /dev/null @@ -1,119 +0,0 @@ -/** - * \file - * Defines the basic structures of an ANTLR3 bitset. this is a C version of the - * cut down Bitset class provided with the java version of antlr 3. - * - * - */ -#ifndef _ANTLR3_BITSET_H -#define _ANTLR3_BITSET_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 <antlr3collections.h> - -/** How many bits in the elements - */ -#define ANTLR3_BITSET_BITS 64 - -/** How many bits in a nible of bits - */ -#define ANTLR3_BITSET_NIBBLE 4 - -/** log2 of ANTLR3_BITSET_BITS 2^ANTLR3_BITSET_LOG_BITS = ANTLR3_BITSET_BITS - */ -#define ANTLR3_BITSET_LOG_BITS 6 - -/** We will often need to do a mod operator (i mod nbits). - * For powers of two, this mod operation is the - * same as: - * - (i & (nbits-1)). - * - * Since mod is relatively slow, we use an easily - * precomputed mod mask to do the mod instead. - */ -#define ANTLR3_BITSET_MOD_MASK ANTLR3_BITSET_BITS - 1 - -#ifdef __cplusplus -extern "C" { -#endif - -typedef struct ANTLR3_BITSET_LIST_struct -{ - /// Pointer to the allocated array of bits for this bit set, which - /// is an array of 64 bit elements (of the architecture). If we find a - /// machine/C compiler that does not know anything about 64 bit values - /// then it should be easy enough to produce a 32 bit (or less) version - /// of the bitset code. Note that the pointer here may be static if laid down - /// by the code generation, and it must be copied if it is to be manipulated - /// to perform followset calculations. - /// - pANTLR3_BITWORD bits; - - /// Length of the current bit set in ANTLR3_UINT64 units. - /// - ANTLR3_UINT32 length; -} - ANTLR3_BITSET_LIST; - -typedef struct ANTLR3_BITSET_struct -{ - /// The actual bits themselves - /// - ANTLR3_BITSET_LIST blist; - - pANTLR3_BITSET (*clone) (struct ANTLR3_BITSET_struct * inSet); - pANTLR3_BITSET (*bor) (struct ANTLR3_BITSET_struct * bitset1, struct ANTLR3_BITSET_struct * bitset2); - void (*borInPlace) (struct ANTLR3_BITSET_struct * bitset, struct ANTLR3_BITSET_struct * bitset2); - ANTLR3_UINT32 (*size) (struct ANTLR3_BITSET_struct * bitset); - void (*add) (struct ANTLR3_BITSET_struct * bitset, ANTLR3_INT32 bit); - void (*grow) (struct ANTLR3_BITSET_struct * bitset, ANTLR3_INT32 newSize); - ANTLR3_BOOLEAN (*equals) (struct ANTLR3_BITSET_struct * bitset1, struct ANTLR3_BITSET_struct * bitset2); - ANTLR3_BOOLEAN (*isMember) (struct ANTLR3_BITSET_struct * bitset, ANTLR3_UINT32 bit); - ANTLR3_UINT32 (*numBits) (struct ANTLR3_BITSET_struct * bitset); - void (*remove) (struct ANTLR3_BITSET_struct * bitset, ANTLR3_UINT32 bit); - ANTLR3_BOOLEAN (*isNilNode) (struct ANTLR3_BITSET_struct * bitset); - pANTLR3_INT32 (*toIntList) (struct ANTLR3_BITSET_struct * bitset); - - void (*free) (struct ANTLR3_BITSET_struct * bitset); - - -} - ANTLR3_BITSET; - -#ifdef __cplusplus -} -#endif - - - -#endif - diff --git a/impl/antlr/libantlr3c-3.4/include/antlr3collections.h b/impl/antlr/libantlr3c-3.4/include/antlr3collections.h deleted file mode 100644 index 7c73e36..0000000 --- a/impl/antlr/libantlr3c-3.4/include/antlr3collections.h +++ /dev/null @@ -1,513 +0,0 @@ -#ifndef ANTLR3COLLECTIONS_H -#define ANTLR3COLLECTIONS_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 <antlr3bitset.h> - -#define ANTLR3_HASH_TYPE_INT 0 /**< Indicates the hashed file has integer keys */ -#define ANTLR3_HASH_TYPE_STR 1 /**< Indicates the hashed file has numeric keys */ - -#ifdef __cplusplus -extern "C" { -#endif - -typedef struct ANTLR3_HASH_KEY_struct -{ - ANTLR3_UINT8 type; /**< One of ##ANTLR3_HASH_TYPE_INT or ##ANTLR3_HASH_TYPE_STR */ - - union - { - pANTLR3_UINT8 sKey; /**< Used if type is ANTLR3_HASH_TYPE_STR */ - ANTLR3_INTKEY iKey; /**< used if type is ANTLR3_HASH_TYPE_INT */ - } - key; - -} ANTLR3_HASH_KEY, *pANTLR3_HASH_KEY; - -/** Internal structure representing an element in a hash bucket. - * Stores the original key so that duplicate keys can be rejected - * if necessary, and contains function can be supported. If the hash key - * could be unique I would have invented the perfect compression algorithm ;-) - */ -typedef struct ANTLR3_HASH_ENTRY_struct -{ - /** Key that created this particular entry - */ - ANTLR3_HASH_KEY keybase; - - /** Pointer to the data for this particular entry - */ - void * data; - - /** Pointer to routine that knows how to release the memory - * structure pointed at by data. If this is NULL then we assume - * that the data pointer does not need to be freed when the entry - * is deleted from the table. - */ - void (ANTLR3_CDECL *free)(void * data); - - /** Pointer to the next entry in this bucket if there - * is one. Sometimes different keys will hash to the same bucket (especially - * if the number of buckets is small). We could implement dual hashing algorithms - * to minimize this, but that seems over the top for what this is needed for. - */ - struct ANTLR3_HASH_ENTRY_struct * nextEntry; -} - ANTLR3_HASH_ENTRY; - -/** Internal structure of a hash table bucket, which tracks - * all keys that hash to the same bucket. - */ -typedef struct ANTLR3_HASH_BUCKET_struct -{ - /** Pointer to the first entry in the bucket (if any, it - * may be NULL). Duplicate entries are chained from - * here. - */ - pANTLR3_HASH_ENTRY entries; - -} - ANTLR3_HASH_BUCKET; - -/** Structure that tracks a hash table - */ -typedef struct ANTLR3_HASH_TABLE_struct -{ - /** Indicates whether the table allows duplicate keys - */ - int allowDups; - - /** Number of buckets available in this table - */ - ANTLR3_UINT32 modulo; - - /** Points to the memory where the array of buckets - * starts. - */ - pANTLR3_HASH_BUCKET buckets; - - /** How many elements currently exist in the table. - */ - ANTLR3_UINT32 count; - - /** Whether the hash table should strdup the keys it is given or not. - */ - ANTLR3_BOOLEAN doStrdup; - - /** Pointer to function to completely delete this table - */ - void (*free) (struct ANTLR3_HASH_TABLE_struct * table); - - /* String keyed hashtable functions */ - void (*del) (struct ANTLR3_HASH_TABLE_struct * table, void * key); - pANTLR3_HASH_ENTRY (*remove) (struct ANTLR3_HASH_TABLE_struct * table, void * key); - void * (*get) (struct ANTLR3_HASH_TABLE_struct * table, void * key); - ANTLR3_INT32 (*put) (struct ANTLR3_HASH_TABLE_struct * table, void * key, void * element, void (ANTLR3_CDECL *freeptr)(void *)); - - /* Integer based hash functions */ - void (*delI) (struct ANTLR3_HASH_TABLE_struct * table, ANTLR3_INTKEY key); - pANTLR3_HASH_ENTRY (*removeI) (struct ANTLR3_HASH_TABLE_struct * table, ANTLR3_INTKEY key); - void * (*getI) (struct ANTLR3_HASH_TABLE_struct * table, ANTLR3_INTKEY key); - ANTLR3_INT32 (*putI) (struct ANTLR3_HASH_TABLE_struct * table, ANTLR3_INTKEY key, void * element, void (ANTLR3_CDECL *freeptr)(void *)); - - ANTLR3_UINT32 (*size) (struct ANTLR3_HASH_TABLE_struct * table); -} - ANTLR3_HASH_TABLE; - - -/** Internal structure representing an enumeration of a table. - * This is returned by antlr3Enumeration() - * Allows the programmer to traverse the table in hash order without - * knowing what is in the actual table. - * - * Note that it is up to the caller to ensure that the table - * structure does not change in the hash bucket that is currently being - * enumerated as this structure just tracks the next pointers in the - * bucket series. - */ -typedef struct ANTLR3_HASH_ENUM_struct -{ - /* Pointer to the table we are enumerating - */ - pANTLR3_HASH_TABLE table; - - /* Bucket we are currently enumerating (if NULL then we are done) - */ - ANTLR3_UINT32 bucket; - - /* Next entry to return, if NULL, then move to next bucket if any - */ - pANTLR3_HASH_ENTRY entry; - - /* Interface - */ - int (*next) (struct ANTLR3_HASH_ENUM_struct * en, pANTLR3_HASH_KEY *key, void ** data); - void (*free) (struct ANTLR3_HASH_ENUM_struct * table); -} - ANTLR3_HASH_ENUM; - -/** Structure that represents a LIST collection - */ -typedef struct ANTLR3_LIST_struct -{ - /** Hash table that is storing the list elements - */ - pANTLR3_HASH_TABLE table; - - void (*free) (struct ANTLR3_LIST_struct * list); - void (*del) (struct ANTLR3_LIST_struct * list, ANTLR3_INTKEY key); - void * (*get) (struct ANTLR3_LIST_struct * list, ANTLR3_INTKEY key); - void * (*remove) (struct ANTLR3_LIST_struct * list, ANTLR3_INTKEY key); - ANTLR3_INT32 (*add) (struct ANTLR3_LIST_struct * list, void * element, void (ANTLR3_CDECL *freeptr)(void *)); - ANTLR3_INT32 (*put) (struct ANTLR3_LIST_struct * list, ANTLR3_INTKEY key, void * element, void (ANTLR3_CDECL *freeptr)(void *)); - ANTLR3_UINT32 (*size) (struct ANTLR3_LIST_struct * list); - -} - ANTLR3_LIST; - -/** Structure that represents a Stack collection - */ -typedef struct ANTLR3_STACK_struct -{ - /** List that supports the stack structure - */ - pANTLR3_VECTOR vector; - - /** Used for quick access to the top of the stack - */ - void * top; - void (*free) (struct ANTLR3_STACK_struct * stack); - void * (*pop) (struct ANTLR3_STACK_struct * stack); - void * (*get) (struct ANTLR3_STACK_struct * stack, ANTLR3_INTKEY key); - ANTLR3_BOOLEAN (*push) (struct ANTLR3_STACK_struct * stack, void * element, void (ANTLR3_CDECL *freeptr)(void *)); - ANTLR3_UINT32 (*size) (struct ANTLR3_STACK_struct * stack); - void * (*peek) (struct ANTLR3_STACK_struct * stack); - -} - ANTLR3_STACK; - -/* Structure that represents a vector element - */ -typedef struct ANTLR3_VECTOR_ELEMENT_struct -{ - void * element; - void (ANTLR3_CDECL *freeptr)(void *); -} - ANTLR3_VECTOR_ELEMENT, *pANTLR3_VECTOR_ELEMENT; - -#define ANTLR3_VECTOR_INTERNAL_SIZE 16 -/* Structure that represents a vector collection. A vector is a simple list - * that contains a pointer to the element and a pointer to a function that - * that can free the element if it is removed. It auto resizes but does not - * use hash techniques as it is referenced by a simple numeric index. It is not a - * sparse list, so if any element is deleted, then the ones following are moved - * down in memory and the count is adjusted. - */ -typedef struct ANTLR3_VECTOR_struct -{ - /** Array of pointers to vector elements - */ - pANTLR3_VECTOR_ELEMENT elements; - - /** Number of entries currently in the list; - */ - ANTLR3_UINT32 count; - - /** Many times, a vector holds just a few nodes in an AST and it - * is too much overhead to malloc the space for elements so - * at the expense of a few bytes of memory, we hold the first - * few elements internally. It means we must copy them when - * we grow beyond this initial size, but that is less overhead than - * the malloc/free callas we would otherwise require. - */ - ANTLR3_VECTOR_ELEMENT internal[ANTLR3_VECTOR_INTERNAL_SIZE]; - - /** Indicates if the structure was made by a factory, in which - * case only the factory can free the memory for the actual vector, - * though the vector free function is called and will recurse through its - * entries calling any free pointers for each entry. - */ - ANTLR3_BOOLEAN factoryMade; - - /** Total number of entries in elements at any point in time - */ - ANTLR3_UINT32 elementsSize; - - void (ANTLR3_CDECL *free) (struct ANTLR3_VECTOR_struct * vector); - void (*del) (struct ANTLR3_VECTOR_struct * vector, ANTLR3_UINT32 entry); - void * (*get) (struct ANTLR3_VECTOR_struct * vector, ANTLR3_UINT32 entry); - void * (*remove) (struct ANTLR3_VECTOR_struct * vector, ANTLR3_UINT32 entry); - void (*clear) (struct ANTLR3_VECTOR_struct * vector); - ANTLR3_BOOLEAN (*swap) (struct ANTLR3_VECTOR_struct *, ANTLR3_UINT32 entry1, ANTLR3_UINT32 entry2); - ANTLR3_UINT32 (*add) (struct ANTLR3_VECTOR_struct * vector, void * element, void (ANTLR3_CDECL *freeptr)(void *)); - ANTLR3_UINT32 (*set) (struct ANTLR3_VECTOR_struct * vector, ANTLR3_UINT32 entry, void * element, void (ANTLR3_CDECL *freeptr)(void *), ANTLR3_BOOLEAN freeExisting); - ANTLR3_UINT32 (*size) (struct ANTLR3_VECTOR_struct * vector); -} - ANTLR3_VECTOR; - -/** Default vector pool size if otherwise unspecified - */ -#define ANTLR3_FACTORY_VPOOL_SIZE 256 - -/** Structure that tracks vectors in a vector and auto deletes the vectors - * in the vector factory when closed. - */ -typedef struct ANTLR3_VECTOR_FACTORY_struct -{ - - /** List of all vector pools allocated so far - */ - pANTLR3_VECTOR *pools; - - /** Count of the vector pools allocated so far (current active pool) - */ - ANTLR3_INT32 thisPool; - - /** The next vector available in the pool - */ - ANTLR3_UINT32 nextVector; - - /** Trick to quickly initialize a new vector via memcpy and not a function call - */ - ANTLR3_VECTOR unTruc; - - /** Consumers from the factory can release a factory produced vector - * back to the factory so that it may be reused (and thus conserve memory) - * by another caller. The available vectors are stored here. Note that - * the only vectors avaible in the free chain are produced by this factory, so they - * need not be explicitly freed when the factory is closed. - */ - pANTLR3_STACK freeStack; - - /** Function to close the vector factory - */ - void (*close) (struct ANTLR3_VECTOR_FACTORY_struct * factory); - - /** Function to supply a new vector - */ - pANTLR3_VECTOR (*newVector) (struct ANTLR3_VECTOR_FACTORY_struct * factory); - - /// Function to return a vector to the factory for reuse - /// - void (*returnVector) (struct ANTLR3_VECTOR_FACTORY_struct * factory, pANTLR3_VECTOR vector); - -} -ANTLR3_VECTOR_FACTORY; - - -/* -------------- TRIE Interfaces ---------------- */ - - -/** Structure that holds the payload entry in an ANTLR3_INT_TRIE or ANTLR3_STRING_TRIE - */ -typedef struct ANTLR3_TRIE_ENTRY_struct -{ - ANTLR3_UINT32 type; - void (ANTLR3_CDECL *freeptr)(void *); - union - { - ANTLR3_INTKEY intVal; - void * ptr; - } data; - - struct ANTLR3_TRIE_ENTRY_struct * next; /* Allows duplicate entries for same key in insertion order */ -} -ANTLR3_TRIE_ENTRY, * pANTLR3_TRIE_ENTRY; - - -/** Structure that defines an element/node in an ANTLR3_INT_TRIE - */ -typedef struct ANTLR3_INT_TRIE_NODE_struct -{ - ANTLR3_UINT32 bitNum; /**< This is the left/right bit index for traversal along the nodes */ - ANTLR3_INTKEY key; /**< This is the actual key that the entry represents if it is a terminal node */ - pANTLR3_TRIE_ENTRY buckets; /**< This is the data bucket(s) that the key indexes, which may be NULL */ - struct ANTLR3_INT_TRIE_NODE_struct * leftN; /**< Pointer to the left node from here when sKey & bitNum = 0 */ - struct ANTLR3_INT_TRIE_NODE_struct * rightN; /**< Pointer to the right node from here when sKey & bitNum, = 1 */ -} - ANTLR3_INT_TRIE_NODE, * pANTLR3_INT_TRIE_NODE; - -/** Structure that defines an ANTLR3_INT_TRIE. For this particular implementation, - * as you might expect, the key is turned into a "string" by looking at bit(key, depth) - * of the integer key. Using 64 bit keys gives us a depth limit of 64 (or bit 0..63) - * and potentially a huge trie. This is the algorithm for a Patricia Trie. - * Note also that this trie [can] accept multiple entries for the same key and is - * therefore a kind of elastic bucket patricia trie. - * - * If you find this code useful, please feel free to 'steal' it for any purpose - * as covered by the BSD license under which ANTLR is issued. You can cut the code - * but as the ANTLR library is only about 50K (Windows Vista), you might find it - * easier to just link the library. Please keep all comments and licenses and so on - * in any version of this you create of course. - * - * Jim Idle. - * - */ -typedef struct ANTLR3_INT_TRIE_struct -{ - pANTLR3_INT_TRIE_NODE root; /* Root node of this integer trie */ - pANTLR3_INT_TRIE_NODE current; /* Used to traverse the TRIE with the next() method */ - ANTLR3_UINT32 count; /* Current entry count */ - ANTLR3_BOOLEAN allowDups; /* Whether this trie accepts duplicate keys */ - - - pANTLR3_TRIE_ENTRY (*get) (struct ANTLR3_INT_TRIE_struct * trie, ANTLR3_INTKEY key); - ANTLR3_BOOLEAN (*del) (struct ANTLR3_INT_TRIE_struct * trie, ANTLR3_INTKEY key); - ANTLR3_BOOLEAN (*add) (struct ANTLR3_INT_TRIE_struct * trie, ANTLR3_INTKEY key, ANTLR3_UINT32 type, ANTLR3_INTKEY intVal, void * data, void (ANTLR3_CDECL *freeptr)(void *)); - void (*free) (struct ANTLR3_INT_TRIE_struct * trie); - -} - ANTLR3_INT_TRIE; - -/** - * A topological sort system that given a set of dependencies of a node m on node n, - * can sort them in dependency order. This is a generally useful utility object - * that does not care what the things are it is sorting. Generally the set - * to be sorted will be numeric indexes into some other structure such as an ANTLR3_VECTOR. - * I have provided a sort method that given ANTLR3_VECTOR as an input will sort - * the vector entries in place, as well as a sort method that just returns an - * array of the sorted noded indexes, in case you are not sorting ANTLR3_VECTORS but - * some set of your own device. - * - * Of the two main algorithms that could be used, I chose to use the depth first - * search for unvisited nodes as a) This runs in linear time, and b) it is what - * we used in the ANTLR Tool to perform a topological sort of the input grammar files - * based on their dependencies. - */ -typedef struct ANTLR3_TOPO_struct -{ - /** - * A vector of vectors of edges, built by calling the addEdge method() - * to indicate that node number n depends on node number m. Each entry in the vector - * contains a bitset, which has a bit index set for each node upon which the - * entry node depends. - */ - pANTLR3_BITSET * edges; - - /** - * A vector used to build up the sorted output order. Note that - * as the vector contains UINT32 then the maximum node index is - * 'limited' to 2^32, as nodes should be zero based. - */ - pANTLR3_UINT32 sorted; - - /** - * A vector used to detect cycles in the edge dependecies. It is used - * as a stack and each time we descend a node to one of its edges we - * add the node into this stack. If we find a node that we have already - * visited in the stack, then it means there wasa cycle such as 9->8->1->9 - * as the only way a node can be on the stack is if we are currently - * descnding from it as we remove it from the stack as we exit from - * descending its dependencies - */ - pANTLR3_UINT32 cycle; - - /** - * A flag that indicates the algorithm found a cycle in the edges - * such as 9->8->1->9 - * If this flag is set after you have called one of the sort routines - * then the detected cycle will be contained in the cycle array and - * cycleLimit will point to the one after the last entry in the cycle. - */ - ANTLR3_BOOLEAN hasCycle; - - /** - * A watermark used to accumulate potential cycles in the cycle array. - * This should be zero when we are done. Check hasCycle after calling one - * of the sort methods and if it is ANTLR3_TRUE then you can find the cycle - * in cycle[0]...cycle[cycleMark-1] - */ - ANTLR3_UINT32 cycleMark; - - /** - * One more than the largest node index that is contained in edges/sorted. - */ - ANTLR3_UINT32 limit; - - /** - * The set of visited nodes as determined by a set entry in - * the bitmap. - */ - pANTLR3_BITSET visited; - - /** - * A method that adds an edge from one node to another. An edge - * of n -> m indicates that node n is dependent on node m. Note that - * while building these edges, it is perfectly OK to add nodes out of - * sequence. So, if you have edges: - * - * 3 -> 0 - * 2 -> 1 - * 1 -> 3 - * - * The you can add them in that order and so add node 3 before nodes 2 and 1 - * - */ - void (*addEdge) (struct ANTLR3_TOPO_struct * topo, ANTLR3_UINT32 edge, ANTLR3_UINT32 dependency); - - - /** - * A method that returns a pointer to an array of sorted node indexes. - * The array is sorted in topological sorted order. Note that the array - * is only as large as the largest node index you created an edge for. This means - * that if you had an input of 32 nodes, but that largest node with an edge - * was 16, then the returned array will be the sorted order of the first 16 - * nodes and the last 16 nodes of your array are basically fine as they are - * as they had no dependencies and do not need any particular sort order. - * - * NB: If the structure that contains the array is freed, then the sorted - * array will be freed too so you should use the value of limit to - * make a long term copy of this array if you do not want to keep the topo - * structure around as well. - */ - pANTLR3_UINT32 (*sortToArray) (struct ANTLR3_TOPO_struct * topo); - - /** - * A method that sorts the supplied ANTLR3_VECTOR in place based - * on the previously supplied edge data. - */ - void (*sortVector) (struct ANTLR3_TOPO_struct * topo, pANTLR3_VECTOR v); - - /** - * A method to free this structure and any associated memory. - */ - void (*free) (struct ANTLR3_TOPO_struct * topo); -} - ANTLR3_TOPO; - -#ifdef __cplusplus -} -#endif - -#endif - - diff --git a/impl/antlr/libantlr3c-3.4/include/antlr3commontoken.h b/impl/antlr/libantlr3c-3.4/include/antlr3commontoken.h deleted file mode 100644 index c48068e..0000000 --- a/impl/antlr/libantlr3c-3.4/include/antlr3commontoken.h +++ /dev/null @@ -1,367 +0,0 @@ -/** \file - * \brief Defines the interface for a common token. - * - * All token streams should provide their tokens using an instance - * of this common token. A custom pointer is provided, wher you may attach - * a further structure to enhance the common token if you feel the need - * to do so. The C runtime will assume that a token provides implementations - * of the interface functions, but all of them may be rplaced by your own - * implementation if you require it. - */ -#ifndef _ANTLR3_COMMON_TOKEN_H -#define _ANTLR3_COMMON_TOKEN_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> - -/** How many tokens to allocate at once in the token factory - */ -#define ANTLR3_FACTORY_POOL_SIZE 1024 - -/* Base token types, which all lexer/parser tokens come after in sequence. - */ - -/** Indicator of an invalid token - */ -#define ANTLR3_TOKEN_INVALID 0 - -#define ANTLR3_EOR_TOKEN_TYPE 1 - -/** Imaginary token type to cause a traversal of child nodes in a tree parser - */ -#define ANTLR3_TOKEN_DOWN 2 - -/** Imaginary token type to signal the end of a stream of child nodes. - */ -#define ANTLR3_TOKEN_UP 3 - -/** First token that can be used by users/generated code - */ - -#define ANTLR3_MIN_TOKEN_TYPE ANTLR3_TOKEN_UP + 1 - -/** End of file token - */ -#define ANTLR3_TOKEN_EOF (ANTLR3_CHARSTREAM_EOF & 0xFFFFFFFF) - -/** Default channel for a token - */ -#define ANTLR3_TOKEN_DEFAULT_CHANNEL 0 - -/** Reserved channel number for a HIDDEN token - a token that - * is hidden from the parser. - */ -#define HIDDEN 99 - -#ifdef __cplusplus -extern "C" { -#endif - -// Indicates whether this token is carrying: -// -// State | Meaning -// ------+-------------------------------------- -// 0 | Nothing (neither rewrite text, nor setText) -// 1 | char * to user supplied rewrite text -// 2 | pANTLR3_STRING because of setText or similar action -// -#define ANTLR3_TEXT_NONE 0 -#define ANTLR3_TEXT_CHARP 1 -#define ANTLR3_TEXT_STRING 2 - -/** The definition of an ANTLR3 common token structure, which all implementations - * of a token stream should provide, installing any further structures in the - * custom pointer element of this structure. - * - * \remark - * Token streams are in essence provided by lexers or other programs that serve - * as lexers. - */ -typedef struct ANTLR3_COMMON_TOKEN_struct -{ - /** The actual type of this token - */ - ANTLR3_UINT32 type; - - /** Indicates that a token was produced from the token factory and therefore - * the the freeToken() method should not do anything itself because - * token factory is responsible for deleting it. - */ - ANTLR3_BOOLEAN factoryMade; - - /// A string factory that we can use if we ever need the text of a token - /// and need to manufacture a pANTLR3_STRING - /// - pANTLR3_STRING_FACTORY strFactory; - - /** The line number in the input stream where this token was derived from - */ - ANTLR3_UINT32 line; - - /** The offset into the input stream that the line in which this - * token resides starts. - */ - void * lineStart; - - /** The character position in the line that this token was derived from - */ - ANTLR3_INT32 charPosition; - - /** The virtual channel that this token exists in. - */ - ANTLR3_UINT32 channel; - - /** Pointer to the input stream that this token originated in. - */ - pANTLR3_INPUT_STREAM input; - - /** What the index of this token is, 0, 1, .., n-2, n-1 tokens - */ - ANTLR3_MARKER index; - - /** The character offset in the input stream where the text for this token - * starts. - */ - ANTLR3_MARKER start; - - /** The character offset in the input stream where the text for this token - * stops. - */ - ANTLR3_MARKER stop; - - /// Indicates whether this token is carrying: - /// - /// State | Meaning - /// ------+-------------------------------------- - /// 0 | Nothing (neither rewrite text, nor setText) - /// 1 | char * to user supplied rewrite text - /// 2 | pANTLR3_STRING because of setText or similar action - /// - /// Affects the union structure tokText below - /// (uses 32 bit so alignment is always good) - /// - ANTLR3_UINT32 textState; - - union - { - /// Pointer that is used when the token just has a pointer to - /// a char *, such as when a rewrite of an imaginary token supplies - /// a string in the grammar. No sense in constructing a pANTLR3_STRING just - /// for that, as mostly the text will not be accessed - if it is, then - /// we will build a pANTLR3_STRING for it a that point. - /// - pANTLR3_UCHAR chars; - - /// Some token types actually do carry around their associated text, hence - /// (*getText)() will return this pointer if it is not NULL - /// - pANTLR3_STRING text; - } - tokText; - - /** Because it is a bit more of a hassle to override an ANTLR3_COMMON_TOKEN - * as the standard structure for a token, a number of user programmable - * elements are allowed in a token. This is one of them. - */ - ANTLR3_UINT32 user1; - - /** Because it is a bit more of a hassle to override an ANTLR3_COMMON_TOKEN - * as the standard structure for a token, a number of user programmable - * elements are allowed in a token. This is one of them. - */ - ANTLR3_UINT32 user2; - - /** Because it is a bit more of a hassle to override an ANTLR3_COMMON_TOKEN - * as the standard structure for a token, a number of user programmable - * elements are allowed in a token. This is one of them. - */ - ANTLR3_UINT32 user3; - - /** Pointer to a custom element that the ANTLR3 programmer may define and install - */ - void * custom; - - /** Pointer to a function that knows how to free the custom structure when the - * token is destroyed. - */ - void (*freeCustom)(void * custom); - - /* ============================== - * API - */ - - /** Pointer to function that returns the text pointer of a token, use - * toString() if you want a pANTLR3_STRING version of the token. - */ - pANTLR3_STRING (*getText)(struct ANTLR3_COMMON_TOKEN_struct * token); - - /** Pointer to a function that 'might' be able to set the text associated - * with a token. Imaginary tokens such as an ANTLR3_CLASSIC_TOKEN may actually - * do this, however many tokens such as ANTLR3_COMMON_TOKEN do not actaully have - * strings associated with them but just point into the current input stream. These - * tokens will implement this function with a function that errors out (probably - * drastically. - */ - void (*setText)(struct ANTLR3_COMMON_TOKEN_struct * token, pANTLR3_STRING text); - - /** Pointer to a function that 'might' be able to set the text associated - * with a token. Imaginary tokens such as an ANTLR3_CLASSIC_TOKEN may actually - * do this, however many tokens such as ANTLR3_COMMON_TOKEN do not actully have - * strings associated with them but just point into the current input stream. These - * tokens will implement this function with a function that errors out (probably - * drastically. - */ - void (*setText8)(struct ANTLR3_COMMON_TOKEN_struct * token, pANTLR3_UINT8 text); - - /** Pointer to a function that returns the token type of this token - */ - ANTLR3_UINT32 (*getType)(struct ANTLR3_COMMON_TOKEN_struct * token); - - /** Pointer to a function that sets the type of this token - */ - void (*setType)(struct ANTLR3_COMMON_TOKEN_struct * token, ANTLR3_UINT32 ttype); - - /** Pointer to a function that gets the 'line' number where this token resides - */ - ANTLR3_UINT32 (*getLine)(struct ANTLR3_COMMON_TOKEN_struct * token); - - /** Pointer to a function that sets the 'line' number where this token reside - */ - void (*setLine)(struct ANTLR3_COMMON_TOKEN_struct * token, ANTLR3_UINT32 line); - - /** Pointer to a function that gets the offset in the line where this token exists - */ - ANTLR3_INT32 (*getCharPositionInLine) (struct ANTLR3_COMMON_TOKEN_struct * token); - - /** Pointer to a function that sets the offset in the line where this token exists - */ - void (*setCharPositionInLine) (struct ANTLR3_COMMON_TOKEN_struct * token, ANTLR3_INT32 pos); - - /** Pointer to a function that gets the channel that this token was placed in (parsers - * can 'tune' to these channels. - */ - ANTLR3_UINT32 (*getChannel) (struct ANTLR3_COMMON_TOKEN_struct * token); - - /** Pointer to a function that sets the channel that this token should belong to - */ - void (*setChannel) (struct ANTLR3_COMMON_TOKEN_struct * token, ANTLR3_UINT32 channel); - - /** Pointer to a function that returns an index 0...n-1 of the token in the token - * input stream. - */ - ANTLR3_MARKER (*getTokenIndex) (struct ANTLR3_COMMON_TOKEN_struct * token); - - /** Pointer to a function that can set the token index of this token in the token - * input stream. - */ - void (*setTokenIndex) (struct ANTLR3_COMMON_TOKEN_struct * token, ANTLR3_MARKER); - - /** Pointer to a function that gets the start index in the input stream for this token. - */ - ANTLR3_MARKER (*getStartIndex) (struct ANTLR3_COMMON_TOKEN_struct * token); - - /** Pointer to a function that sets the start index in the input stream for this token. - */ - void (*setStartIndex) (struct ANTLR3_COMMON_TOKEN_struct * token, ANTLR3_MARKER index); - - /** Pointer to a function that gets the stop index in the input stream for this token. - */ - ANTLR3_MARKER (*getStopIndex) (struct ANTLR3_COMMON_TOKEN_struct * token); - - /** Pointer to a function that sets the stop index in the input stream for this token. - */ - void (*setStopIndex) (struct ANTLR3_COMMON_TOKEN_struct * token, ANTLR3_MARKER index); - - /** Pointer to a function that returns this token as a text representation that can be - * printed with embedded control codes such as \n replaced with the printable sequence "\\n" - * This also yields a string structure that can be used more easily than the pointer to - * the input stream in certain situations. - */ - pANTLR3_STRING (*toString) (struct ANTLR3_COMMON_TOKEN_struct * token); -} - ANTLR3_COMMON_TOKEN; - -/** \brief ANTLR3 Token factory interface to create lots of tokens efficiently - * rather than creating and freeing lots of little bits of memory. - */ -typedef struct ANTLR3_TOKEN_FACTORY_struct -{ - /** Pointers to the array of tokens that this factory has produced so far - */ - pANTLR3_COMMON_TOKEN *pools; - - /** Current pool tokens we are allocating from - */ - ANTLR3_INT32 thisPool; - - /** Maximum pool count we have available - */ - ANTLR3_INT32 maxPool; - - /** The next token to throw out from the pool, will cause a new pool allocation - * if this exceeds the available tokenCount - */ - ANTLR3_UINT32 nextToken; - - /** Trick to initialize tokens and their API quickly, we set up this token when the - * factory is created, then just copy the memory it uses into the new token. - */ - ANTLR3_COMMON_TOKEN unTruc; - - /** Pointer to an input stream that is using this token factory (may be NULL) - * which will be assigned to the tokens automatically. - */ - pANTLR3_INPUT_STREAM input; - - /** Pointer to a function that returns a new token - */ - pANTLR3_COMMON_TOKEN (*newToken) (struct ANTLR3_TOKEN_FACTORY_struct * factory); - - /** Pointer to a function that resets the factory so you can reuse the pools it - * has laready allocated - */ - void (*reset) (struct ANTLR3_TOKEN_FACTORY_struct * factory); - - /** Pointer to a function that changes teh curent inptu stream so that - * new tokens are created with reference to their originating text. - */ - void (*setInputStream) (struct ANTLR3_TOKEN_FACTORY_struct * factory, pANTLR3_INPUT_STREAM input); - /** Pointer to a function the destroys the factory - */ - void (*close) (struct ANTLR3_TOKEN_FACTORY_struct * factory); -} - ANTLR3_TOKEN_FACTORY; - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/impl/antlr/libantlr3c-3.4/include/antlr3commontree.h b/impl/antlr/libantlr3c-3.4/include/antlr3commontree.h deleted file mode 100644 index 1516ecc..0000000 --- a/impl/antlr/libantlr3c-3.4/include/antlr3commontree.h +++ /dev/null @@ -1,167 +0,0 @@ -/** Interface for an ANTLR3 common tree which is what gets - * passed around by the AST producing parser. - */ - -#ifndef _ANTLR3_COMMON_TREE_H -#define _ANTLR3_COMMON_TREE_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 <antlr3basetree.h> -#include <antlr3commontoken.h> - -#ifdef __cplusplus -extern "C" { -#endif - -typedef struct ANTLR3_COMMON_TREE_struct -{ - - /// Not used by ANTLR, but if a super structure is created above - /// this structure, it can be used to point to the start of the super - /// structure, where additional data and function pointers can be stored. - /// - void * super; - - /// Start token index that encases this tree - /// - ANTLR3_MARKER startIndex; - - /// End token that encases this tree - /// - ANTLR3_MARKER stopIndex; - - /// A single token, this is the payload for the tree - /// - pANTLR3_COMMON_TOKEN token; - - /// Points to the node that has this node as a child. - /// If this is NULL, then this is the root node. - /// - pANTLR3_COMMON_TREE parent; - - /// What index is this particular node in the child list it - /// belongs to? - /// - ANTLR3_INT32 childIndex; - - /// Pointer to the tree factory that manufactured this - /// token. This can be used by duplication methods and so on - /// to manufacture another auto-tracked common tree structure - /// - pANTLR3_ARBORETUM factory; - - /// An encapsulated BASE TREE structure (NOT a pointer) - /// that performs a lot of the dirty work of node management - /// To this we add just a few functions that are specific to the - /// payload. You can further abstract common tree so long - /// as you always have a baseTree pointer in the top structure - /// and copy it from the next one down. - /// So, lets say we have a structure JIMS_TREE. - /// It needs an ANTLR3_BASE_TREE that will support all the - /// general tree duplication stuff. - /// It needs a ANTLR3_COMMON_TREE structure embedded or completely - /// provides the equivalent interface. - /// It provides it's own methods and data. - /// To create a new one of these, the function provided to - /// the tree adaptor (see comments there) should allocate the - /// memory for a new JIMS_TREE structure, then call - /// antlr3InitCommonTree(<addressofembeddedCOMMON_TREE>) - /// antlr3BaseTreeNew(<addressofBASETREE>) - /// The interfaces for BASE_TREE and COMMON_TREE will then - /// be initialized. You then call and you can override them or just init - /// JIMS_TREE (note that the base tree in common tree will be ignored) - /// just the top level base tree is used). Codegen will take care of the rest. - /// - ANTLR3_BASE_TREE baseTree; - -} - ANTLR3_COMMON_TREE; - -/// \brief ANTLR3 Tree factory interface to create lots of trees efficiently -/// rather than creating and freeing lots of little bits of memory. -/// -typedef struct ANTLR3_ARBORETUM_struct -{ - /// Pointers to the array of tokens that this factory has produced so far - /// - pANTLR3_COMMON_TREE *pools; - - /// Current pool tokens we are allocating from - /// - ANTLR3_INT32 thisPool; - - /// The next token to throw out from the pool, will cause a new pool allocation - /// if this exceeds the available tokenCount - /// - ANTLR3_UINT32 nextTree; - - /// Trick to initialize tokens and their API quickly, we set up this token when the - /// factory is created, then just copy the memory it uses into the new token. - /// - ANTLR3_COMMON_TREE unTruc; - - /// Pointer to a vector factory that is used to create child list vectors - /// for any child nodes that need them. This means that we auto track the - /// vectors and auto free them when we close the factory. It also means - /// that all rewriting trees can use the same tree factory and the same - /// vector factory and we do not dup any nodes unless we must do so - /// explicitly because of context such as an empty rewrite stream and - /// ->IMAGINARY[ID] so on. This makes memory tracking much simpler and - /// tempts no errors. - /// - pANTLR3_VECTOR_FACTORY vFactory; - - /// A resuse stack for reclaiming Nil nodes that were used in rewrites - /// and are now dead. The nilNode() method will eat one of these before - /// creating a new node. - /// - pANTLR3_STACK nilStack; - - /// Pointer to a function that returns a new tree - /// - pANTLR3_BASE_TREE (*newTree) (struct ANTLR3_ARBORETUM_struct * factory); - pANTLR3_BASE_TREE (*newFromTree) (struct ANTLR3_ARBORETUM_struct * factory, pANTLR3_COMMON_TREE tree); - pANTLR3_BASE_TREE (*newFromToken) (struct ANTLR3_ARBORETUM_struct * factory, pANTLR3_COMMON_TOKEN token); - - /// Pointer to a function the destroys the factory - /// - void (*close) (struct ANTLR3_ARBORETUM_struct * factory); -} - ANTLR3_ARBORETUM; - -#ifdef __cplusplus -} -#endif - -#endif - - diff --git a/impl/antlr/libantlr3c-3.4/include/antlr3commontreeadaptor.h b/impl/antlr/libantlr3c-3.4/include/antlr3commontreeadaptor.h deleted file mode 100644 index 4827997..0000000 --- a/impl/antlr/libantlr3c-3.4/include/antlr3commontreeadaptor.h +++ /dev/null @@ -1,70 +0,0 @@ -/** \file - * Definition of the ANTLR3 common tree adaptor. - */ - -#ifndef _ANTLR3_COMMON_TREE_ADAPTOR_H -#define _ANTLR3_COMMON_TREE_ADAPTOR_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 <antlr3collections.h> -#include <antlr3string.h> -#include <antlr3basetreeadaptor.h> -#include <antlr3commontree.h> -#include <antlr3debugeventlistener.h> - -#ifdef __cplusplus -extern "C" { -#endif - -typedef struct ANTLR3_COMMON_TREE_ADAPTOR_struct -{ - /** Any enclosing structure/class can use this pointer to point to its own interface. - */ - void * super; - - /** Base interface implementation, embedded structure - */ - ANTLR3_TREE_ADAPTOR baseAdaptor; - - /** Tree factory for producing new nodes as required without needing to track - * memory allocation per node. - */ - pANTLR3_ARBORETUM arboretum; - -} - ANTLR3_COMMON_TREE_ADAPTOR; - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/impl/antlr/libantlr3c-3.4/include/antlr3commontreenodestream.h b/impl/antlr/libantlr3c-3.4/include/antlr3commontreenodestream.h deleted file mode 100644 index beb0534..0000000 --- a/impl/antlr/libantlr3c-3.4/include/antlr3commontreenodestream.h +++ /dev/null @@ -1,336 +0,0 @@ -/// \file -/// Definition of the ANTLR3 common tree node stream. -/// - -#ifndef _ANTLR3_COMMON_TREE_NODE_STREAM__H -#define _ANTLR3_COMMON_TREE_NODE_STREAM__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 <antlr3commontreeadaptor.h> -#include <antlr3commontree.h> -#include <antlr3collections.h> -#include <antlr3intstream.h> -#include <antlr3string.h> - -/// Token buffer initial size settings ( will auto increase) -/// -#define DEFAULT_INITIAL_BUFFER_SIZE 100 -#define INITIAL_CALL_STACK_SIZE 10 - -#ifdef __cplusplus -extern "C" { -#endif - -typedef struct ANTLR3_TREE_NODE_STREAM_struct -{ - /// Any interface that implements this interface (is a - /// super structure containing this structure), may store the pointer - /// to itself here in the super pointer, which is not used by - /// the tree node stream. This will point to an implementation - /// of ANTLR3_COMMON_TREE_NODE_STREAM in this case. - /// - pANTLR3_COMMON_TREE_NODE_STREAM ctns; - - /// All input streams implement the ANTLR3_INT_STREAM interface... - /// - pANTLR3_INT_STREAM istream; - - /// Get tree node at current input pointer + i ahead where i=1 is next node. - /// i<0 indicates nodes in the past. So LT(-1) is previous node, but - /// implementations are not required to provide results for k < -1. - /// LT(0) is undefined. For i>=n, return null. - /// Return NULL for LT(0) and any index that results in an absolute address - /// that is negative (beyond the start of the list). - /// - /// This is analogous to the LT() method of the TokenStream, but this - /// returns a tree node instead of a token. Makes code gen identical - /// for both parser and tree grammars. :) - /// - pANTLR3_BASE_TREE (*_LT) (struct ANTLR3_TREE_NODE_STREAM_struct * tns, ANTLR3_INT32 k); - - /// Where is this stream pulling nodes from? This is not the name, but - /// the object that provides node objects. - /// - pANTLR3_BASE_TREE (*getTreeSource) (struct ANTLR3_TREE_NODE_STREAM_struct * tns); - - /// What adaptor can tell me how to interpret/navigate nodes and - /// trees. E.g., get text of a node. - /// - pANTLR3_BASE_TREE_ADAPTOR (*getTreeAdaptor) (struct ANTLR3_TREE_NODE_STREAM_struct * tns); - - /// As we flatten the tree, we use UP, DOWN nodes to represent - /// the tree structure. When debugging we need unique nodes - /// so we have to instantiate new ones. When doing normal tree - /// parsing, it's slow and a waste of memory to create unique - /// navigation nodes. Default should be false; - /// - void (*setUniqueNavigationNodes) (struct ANTLR3_TREE_NODE_STREAM_struct * tns, ANTLR3_BOOLEAN uniqueNavigationNodes); - - pANTLR3_STRING (*toString) (struct ANTLR3_TREE_NODE_STREAM_struct * tns); - - /// Return the text of all nodes from start to stop, inclusive. - /// If the stream does not buffer all the nodes then it can still - /// walk recursively from start until stop. You can always return - /// null or "" too, but users should not access $ruleLabel.text in - /// an action of course in that case. - /// - pANTLR3_STRING (*toStringSS) (struct ANTLR3_TREE_NODE_STREAM_struct * tns, pANTLR3_BASE_TREE start, pANTLR3_BASE_TREE stop); - - /// Return the text of all nodes from start to stop, inclusive, into the - /// supplied buffer. - /// If the stream does not buffer all the nodes then it can still - /// walk recursively from start until stop. You can always return - /// null or "" too, but users should not access $ruleLabel.text in - /// an action of course in that case. - /// - void (*toStringWork) (struct ANTLR3_TREE_NODE_STREAM_struct * tns, pANTLR3_BASE_TREE start, pANTLR3_BASE_TREE stop, pANTLR3_STRING buf); - - /// Release up any and all space the the interface allocate, including for this structure. - /// - void (*free) (struct ANTLR3_TREE_NODE_STREAM_struct * tns); - - /// Get a tree node at an absolute index i; 0..n-1. - /// If you don't want to buffer up nodes, then this method makes no - /// sense for you. - /// - pANTLR3_BASE_TREE (*get) (struct ANTLR3_TREE_NODE_STREAM_struct * tns, ANTLR3_INT32 i); - - // REWRITING TREES (used by tree parser) - - /// Replace from start to stop child index of parent with t, which might - /// be a list. Number of children may be different - /// after this call. The stream is notified because it is walking the - /// tree and might need to know you are monkeying with the underlying - /// tree. Also, it might be able to modify the node stream to avoid - /// restreaming for future phases. - /// - /// If parent is null, don't do anything; must be at root of overall tree. - /// Can't replace whatever points to the parent externally. Do nothing. - /// - void (*replaceChildren) (struct ANTLR3_TREE_NODE_STREAM_struct * tns, pANTLR3_BASE_TREE parent, ANTLR3_INT32 startChildIndex, ANTLR3_INT32 stopChildIndex, pANTLR3_BASE_TREE t); - -} - ANTLR3_TREE_NODE_STREAM; - -typedef struct ANTLR3_COMMON_TREE_NODE_STREAM_struct -{ - /// Any interface that implements this interface (is a - /// super structure containing this structure), may store the pointer - /// to itself here in the super pointer, which is not used by - /// the common tree node stream. - /// - void * super; - - /// Pointer to the tree node stream interface - /// - pANTLR3_TREE_NODE_STREAM tnstream; - - /// String factory for use by anything that wishes to create strings - /// such as a tree representation or some copy of the text etc. - /// - pANTLR3_STRING_FACTORY stringFactory; - - /// Dummy tree node that indicates a descent into a child - /// tree. Initialized by a call to create a new interface. - /// - ANTLR3_COMMON_TREE DOWN; - - /// Dummy tree node that indicates a descent up to a parent - /// tree. Initialized by a call to create a new interface. - /// - ANTLR3_COMMON_TREE UP; - - /// Dummy tree node that indicates the termination point of the - /// tree. Initialized by a call to create a new interface. - /// - ANTLR3_COMMON_TREE EOF_NODE; - - /// Dummy node that is returned if we need to indicate an invalid node - /// for any reason. - /// - ANTLR3_COMMON_TREE INVALID_NODE; - - /// The complete mapping from stream index to tree node. - /// This buffer includes pointers to DOWN, UP, and EOF nodes. - /// It is built upon ctor invocation. The elements are type - /// Object as we don't what the trees look like. - /// - /// Load upon first need of the buffer so we can set token types - /// of interest for reverseIndexing. Slows us down a wee bit to - /// do all of the if p==-1 testing everywhere though, though in C - /// you won't really be able to measure this. - /// - /// Must be freed when the tree node stream is torn down. - /// - pANTLR3_VECTOR nodes; - - /// If set to ANTLR3_TRUE then the navigation nodes UP, DOWN are - /// duplicated rather than reused within the tree. - /// - ANTLR3_BOOLEAN uniqueNavigationNodes; - - /// Which tree are we navigating ? - /// - pANTLR3_BASE_TREE root; - - /// Pointer to tree adaptor interface that manipulates/builds - /// the tree. - /// - pANTLR3_BASE_TREE_ADAPTOR adaptor; - - /// As we walk down the nodes, we must track parent nodes so we know - /// where to go after walking the last child of a node. When visiting - /// a child, push current node and current index (current index - /// is first stored in the tree node structure to avoid two stacks. - /// - pANTLR3_STACK nodeStack; - - /// The current index into the nodes vector of the current tree - /// we are parsing and possibly rewriting. - /// - ANTLR3_INT32 p; - - /// Which node are we currently visiting? - /// - pANTLR3_BASE_TREE currentNode; - - /// Which node did we last visit? Used for LT(-1) - /// - pANTLR3_BASE_TREE previousNode; - - /// Which child are we currently visiting? If -1 we have not visited - /// this node yet; next consume() request will set currentIndex to 0. - /// - ANTLR3_INT32 currentChildIndex; - - /// What node index did we just consume? i=0..n-1 for n node trees. - /// IntStream.next is hence 1 + this value. Size will be same. - /// - ANTLR3_MARKER absoluteNodeIndex; - - /// Buffer tree node stream for use with LT(i). This list grows - /// to fit new lookahead depths, but consume() wraps like a circular - /// buffer. - /// - pANTLR3_BASE_TREE * lookAhead; - - /// Number of elements available in the lookahead buffer at any point in - /// time. This is the current size of the array. - /// - ANTLR3_UINT32 lookAheadLength; - - /// lookAhead[head] is the first symbol of lookahead, LT(1). - /// - ANTLR3_UINT32 head; - - /// Add new lookahead at lookahead[tail]. tail wraps around at the - /// end of the lookahead buffer so tail could be less than head. - /// - ANTLR3_UINT32 tail; - - /// Calls to mark() may be nested so we have to track a stack of - /// them. The marker is an index into this stack. Index 0 is - /// the first marker. This is a List<TreeWalkState> - /// - pANTLR3_VECTOR markers; - - // INTERFACE - // - void (*fill) (struct ANTLR3_COMMON_TREE_NODE_STREAM_struct * ctns, ANTLR3_INT32 k); - - void (*addLookahead) (struct ANTLR3_COMMON_TREE_NODE_STREAM_struct * ctns, pANTLR3_BASE_TREE node); - - ANTLR3_BOOLEAN (*hasNext) (struct ANTLR3_COMMON_TREE_NODE_STREAM_struct * ctns); - - pANTLR3_BASE_TREE (*next) (struct ANTLR3_COMMON_TREE_NODE_STREAM_struct * ctns); - - pANTLR3_BASE_TREE (*handleRootnode) (struct ANTLR3_COMMON_TREE_NODE_STREAM_struct * ctns); - - pANTLR3_BASE_TREE (*visitChild) (struct ANTLR3_COMMON_TREE_NODE_STREAM_struct * ctns, ANTLR3_UINT32 child); - - void (*addNavigationNode) (struct ANTLR3_COMMON_TREE_NODE_STREAM_struct * ctns, ANTLR3_UINT32 ttype); - - pANTLR3_BASE_TREE (*newDownNode) (struct ANTLR3_COMMON_TREE_NODE_STREAM_struct * ctns); - - pANTLR3_BASE_TREE (*newUpNode) (struct ANTLR3_COMMON_TREE_NODE_STREAM_struct * ctns); - - void (*walkBackToMostRecentNodeWithUnvisitedChildren) - (struct ANTLR3_COMMON_TREE_NODE_STREAM_struct * ctns); - - ANTLR3_BOOLEAN (*hasUniqueNavigationNodes) (struct ANTLR3_COMMON_TREE_NODE_STREAM_struct * ctns); - - ANTLR3_UINT32 (*getLookaheadSize) (struct ANTLR3_COMMON_TREE_NODE_STREAM_struct * ctns); - - void (*push) (struct ANTLR3_COMMON_TREE_NODE_STREAM_struct * ctns, ANTLR3_INT32 index); - - ANTLR3_INT32 (*pop) (struct ANTLR3_COMMON_TREE_NODE_STREAM_struct * ctns); - - void (*reset) (struct ANTLR3_COMMON_TREE_NODE_STREAM_struct * ctns); - - void (*free) (struct ANTLR3_COMMON_TREE_NODE_STREAM_struct * ctns); - - /// Indicates whether this node stream was derived from a prior - /// node stream to be used by a rewriting tree parser for instance. - /// If this flag is set to ANTLR3_TRUE, then when this stream is - /// closed it will not free the root tree as this tree always - /// belongs to the origniating node stream. - /// - ANTLR3_BOOLEAN isRewriter; - -} - ANTLR3_COMMON_TREE_NODE_STREAM; - -/** This structure is used to save the state information in the treenodestream - * when walking ahead with cyclic DFA or for syntactic predicates, - * we need to record the state of the tree node stream. This - * class wraps up the current state of the CommonTreeNodeStream. - * Calling mark() will push another of these on the markers stack. - */ -typedef struct ANTLR3_TREE_WALK_STATE_struct -{ - ANTLR3_UINT32 currentChildIndex; - ANTLR3_MARKER absoluteNodeIndex; - pANTLR3_BASE_TREE currentNode; - pANTLR3_BASE_TREE previousNode; - ANTLR3_UINT32 nodeStackSize; - pANTLR3_BASE_TREE * lookAhead; - ANTLR3_UINT32 lookAheadLength; - ANTLR3_UINT32 tail; - ANTLR3_UINT32 head; -} - ANTLR3_TREE_WALK_STATE; - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/impl/antlr/libantlr3c-3.4/include/antlr3convertutf.h b/impl/antlr/libantlr3c-3.4/include/antlr3convertutf.h deleted file mode 100644 index 79cc82c..0000000 --- a/impl/antlr/libantlr3c-3.4/include/antlr3convertutf.h +++ /dev/null @@ -1,176 +0,0 @@ -/* - * Copyright 2001-2004 Unicode, Inc. - * - * Disclaimer - * - * This source code is provided as is by Unicode, Inc. No claims are - * made as to fitness for any particular purpose. No warranties of any - * kind are expressed or implied. The recipient agrees to determine - * applicability of information provided. If this file has been - * purchased on magnetic or optical media from Unicode, Inc., the - * sole remedy for any claim will be exchange of defective media - * within 90 days of receipt. - * - * Limitations on Rights to Redistribute This Code - * - * Unicode, Inc. hereby grants the right to freely use the information - * supplied in this file in the creation of products supporting the - * Unicode Standard, and to make copies of this file in any form - * for internal or external distribution as long as this notice - * remains attached. - */ - -/* --------------------------------------------------------------------- - - Conversions between UTF32, UTF-16, and UTF-8. Header file. - - Several functions are included here, forming a complete set of - conversions between the three formats. UTF-7 is not included - here, but is handled in a separate source file. - - Each of these routines takes pointers to input buffers and output - buffers. The input buffers are const. - - Each routine converts the text between *sourceStart and sourceEnd, - putting the result into the buffer between *targetStart and - targetEnd. Note: the end pointers are *after* the last item: e.g. - *(sourceEnd - 1) is the last item. - - The return result indicates whether the conversion was successful, - and if not, whether the problem was in the source or target buffers. - (Only the first encountered problem is indicated.) - - After the conversion, *sourceStart and *targetStart are both - updated to point to the end of last text successfully converted in - the respective buffers. - - Input parameters: - sourceStart - pointer to a pointer to the source buffer. - The contents of this are modified on return so that - it points at the next thing to be converted. - targetStart - similarly, pointer to pointer to the target buffer. - sourceEnd, targetEnd - respectively pointers to the ends of the - two buffers, for overflow checking only. - - These conversion functions take a ConversionFlags argument. When this - flag is set to strict, both irregular sequences and isolated surrogates - will cause an error. When the flag is set to lenient, both irregular - sequences and isolated surrogates are converted. - - Whether the flag is strict or lenient, all illegal sequences will cause - an error return. This includes sequences such as: <F4 90 80 80>, <C0 80>, - or <A0> in UTF-8, and values above 0x10FFFF in UTF-32. Conformant code - must check for illegal sequences. - - When the flag is set to lenient, characters over 0x10FFFF are converted - to the replacement character; otherwise (when the flag is set to strict) - they constitute an error. - - Output parameters: - The value "sourceIllegal" is returned from some routines if the input - sequence is malformed. When "sourceIllegal" is returned, the source - value will point to the illegal value that caused the problem. E.g., - in UTF-8 when a sequence is malformed, it points to the start of the - malformed sequence. - - Author: Mark E. Davis, 1994. - Rev History: Rick McGowan, fixes & updates May 2001. - Fixes & updates, Sept 2001. - ------------------------------------------------------------------------- */ - -/* --------------------------------------------------------------------- - The following 4 definitions are compiler-specific. - The C standard does not guarantee that wchar_t has at least - 16 bits, so wchar_t is no less portable than unsigned short! - All should be unsigned values to avoid sign extension during - bit mask & shift operations. ------------------------------------------------------------------------- */ - - -// Changes for ANTLR3 - Jim Idle, January 2008. -// builtin types defined for Unicode types changed to -// aliases for the types that are system determined by -// ANTLR at compile time. -// -// typedef unsigned long UTF32; /* at least 32 bits */ -// typedef unsigned short UTF16; /* at least 16 bits */ -// typedef unsigned char UTF8; /* typically 8 bits */ -// typedef unsigned char Boolean; /* 0 or 1 */ - -#ifndef _ANTLR3_CONVERTUTF_H -#define _ANTLR3_CONVERTUTF_H - -#include <antlr3defs.h> - -typedef ANTLR3_UINT32 UTF32; /* at least 32 bits */ -typedef ANTLR3_UINT16 UTF16; /* at least 16 bits */ -typedef ANTLR3_UINT8 UTF8; /* typically 8 bits */ - -/* Some fundamental constants */ -#define UNI_REPLACEMENT_CHAR (UTF32)0x0000FFFD -#define UNI_MAX_BMP (UTF32)0x0000FFFF -#define UNI_MAX_UTF16 (UTF32)0x0010FFFF -#define UNI_MAX_UTF32 (UTF32)0x7FFFFFFF -#define UNI_MAX_LEGAL_UTF32 (UTF32)0x0010FFFF - -#define UNI_SUR_HIGH_START (UTF32)0xD800 -#define UNI_SUR_HIGH_END (UTF32)0xDBFF -#define UNI_SUR_LOW_START (UTF32)0xDC00 -#define UNI_SUR_LOW_END (UTF32)0xDFFF -#define false ANTLR3_FALSE -#define true ANTLR3_TRUE -#define halfShift ((UTF32)10) -#define halfBase ((UTF32)0x0010000UL) -#define halfMask ((UTF32)0x3FFUL) - -typedef enum { - conversionOK, /* conversion successful */ - sourceExhausted, /* partial character in source, but hit end */ - targetExhausted, /* insuff. room in target for conversion */ - sourceIllegal /* source sequence is illegal/malformed */ -} ConversionResult; - -typedef enum { - strictConversion = 0, - lenientConversion -} ConversionFlags; - -/* This is for C++ and does no harm in C */ -#ifdef __cplusplus -extern "C" { -#endif - -ConversionResult ConvertUTF8toUTF16 ( - const UTF8** sourceStart, const UTF8* sourceEnd, - UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags); - -ConversionResult ConvertUTF16toUTF8 ( - const UTF16** sourceStart, const UTF16* sourceEnd, - UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags); - -ConversionResult ConvertUTF8toUTF32 ( - const UTF8** sourceStart, const UTF8* sourceEnd, - UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags); - -ConversionResult ConvertUTF32toUTF8 ( - const UTF32** sourceStart, const UTF32* sourceEnd, - UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags); - -ConversionResult ConvertUTF16toUTF32 ( - const UTF16** sourceStart, const UTF16* sourceEnd, - UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags); - -ConversionResult ConvertUTF32toUTF16 ( - const UTF32** sourceStart, const UTF32* sourceEnd, - UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags); - -ANTLR3_BOOLEAN isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd); - -#ifdef __cplusplus -} -#endif - -#endif - -/* --------------------------------------------------------------------- */ diff --git a/impl/antlr/libantlr3c-3.4/include/antlr3cyclicdfa.h b/impl/antlr/libantlr3c-3.4/include/antlr3cyclicdfa.h deleted file mode 100644 index 78708a0..0000000 --- a/impl/antlr/libantlr3c-3.4/include/antlr3cyclicdfa.h +++ /dev/null @@ -1,97 +0,0 @@ -/// Definition of a cyclic dfa structure such that it can be -/// initialized at compile time and have only a single -/// runtime function that can deal with all cyclic dfa -/// structures and show Java how it is done ;-) -/// -#ifndef ANTLR3_CYCLICDFA_H -#define ANTLR3_CYCLICDFA_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 <antlr3baserecognizer.h> -#include <antlr3intstream.h> - -#ifdef __cplusplus -extern "C" { - -// If this header file is included as part of a generated recognizer that -// is being compiled as if it were C++, and this is Windows, then the const elements -// of the structure cause the C++ compiler to (rightly) point out that -// there can be no instantiation of the structure because it needs a constructor -// that can initialize the data, however these structures are not -// useful for C++ as they are pre-generated and static in the recognizer. -// So, we turn off those warnings, which are only at /W4 anyway. -// -#ifdef ANTLR3_WINDOWS -#pragma warning (push) -#pragma warning (disable : 4510) -#pragma warning (disable : 4512) -#pragma warning (disable : 4610) -#endif -#endif - -typedef struct ANTLR3_CYCLIC_DFA_struct -{ - /// Decision number that a particular static structure - /// represents. - /// - const ANTLR3_INT32 decisionNumber; - - /// What this decision represents - /// - const pANTLR3_UCHAR description; - - ANTLR3_INT32 (*specialStateTransition) (void * ctx, pANTLR3_BASE_RECOGNIZER recognizer, pANTLR3_INT_STREAM is, struct ANTLR3_CYCLIC_DFA_struct * dfa, ANTLR3_INT32 s); - - ANTLR3_INT32 (*specialTransition) (void * ctx, pANTLR3_BASE_RECOGNIZER recognizer, pANTLR3_INT_STREAM is, struct ANTLR3_CYCLIC_DFA_struct * dfa, ANTLR3_INT32 s); - - ANTLR3_INT32 (*predict) (void * ctx, pANTLR3_BASE_RECOGNIZER recognizer, pANTLR3_INT_STREAM is, struct ANTLR3_CYCLIC_DFA_struct * dfa); - - const ANTLR3_INT32 * const eot; - const ANTLR3_INT32 * const eof; - const ANTLR3_INT32 * const min; - const ANTLR3_INT32 * const max; - const ANTLR3_INT32 * const accept; - const ANTLR3_INT32 * const special; - const ANTLR3_INT32 * const * const transition; - -} - ANTLR3_CYCLIC_DFA; - -typedef ANTLR3_INT32 (*CDFA_SPECIAL_FUNC) (void * , pANTLR3_BASE_RECOGNIZER , pANTLR3_INT_STREAM , struct ANTLR3_CYCLIC_DFA_struct * , ANTLR3_INT32); - -#ifdef __cplusplus -} -#ifdef ANTLR3_WINDOWS -#pragma warning (pop) -#endif -#endif - -#endif diff --git a/impl/antlr/libantlr3c-3.4/include/antlr3debugeventlistener.h b/impl/antlr/libantlr3c-3.4/include/antlr3debugeventlistener.h deleted file mode 100644 index c9cd6ce..0000000 --- a/impl/antlr/libantlr3c-3.4/include/antlr3debugeventlistener.h +++ /dev/null @@ -1,398 +0,0 @@ -/** - * \file - * The definition of all debugging events that a recognizer can trigger. - * - * \remark - * From the java implementation by Terence Parr... - * I did not create a separate AST debugging interface as it would create - * lots of extra classes and DebugParser has a dbg var defined, which makes - * it hard to change to ASTDebugEventListener. I looked hard at this issue - * and it is easier to understand as one monolithic event interface for all - * possible events. Hopefully, adding ST debugging stuff won't be bad. Leave - * for future. 4/26/2006. - */ - -#ifndef ANTLR3_DEBUG_EVENT_LISTENER_H -#define ANTLR3_DEBUG_EVENT_LISTENER_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 <antlr3basetree.h> -#include <antlr3commontoken.h> - - -/// Default debugging port -/// -#define DEFAULT_DEBUGGER_PORT 0xBFCC; - -#ifdef __cplusplus -extern "C" { -#endif - -/** The ANTLR3 debugging interface for communicating with ANLTR Works. Function comments - * mostly taken from the Java version. - */ -typedef struct ANTLR3_DEBUG_EVENT_LISTENER_struct -{ - /// The port number which the debug listener should listen on for a connection - /// - ANTLR3_UINT32 port; - - /// The socket structure we receive after a successful accept on the serverSocket - /// - SOCKET socket; - - /** The version of the debugging protocol supported by the providing - * instance of the debug event listener. - */ - int PROTOCOL_VERSION; - - /// The name of the grammar file that we are debugging - /// - pANTLR3_STRING grammarFileName; - - /// Indicates whether we have already connected or not - /// - ANTLR3_BOOLEAN initialized; - - /// Used to serialize the values of any particular token we need to - /// send back to the debugger. - /// - pANTLR3_STRING tokenString; - - - /// Allows the debug event system to access the adapter in use - /// by the recognizer, if this is a tree parser of some sort. - /// - pANTLR3_BASE_TREE_ADAPTOR adaptor; - - /// Wait for a connection from the debugger and initiate the - /// debugging session. - /// - ANTLR3_BOOLEAN (*handshake) (pANTLR3_DEBUG_EVENT_LISTENER delboy); - - /** The parser has just entered a rule. No decision has been made about - * which alt is predicted. This is fired AFTER init actions have been - * executed. Attributes are defined and available etc... - */ - void (*enterRule) (pANTLR3_DEBUG_EVENT_LISTENER delboy, const char * grammarFileName, const char * ruleName); - - /** Because rules can have lots of alternatives, it is very useful to - * know which alt you are entering. This is 1..n for n alts. - */ - void (*enterAlt) (pANTLR3_DEBUG_EVENT_LISTENER delboy, int alt); - - /** This is the last thing executed before leaving a rule. It is - * executed even if an exception is thrown. This is triggered after - * error reporting and recovery have occurred (unless the exception is - * not caught in this rule). This implies an "exitAlt" event. - */ - void (*exitRule) (pANTLR3_DEBUG_EVENT_LISTENER delboy, const char * grammarFileName, const char * ruleName); - - /** Track entry into any (...) subrule other EBNF construct - */ - void (*enterSubRule) (pANTLR3_DEBUG_EVENT_LISTENER delboy, int decisionNumber); - - void (*exitSubRule) (pANTLR3_DEBUG_EVENT_LISTENER delboy, int decisionNumber); - - /** Every decision, fixed k or arbitrary, has an enter/exit event - * so that a GUI can easily track what LT/consume events are - * associated with prediction. You will see a single enter/exit - * subrule but multiple enter/exit decision events, one for each - * loop iteration. - */ - void (*enterDecision) (pANTLR3_DEBUG_EVENT_LISTENER delboy, int decisionNumber); - - void (*exitDecision) (pANTLR3_DEBUG_EVENT_LISTENER delboy, int decisionNumber); - - /** An input token was consumed; matched by any kind of element. - * Trigger after the token was matched by things like match(), matchAny(). - */ - void (*consumeToken) (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_COMMON_TOKEN t); - - /** An off-channel input token was consumed. - * Trigger after the token was matched by things like match(), matchAny(). - * (unless of course the hidden token is first stuff in the input stream). - */ - void (*consumeHiddenToken) (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_COMMON_TOKEN t); - - /** Somebody (anybody) looked ahead. Note that this actually gets - * triggered by both LA and LT calls. The debugger will want to know - * which Token object was examined. Like consumeToken, this indicates - * what token was seen at that depth. A remote debugger cannot look - * ahead into a file it doesn't have so LT events must pass the token - * even if the info is redundant. - */ - void (*LT) (pANTLR3_DEBUG_EVENT_LISTENER delboy, int i, pANTLR3_COMMON_TOKEN t); - - /** The parser is going to look arbitrarily ahead; mark this location, - * the token stream's marker is sent in case you need it. - */ - void (*mark) (pANTLR3_DEBUG_EVENT_LISTENER delboy, ANTLR3_MARKER marker); - - /** After an arbitrarily long lookahead as with a cyclic DFA (or with - * any backtrack), this informs the debugger that stream should be - * rewound to the position associated with marker. - */ - void (*rewind) (pANTLR3_DEBUG_EVENT_LISTENER delboy, ANTLR3_MARKER marker); - - /** Rewind to the input position of the last marker. - * Used currently only after a cyclic DFA and just - * before starting a sem/syn predicate to get the - * input position back to the start of the decision. - * Do not "pop" the marker off the state. mark(i) - * and rewind(i) should balance still. - */ - void (*rewindLast) (pANTLR3_DEBUG_EVENT_LISTENER delboy); - - void (*beginBacktrack) (pANTLR3_DEBUG_EVENT_LISTENER delboy, int level); - - void (*endBacktrack) (pANTLR3_DEBUG_EVENT_LISTENER delboy, int level, ANTLR3_BOOLEAN successful); - - /** To watch a parser move through the grammar, the parser needs to - * inform the debugger what line/charPos it is passing in the grammar. - * For now, this does not know how to switch from one grammar to the - * other and back for island grammars etc... - * - * This should also allow breakpoints because the debugger can stop - * the parser whenever it hits this line/pos. - */ - void (*location) (pANTLR3_DEBUG_EVENT_LISTENER delboy, int line, int pos); - - /** A recognition exception occurred such as NoViableAltException. I made - * this a generic event so that I can alter the exception hierarchy later - * without having to alter all the debug objects. - * - * Upon error, the stack of enter rule/subrule must be properly unwound. - * If no viable alt occurs it is within an enter/exit decision, which - * also must be rewound. Even the rewind for each mark must be unwound. - * In the Java target this is pretty easy using try/finally, if a bit - * ugly in the generated code. The rewind is generated in DFA.predict() - * actually so no code needs to be generated for that. For languages - * w/o this "finally" feature (C++?), the target implementor will have - * to build an event stack or something. - * - * Across a socket for remote debugging, only the RecognitionException - * data fields are transmitted. The token object or whatever that - * caused the problem was the last object referenced by LT. The - * immediately preceding LT event should hold the unexpected Token or - * char. - * - * Here is a sample event trace for grammar: - * - * b : C ({;}A|B) // {;} is there to prevent A|B becoming a set - * | D - * ; - * - * The sequence for this rule (with no viable alt in the subrule) for - * input 'c c' (there are 3 tokens) is: - * - * commence - * LT(1) - * enterRule b - * location 7 1 - * enter decision 3 - * LT(1) - * exit decision 3 - * enterAlt1 - * location 7 5 - * LT(1) - * consumeToken [c/<4>,1:0] - * location 7 7 - * enterSubRule 2 - * enter decision 2 - * LT(1) - * LT(1) - * recognitionException NoViableAltException 2 1 2 - * exit decision 2 - * exitSubRule 2 - * beginResync - * LT(1) - * consumeToken [c/<4>,1:1] - * LT(1) - * endResync - * LT(-1) - * exitRule b - * terminate - */ - void (*recognitionException) (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_EXCEPTION e); - - /** Indicates the recognizer is about to consume tokens to resynchronize - * the parser. Any consume events from here until the recovered event - * are not part of the parse--they are dead tokens. - */ - void (*beginResync) (pANTLR3_DEBUG_EVENT_LISTENER delboy); - - /** Indicates that the recognizer has finished consuming tokens in order - * to resynchronize. There may be multiple beginResync/endResync pairs - * before the recognizer comes out of errorRecovery mode (in which - * multiple errors are suppressed). This will be useful - * in a gui where you want to probably grey out tokens that are consumed - * but not matched to anything in grammar. Anything between - * a beginResync/endResync pair was tossed out by the parser. - */ - void (*endResync) (pANTLR3_DEBUG_EVENT_LISTENER delboy); - - /** A semantic predicate was evaluate with this result and action text - */ - void (*semanticPredicate) (pANTLR3_DEBUG_EVENT_LISTENER delboy, ANTLR3_BOOLEAN result, const char * predicate); - - /** Announce that parsing has begun. Not technically useful except for - * sending events over a socket. A GUI for example will launch a thread - * to connect and communicate with a remote parser. The thread will want - * to notify the GUI when a connection is made. ANTLR parsers - * trigger this upon entry to the first rule (the ruleLevel is used to - * figure this out). - */ - void (*commence) (pANTLR3_DEBUG_EVENT_LISTENER delboy); - - /** Parsing is over; successfully or not. Mostly useful for telling - * remote debugging listeners that it's time to quit. When the rule - * invocation level goes to zero at the end of a rule, we are done - * parsing. - */ - void (*terminate) (pANTLR3_DEBUG_EVENT_LISTENER delboy); - - /// Retrieve acknowledge response from the debugger. in fact this - /// response is never used at the moment. So we just read whatever - /// is in the socket buffer and throw it away. - /// - void (*ack) (pANTLR3_DEBUG_EVENT_LISTENER delboy); - - // T r e e P a r s i n g - - /** Input for a tree parser is an AST, but we know nothing for sure - * about a node except its type and text (obtained from the adaptor). - * This is the analog of the consumeToken method. The ID is usually - * the memory address of the node. - * If the type is UP or DOWN, then - * the ID is not really meaningful as it's fixed--there is - * just one UP node and one DOWN navigation node. - * - * Note that unlike the Java version, the node type of the C parsers - * is always fixed as pANTLR3_BASE_TREE because all such structures - * contain a super pointer to their parent, which is generally COMMON_TREE and within - * that there is a super pointer that can point to a user type that encapsulates it. - * Almost akin to saying that it is an interface pointer except we don't need to - * know what the interface is in full, just those bits that are the base. - * @param t - */ - void (*consumeNode) (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE t); - - /** The tree parser looked ahead. If the type is UP or DOWN, - * then the ID is not really meaningful as it's fixed--there is - * just one UP node and one DOWN navigation node. - */ - void (*LTT) (pANTLR3_DEBUG_EVENT_LISTENER delboy, int i, pANTLR3_BASE_TREE t); - - - // A S T E v e n t s - - /** A nil was created (even nil nodes have a unique ID... - * they are not "null" per se). As of 4/28/2006, this - * seems to be uniquely triggered when starting a new subtree - * such as when entering a subrule in automatic mode and when - * building a tree in rewrite mode. - * - * If you are receiving this event over a socket via - * RemoteDebugEventSocketListener then only t.ID is set. - */ - void (*nilNode) (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE t); - - /** If a syntax error occurs, recognizers bracket the error - * with an error node if they are building ASTs. This event - * notifies the listener that this is the case - */ - void (*errorNode) (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE t); - - /** Announce a new node built from token elements such as type etc... - * - * If you are receiving this event over a socket via - * RemoteDebugEventSocketListener then only t.ID, type, text are - * set. - */ - void (*createNode) (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE t); - - /** Announce a new node built from an existing token. - * - * If you are receiving this event over a socket via - * RemoteDebugEventSocketListener then only node.ID and token.tokenIndex - * are set. - */ - void (*createNodeTok) (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE node, pANTLR3_COMMON_TOKEN token); - - /** Make a node the new root of an existing root. See - * - * Note: the newRootID parameter is possibly different - * than the TreeAdaptor.becomeRoot() newRoot parameter. - * In our case, it will always be the result of calling - * TreeAdaptor.becomeRoot() and not root_n or whatever. - * - * The listener should assume that this event occurs - * only when the current subrule (or rule) subtree is - * being reset to newRootID. - * - * If you are receiving this event over a socket via - * RemoteDebugEventSocketListener then only IDs are set. - * - * @see org.antlr.runtime.tree.TreeAdaptor.becomeRoot() - */ - void (*becomeRoot) (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE newRoot, pANTLR3_BASE_TREE oldRoot); - - /** Make childID a child of rootID. - * - * If you are receiving this event over a socket via - * RemoteDebugEventSocketListener then only IDs are set. - * - * @see org.antlr.runtime.tree.TreeAdaptor.addChild() - */ - void (*addChild) (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE root, pANTLR3_BASE_TREE child); - - /** Set the token start/stop token index for a subtree root or node. - * - * If you are receiving this event over a socket via - * RemoteDebugEventSocketListener then only t.ID is set. - */ - void (*setTokenBoundaries) (pANTLR3_DEBUG_EVENT_LISTENER delboy, pANTLR3_BASE_TREE t, ANTLR3_MARKER tokenStartIndex, ANTLR3_MARKER tokenStopIndex); - - /// Free up the resources allocated to this structure - /// - void (*free) (pANTLR3_DEBUG_EVENT_LISTENER delboy); - -} - ANTLR3_DEBUG_EVENT_LISTENER; - -#ifdef __cplusplus -} -#endif - -#endif - diff --git a/impl/antlr/libantlr3c-3.4/include/antlr3defs.h b/impl/antlr/libantlr3c-3.4/include/antlr3defs.h deleted file mode 100644 index 2435b02..0000000 --- a/impl/antlr/libantlr3c-3.4/include/antlr3defs.h +++ /dev/null @@ -1,632 +0,0 @@ -/** \file - * Basic type and constant definitions for ANTLR3 Runtime. - */ -#ifndef _ANTLR3DEFS_H -#define _ANTLR3DEFS_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. - -/* Following are for generated code, they are not referenced internally!!! - */ -#if !defined(ANTLR3_HUGE) && !defined(ANTLR3_AVERAGE) && !defined(ANTLR3_SMALL) -#define ANTLR3_AVERAGE -#endif - -#ifdef ANTLR3_HUGE -#ifndef ANTLR3_SIZE_HINT -#define ANTLR3_SIZE_HINT 2049 -#endif -#ifndef ANTLR3_LIST_SIZE_HINT -#define ANTLR3_LIST_SIZE_HINT 127 -#endif -#endif - -#ifdef ANTLR3_AVERAGE -#ifndef ANTLR3_SIZE_HINT -#define ANTLR3_SIZE_HINT 1025 -#define ANTLR3_LIST_SIZE_HINT 63 -#endif -#endif - -#ifdef ANTLR3_SMALL -#ifndef ANTLR3_SIZE_HINT -#define ANTLR3_SIZE_HINT 211 -#define ANTLR3_LIST_SIZE_HINT 31 -#endif -#endif - -// Definitions that indicate the encoding scheme character streams and strings etc -// -/// Indicates Big Endian for encodings where this makes sense -/// -#define ANTLR3_BE 1 - -/// Indicates Little Endian for encoidngs where this makes sense -/// -#define ANTLR3_LE 2 - -/// General latin-1 or other 8 bit encoding scheme such as straight ASCII -/// -#define ANTLR3_ENC_8BIT 4 - -/// UTF-8 encoding scheme -/// -#define ANTLR3_ENC_UTF8 8 - -/// UTF-16 encoding scheme (which also covers UCS2 as that does not have surrogates) -/// -#define ANTLR3_ENC_UTF16 16 -#define ANTLR3_ENC_UTF16BE 16 + ANTLR3_BE -#define ANTLR3_ENC_UTF16LE 16 + ANTLR3_LE - -/// UTF-32 encoding scheme (basically straight 32 bit) -/// -#define ANTLR3_ENC_UTF32 32 -#define ANTLR3_ENC_UTF32BE 32 + ANTLR3_BE -#define ANTLR3_ENC_UTF32LE 32 + ANTLR3_LE - -/// Input is 8 bit EBCDIC (which we convert to 8 bit ASCII on the fly -/// -#define ANTLR3_ENC_EBCDIC 64 - -/* Common definitions come first - */ -#include <antlr3errors.h> - -/* Work out what operating system/compiler this is. We just do this once - * here and use an internal symbol after this. - */ -#ifdef _WIN64 - -# ifndef ANTLR3_WINDOWS -# define ANTLR3_WINDOWS -# endif -# define ANTLR3_WIN64 -# define ANTLR3_USE_64BIT - -#else - -#ifdef _WIN32 -# ifndef ANTLR3_WINDOWS -# define ANTLR3_WINDOWS -# endif - -#define ANTLR3_WIN32 -#endif - -#endif - -#ifdef ANTLR3_WINDOWS - -#ifndef WIN32_LEAN_AND_MEAN -#define WIN32_LEAN_AND_MEAN -#endif - -/* Allow VC 8 (vs2005) and above to use 'secure' versions of various functions such as sprintf - */ -#ifndef _CRT_SECURE_NO_DEPRECATE -#define _CRT_SECURE_NO_DEPRECATE -#endif - -#include <windows.h> -#include <stdlib.h> -#include <winsock.h> -#include <stdio.h> -#include <sys/types.h> -#include <sys/stat.h> -#include <stdarg.h> - -#define ANTLR3_API __declspec(dllexport) -#define ANTLR3_CDECL __cdecl -#define ANTLR3_FASTCALL __fastcall - -#ifdef __cplusplus -extern "C" { -#endif - -#ifndef __MINGW32__ -// Standard Windows types -// -typedef INT32 ANTLR3_CHAR, *pANTLR3_CHAR; -typedef UINT32 ANTLR3_UCHAR, *pANTLR3_UCHAR; - -typedef INT8 ANTLR3_INT8, *pANTLR3_INT8; -typedef INT16 ANTLR3_INT16, *pANTLR3_INT16; -typedef INT32 ANTLR3_INT32, *pANTLR3_INT32; -typedef INT64 ANTLR3_INT64, *pANTLR3_INT64; -typedef UINT8 ANTLR3_UINT8, *pANTLR3_UINT8; -typedef UINT16 ANTLR3_UINT16, *pANTLR3_UINT16; -typedef UINT32 ANTLR3_UINT32, *pANTLR3_UINT32; -typedef UINT64 ANTLR3_UINT64, *pANTLR3_UINT64; -typedef UINT64 ANTLR3_BITWORD, *pANTLR3_BITWORD; -typedef UINT8 ANTLR3_BOOLEAN, *pANTLR3_BOOLEAN; - -#else -// Mingw uses stdint.h and fails to define standard Microsoft typedefs -// such as UINT16, hence we must use stdint.h for Mingw. -// -#include <stdint.h> -typedef int32_t ANTLR3_CHAR, *pANTLR3_CHAR; -typedef uint32_t ANTLR3_UCHAR, *pANTLR3_UCHAR; - -typedef int8_t ANTLR3_INT8, *pANTLR3_INT8; -typedef int16_t ANTLR3_INT16, *pANTLR3_INT16; -typedef int32_t ANTLR3_INT32, *pANTLR3_INT32; -typedef int64_t ANTLR3_INT64, *pANTLR3_INT64; - -typedef uint8_t ANTLR3_UINT8, *pANTLR3_UINT8; -typedef uint16_t ANTLR3_UINT16, *pANTLR3_UINT16; -typedef uint32_t ANTLR3_UINT32, *pANTLR3_UINT32; -typedef uint64_t ANTLR3_UINT64, *pANTLR3_UINT64; -typedef uint64_t ANTLR3_BITWORD, *pANTLR3_BITWORD; - -typedef uint8_t ANTLR3_BOOLEAN, *pANTLR3_BOOLEAN; - -#endif - - - -#define ANTLR3_UINT64_LIT(lit) lit##ULL - -#define ANTLR3_INLINE __inline - -typedef FILE * ANTLR3_FDSC; -typedef struct stat ANTLR3_FSTAT_STRUCT; - -#ifdef ANTLR3_USE_64BIT -#define ANTLR3_FUNC_PTR(ptr) (void *)((ANTLR3_UINT64)(ptr)) -#define ANTLR3_UINT64_CAST(ptr) (ANTLR3_UINT64)(ptr)) -#define ANTLR3_UINT32_CAST(ptr) (ANTLR3_UINT32)((ANTLR3_UINT64)(ptr)) -typedef ANTLR3_INT64 ANTLR3_MARKER; -typedef ANTLR3_UINT64 ANTLR3_INTKEY; -#else -#define ANTLR3_FUNC_PTR(ptr) (void *)((ANTLR3_UINT32)(ptr)) -#define ANTLR3_UINT64_CAST(ptr) (ANTLR3_UINT64)((ANTLR3_UINT32)(ptr)) -#define ANTLR3_UINT32_CAST(ptr) (ANTLR3_UINT32)(ptr) -typedef ANTLR3_INT32 ANTLR3_MARKER; -typedef ANTLR3_UINT32 ANTLR3_INTKEY; -#endif - -#ifdef ANTLR3_WIN32 -#endif - -#ifdef ANTLR3_WIN64 -#endif - - -typedef int ANTLR3_SALENT; // Type used for size of accept structure -typedef struct sockaddr_in ANTLR3_SOCKADDRT, * pANTLR3_SOCKADDRT; // Type used for socket address declaration -typedef struct sockaddr ANTLR3_SOCKADDRC, * pANTLR3_SOCKADDRC; // Type used for cast on accept() - -#define ANTLR3_CLOSESOCKET closesocket - -#ifdef __cplusplus -} -#endif - -/* Warnings that are over-zealous such as complaining about strdup, we - * can turn off. - */ - -/* Don't complain about "deprecated" functions such as strdup - */ -#pragma warning( disable : 4996 ) - -#else - -/* Include configure generated header file - */ -#include <antlr3config.h> - -#include <stdio.h> - -#if HAVE_STDINT_H -# include <stdint.h> -#endif - -#if HAVE_SYS_TYPES_H -# include <sys/types.h> -#endif - -#if HAVE_SYS_STAT_H -# include <sys/stat.h> -#endif - -#if STDC_HEADERS -# include <stdlib.h> -# include <stddef.h> -# include <stdarg.h> -#else -# if HAVE_STDLIB_H -# include <stdlib.h> -# endif -# if HAVE_STDARG_H -# include <stdarg.h> -# endif -#endif - -#if HAVE_STRING_H -# if !STDC_HEADERS && HAVE_MEMORY_H -# include <memory.h> -# endif -# include <string.h> -#endif - -#if HAVE_STRINGS_H -# include <strings.h> -#endif - -#if HAVE_INTTYPES_H -# include <inttypes.h> -#endif - -#if HAVE_UNISTD_H -# include <unistd.h> -#endif - -#ifdef HAVE_NETINET_IN_H -#include <netinet/in.h> -#endif - -#ifdef HAVE_SOCKET_H -# include <socket.h> -#else -# if HAVE_SYS_SOCKET_H -# include <sys/socket.h> -# endif -#endif - -#ifdef HAVE_NETINET_TCP_H -#include <netinet/tcp.h> -#endif - -#ifdef HAVE_ARPA_NAMESER_H -#include <arpa/nameser.h> /* DNS HEADER struct */ -#endif - -#ifdef HAVE_NETDB_H -#include <netdb.h> -#endif - - -#ifdef HAVE_SYS_RESOLVE_H -#include <sys/resolv.h> -#endif - -#ifdef HAVE_RESOLVE_H -#include <resolv.h> -#endif - - -#ifdef HAVE_MALLOC_H -# include <malloc.h> -#else -# ifdef HAVE_SYS_MALLOC_H -# include <sys/malloc.h> -# endif -#endif - -#ifdef HAVE_CTYPE_H -# include <ctype.h> -#endif - -/* Some platforms define a macro, index() in string.h. AIX is - * one of these for instance. We must get rid of that definition - * as we use ->index all over the place. defining macros like this in system header - * files is a really bad idea, but I doubt that IBM will listen to me ;-) - */ -#ifdef index -#undef index -#endif - -#define _stat stat - -// SOCKET not defined on Unix -// -typedef int SOCKET; - -#define ANTLR3_API -#define ANTLR3_CDECL -#define ANTLR3_FASTCALL - -#ifdef __hpux - - // HPUX is always different usually for no good reason. Tru64 should have kicked it - // into touch and everyone knows it ;-) - // - typedef struct sockaddr_in ANTLR3_SOCKADDRT, * pANTLR3_SOCKADDRT; // Type used for socket address declaration - typedef void * pANTLR3_SOCKADDRC; // Type used for cast on accept() - typedef int ANTLR3_SALENT; - -#else - -# if defined(_AIX) || __GNUC__ > 3 - - typedef socklen_t ANTLR3_SALENT; - -# else - - typedef size_t ANTLR3_SALENT; - -# endif - - typedef struct sockaddr_in ANTLR3_SOCKADDRT, * pANTLR3_SOCKADDRT; // Type used for socket address declaration - typedef struct sockaddr * pANTLR3_SOCKADDRC; // Type used for cast on accept() - -#endif - -#define INVALID_SOCKET ((SOCKET)-1) -#define ANTLR3_CLOSESOCKET close - -#ifdef __cplusplus -extern "C" { -#endif - -/* Inherit type definitions for autoconf - */ -typedef int32_t ANTLR3_CHAR, *pANTLR3_CHAR; -typedef uint32_t ANTLR3_UCHAR, *pANTLR3_UCHAR; - -typedef int8_t ANTLR3_INT8, *pANTLR3_INT8; -typedef int16_t ANTLR3_INT16, *pANTLR3_INT16; -typedef int32_t ANTLR3_INT32, *pANTLR3_INT32; -typedef int64_t ANTLR3_INT64, *pANTLR3_INT64; - -typedef uint8_t ANTLR3_UINT8, *pANTLR3_UINT8; -typedef uint16_t ANTLR3_UINT16, *pANTLR3_UINT16; -typedef uint32_t ANTLR3_UINT32, *pANTLR3_UINT32; -typedef uint64_t ANTLR3_UINT64, *pANTLR3_UINT64; -typedef uint64_t ANTLR3_BITWORD, *pANTLR3_BITWORD; - -typedef uint32_t ANTLR3_BOOLEAN, *pANTLR3_BOOLEAN; - -#define ANTLR3_INLINE inline -#define ANTLR3_API - -typedef FILE * ANTLR3_FDSC; -typedef struct stat ANTLR3_FSTAT_STRUCT; - -#ifdef ANTLR3_USE_64BIT -#define ANTLR3_FUNC_PTR(ptr) (void *)((ANTLR3_UINT64)(ptr)) -#define ANTLR3_UINT64_CAST(ptr) (ANTLR3_UINT64)(ptr)) -#define ANTLR3_UINT32_CAST(ptr) (ANTLR3_UINT32)((ANTLR3_UINT64)(ptr)) -typedef ANTLR3_INT64 ANTLR3_MARKER; -typedef ANTLR3_UINT64 ANTLR3_INTKEY; -#else -#define ANTLR3_FUNC_PTR(ptr) (void *)((ANTLR3_UINT32)(ptr)) -#define ANTLR3_UINT64_CAST(ptr) (ANTLR3_UINT64)((ANTLR3_UINT32)(ptr)) -#define ANTLR3_UINT32_CAST(ptr) (ANTLR3_UINT32)(ptr) -typedef ANTLR3_INT32 ANTLR3_MARKER; -typedef ANTLR3_UINT32 ANTLR3_INTKEY; -#endif -#define ANTLR3_UINT64_LIT(lit) lit##ULL - -#ifdef __cplusplus -} -#endif - -#endif - -#ifdef ANTLR3_USE_64BIT -#define ANTLR3_TRIE_DEPTH 63 -#else -#define ANTLR3_TRIE_DEPTH 31 -#endif -/* Pre declare the typedefs for all the interfaces, then - * they can be inter-dependant and we will let the linker - * sort it out for us. - */ -#include <antlr3interfaces.h> - -// Include the unicode.org conversion library header. -// -#include <antlr3convertutf.h> - -/* Prototypes - */ -#ifndef ANTLR3_MALLOC -/// Default definition of ANTLR3_MALLOC. You can override this before including -/// antlr3.h if you wish to use your own implementation. -/// -#define ANTLR3_MALLOC(request) malloc ((size_t)(request)) -#endif - -#ifndef ANTLR3_CALLOC -/// Default definition of ANTLR3_CALLOC. You can override this before including -/// antlr3.h if you wish to use your own implementation. -/// -#define ANTLR3_CALLOC(numEl, elSize) calloc (numEl, (size_t)(elSize)) -#endif - -#ifndef ANTLR3_REALLOC -/// Default definition of ANTLR3_REALLOC. You can override this before including -/// antlr3.h if you wish to use your own implementation. -/// -#define ANTLR3_REALLOC(current, request) realloc ((void *)(current), (size_t)(request)) -#endif -#ifndef ANTLR3_FREE -/// Default definition of ANTLR3_FREE. You can override this before including -/// antlr3.h if you wish to use your own implementation. -/// -#define ANTLR3_FREE(ptr) free ((void *)(ptr)) -#endif -#ifndef ANTLR3_FREE_FUNC -/// Default definition of ANTLR3_FREE_FUNC. You can override this before including -/// antlr3.h if you wish to use your own implementation. -/// -#define ANTLR3_FREE_FUNC free -#endif -#ifndef ANTLR3_STRDUP -/// Default definition of ANTLR3_STRDUP. You can override this before including -/// antlr3.h if you wish to use your own implementation. -/// -#define ANTLR3_STRDUP(instr) (pANTLR3_UINT8)(strdup ((const char *)(instr))) -#endif -#ifndef ANTLR3_MEMCPY -/// Default definition of ANTLR3_MEMCPY. You can override this before including -/// antlr3.h if you wish to use your own implementation. -/// -#define ANTLR3_MEMCPY(target, source, size) memcpy((void *)(target), (const void *)(source), (size_t)(size)) -#endif -#ifndef ANTLR3_MEMMOVE -/// Default definition of ANTLR3_MEMMOVE. You can override this before including -/// antlr3.h if you wish to use your own implementation. -/// -#define ANTLR3_MEMMOVE(target, source, size) memmove((void *)(target), (const void *)(source), (size_t)(size)) -#endif -#ifndef ANTLR3_MEMSET -/// Default definition of ANTLR3_MEMSET. You can override this before including -/// antlr3.h if you wish to use your own implementation. -/// -#define ANTLR3_MEMSET(target, byte, size) memset((void *)(target), (int)(byte), (size_t)(size)) -#endif - -#ifndef ANTLR3_PRINTF -/// Default definition of printf, set this to something other than printf before including antlr3.h -/// if your system does not have a printf. Note that you can define this to be <code>//</code> -/// without harming the runtime. -/// -#define ANTLR3_PRINTF printf -#endif - -#ifndef ANTLR3_FPRINTF -/// Default definition of fprintf, set this to something other than fprintf before including antlr3.h -/// if your system does not have a fprintf. Note that you can define this to be <code>//</code> -/// without harming the runtime. -/// -#define ANTLR3_FPRINTF fprintf -#endif - -#ifdef __cplusplus -extern "C" { -#endif - -ANTLR3_API pANTLR3_INT_TRIE antlr3IntTrieNew (ANTLR3_UINT32 depth); - -ANTLR3_API pANTLR3_BITSET antlr3BitsetNew (ANTLR3_UINT32 numBits); -ANTLR3_API pANTLR3_BITSET antlr3BitsetOf (ANTLR3_INT32 bit, ...); -ANTLR3_API pANTLR3_BITSET antlr3BitsetList (pANTLR3_HASH_TABLE list); -ANTLR3_API pANTLR3_BITSET antlr3BitsetCopy (pANTLR3_BITSET_LIST blist); -ANTLR3_API pANTLR3_BITSET antlr3BitsetLoad (pANTLR3_BITSET_LIST blist); -ANTLR3_API void antlr3BitsetSetAPI (pANTLR3_BITSET bitset); - - -ANTLR3_API pANTLR3_BASE_RECOGNIZER antlr3BaseRecognizerNew (ANTLR3_UINT32 type, ANTLR3_UINT32 sizeHint, pANTLR3_RECOGNIZER_SHARED_STATE state); -ANTLR3_API void antlr3RecognitionExceptionNew (pANTLR3_BASE_RECOGNIZER recognizer); -ANTLR3_API void antlr3MTExceptionNew (pANTLR3_BASE_RECOGNIZER recognizer); -ANTLR3_API void antlr3MTNExceptionNew (pANTLR3_BASE_RECOGNIZER recognizer); -ANTLR3_API pANTLR3_HASH_TABLE antlr3HashTableNew (ANTLR3_UINT32 sizeHint); -ANTLR3_API ANTLR3_UINT32 antlr3Hash (void * key, ANTLR3_UINT32 keylen); -ANTLR3_API pANTLR3_HASH_ENUM antlr3EnumNew (pANTLR3_HASH_TABLE table); -ANTLR3_API pANTLR3_LIST antlr3ListNew (ANTLR3_UINT32 sizeHint); -ANTLR3_API pANTLR3_VECTOR_FACTORY antlr3VectorFactoryNew (ANTLR3_UINT32 sizeHint); -ANTLR3_API pANTLR3_VECTOR antlr3VectorNew (ANTLR3_UINT32 sizeHint); -ANTLR3_API pANTLR3_STACK antlr3StackNew (ANTLR3_UINT32 sizeHint); -ANTLR3_API void antlr3SetVectorApi (pANTLR3_VECTOR vector, ANTLR3_UINT32 sizeHint); -ANTLR3_API ANTLR3_UCHAR antlr3c8toAntlrc (ANTLR3_INT8 inc); -ANTLR3_API pANTLR3_TOPO antlr3TopoNew(); - -ANTLR3_API pANTLR3_EXCEPTION antlr3ExceptionNew (ANTLR3_UINT32 exception, void * name, void * message, ANTLR3_BOOLEAN freeMessage); - - -ANTLR3_API pANTLR3_INPUT_STREAM antlr3FileStreamNew (pANTLR3_UINT8 fileName, ANTLR3_UINT32 encoding); -ANTLR3_API pANTLR3_INPUT_STREAM antlr3StringStreamNew (pANTLR3_UINT8 data, ANTLR3_UINT32 encoding, ANTLR3_UINT32 size, pANTLR3_UINT8 name); - -ANTLR3_API pANTLR3_INT_STREAM antlr3IntStreamNew (void); - -ANTLR3_API pANTLR3_STRING_FACTORY antlr3StringFactoryNew (ANTLR3_UINT32 encoding); - -ANTLR3_API pANTLR3_COMMON_TOKEN antlr3CommonTokenNew (ANTLR3_UINT32 ttype); -ANTLR3_API pANTLR3_TOKEN_FACTORY antlr3TokenFactoryNew (pANTLR3_INPUT_STREAM input); -ANTLR3_API void antlr3SetTokenAPI (pANTLR3_COMMON_TOKEN token); - -ANTLR3_API pANTLR3_LEXER antlr3LexerNewStream (ANTLR3_UINT32 sizeHint, pANTLR3_INPUT_STREAM input, pANTLR3_RECOGNIZER_SHARED_STATE state); -ANTLR3_API pANTLR3_LEXER antlr3LexerNew (ANTLR3_UINT32 sizeHint, pANTLR3_RECOGNIZER_SHARED_STATE state); -ANTLR3_API pANTLR3_PARSER antlr3ParserNewStreamDbg (ANTLR3_UINT32 sizeHint, pANTLR3_TOKEN_STREAM tstream, pANTLR3_DEBUG_EVENT_LISTENER dbg, pANTLR3_RECOGNIZER_SHARED_STATE state); -ANTLR3_API pANTLR3_PARSER antlr3ParserNewStream (ANTLR3_UINT32 sizeHint, pANTLR3_TOKEN_STREAM tstream, pANTLR3_RECOGNIZER_SHARED_STATE state); -ANTLR3_API pANTLR3_PARSER antlr3ParserNew (ANTLR3_UINT32 sizeHint, pANTLR3_RECOGNIZER_SHARED_STATE state); - -ANTLR3_API pANTLR3_COMMON_TOKEN_STREAM antlr3CommonTokenStreamSourceNew (ANTLR3_UINT32 hint, pANTLR3_TOKEN_SOURCE source); -ANTLR3_API pANTLR3_COMMON_TOKEN_STREAM antlr3CommonTokenStreamNew (ANTLR3_UINT32 hint); -ANTLR3_API pANTLR3_COMMON_TOKEN_STREAM antlr3CommonTokenDebugStreamSourceNew (ANTLR3_UINT32 hint, pANTLR3_TOKEN_SOURCE source, pANTLR3_DEBUG_EVENT_LISTENER debugger); - -ANTLR3_API pANTLR3_BASE_TREE_ADAPTOR ANTLR3_TREE_ADAPTORNew (pANTLR3_STRING_FACTORY strFactory); -ANTLR3_API pANTLR3_BASE_TREE_ADAPTOR ANTLR3_TREE_ADAPTORDebugNew (pANTLR3_STRING_FACTORY strFactory, pANTLR3_DEBUG_EVENT_LISTENER debugger); -ANTLR3_API pANTLR3_COMMON_TREE antlr3CommonTreeNew (void); -ANTLR3_API pANTLR3_COMMON_TREE antlr3CommonTreeNewFromTree (pANTLR3_COMMON_TREE tree); -ANTLR3_API pANTLR3_COMMON_TREE antlr3CommonTreeNewFromToken (pANTLR3_COMMON_TOKEN tree); -ANTLR3_API pANTLR3_ARBORETUM antlr3ArboretumNew (pANTLR3_STRING_FACTORY factory); -ANTLR3_API void antlr3SetCTAPI (pANTLR3_COMMON_TREE tree); -ANTLR3_API pANTLR3_BASE_TREE antlr3BaseTreeNew (pANTLR3_BASE_TREE tree); - -ANTLR3_API void antlr3BaseTreeAdaptorInit (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_DEBUG_EVENT_LISTENER debugger); - -ANTLR3_API pANTLR3_TREE_PARSER antlr3TreeParserNewStream (ANTLR3_UINT32 sizeHint, pANTLR3_COMMON_TREE_NODE_STREAM ctnstream, pANTLR3_RECOGNIZER_SHARED_STATE state); - -ANTLR3_API ANTLR3_INT32 antlr3dfaspecialTransition (void * ctx, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_INT_STREAM is, pANTLR3_CYCLIC_DFA dfa, ANTLR3_INT32 s); -ANTLR3_API ANTLR3_INT32 antlr3dfaspecialStateTransition (void * ctx, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_INT_STREAM is, pANTLR3_CYCLIC_DFA dfa, ANTLR3_INT32 s); -ANTLR3_API ANTLR3_INT32 antlr3dfapredict (void * ctx, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_INT_STREAM is, pANTLR3_CYCLIC_DFA cdfa); - -ANTLR3_API pANTLR3_COMMON_TREE_NODE_STREAM antlr3CommonTreeNodeStreamNewTree (pANTLR3_BASE_TREE tree, ANTLR3_UINT32 hint); -ANTLR3_API pANTLR3_COMMON_TREE_NODE_STREAM antlr3CommonTreeNodeStreamNew (pANTLR3_STRING_FACTORY strFactory, ANTLR3_UINT32 hint); -ANTLR3_API pANTLR3_COMMON_TREE_NODE_STREAM antlr3UnbufTreeNodeStreamNewTree (pANTLR3_BASE_TREE tree, ANTLR3_UINT32 hint); -ANTLR3_API pANTLR3_COMMON_TREE_NODE_STREAM antlr3UnbufTreeNodeStreamNew (pANTLR3_STRING_FACTORY strFactory, ANTLR3_UINT32 hint); -ANTLR3_API pANTLR3_COMMON_TREE_NODE_STREAM antlr3CommonTreeNodeStreamNewStream (pANTLR3_COMMON_TREE_NODE_STREAM inStream); -ANTLR3_API pANTLR3_TREE_NODE_STREAM antlr3TreeNodeStreamNew (); -ANTLR3_API void fillBufferExt (pANTLR3_COMMON_TOKEN_STREAM tokenStream); - -ANTLR3_API pANTLR3_REWRITE_RULE_TOKEN_STREAM - antlr3RewriteRuleTOKENStreamNewAE (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_UINT8 description); -ANTLR3_API pANTLR3_REWRITE_RULE_TOKEN_STREAM - antlr3RewriteRuleTOKENStreamNewAEE (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_UINT8 description, void * oneElement); -ANTLR3_API pANTLR3_REWRITE_RULE_TOKEN_STREAM - antlr3RewriteRuleTOKENStreamNewAEV (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_UINT8 description, pANTLR3_VECTOR vector); - -ANTLR3_API pANTLR3_REWRITE_RULE_NODE_STREAM - antlr3RewriteRuleNODEStreamNewAE (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_UINT8 description); -ANTLR3_API pANTLR3_REWRITE_RULE_NODE_STREAM - antlr3RewriteRuleNODEStreamNewAEE (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_UINT8 description, void * oneElement); -ANTLR3_API pANTLR3_REWRITE_RULE_NODE_STREAM - antlr3RewriteRuleNODEStreamNewAEV (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_UINT8 description, pANTLR3_VECTOR vector); - -ANTLR3_API pANTLR3_REWRITE_RULE_SUBTREE_STREAM - antlr3RewriteRuleSubtreeStreamNewAE (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_UINT8 description); -ANTLR3_API pANTLR3_REWRITE_RULE_SUBTREE_STREAM - antlr3RewriteRuleSubtreeStreamNewAEE(pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_UINT8 description, void * oneElement); -ANTLR3_API pANTLR3_REWRITE_RULE_SUBTREE_STREAM - antlr3RewriteRuleSubtreeStreamNewAEV(pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_UINT8 description, pANTLR3_VECTOR vector); - -ANTLR3_API pANTLR3_DEBUG_EVENT_LISTENER antlr3DebugListenerNew(); - -#ifdef __cplusplus -} -#endif - -#endif /* _ANTLR3DEFS_H */ diff --git a/impl/antlr/libantlr3c-3.4/include/antlr3encodings.h b/impl/antlr/libantlr3c-3.4/include/antlr3encodings.h deleted file mode 100644 index f706735..0000000 --- a/impl/antlr/libantlr3c-3.4/include/antlr3encodings.h +++ /dev/null @@ -1,38 +0,0 @@ -#ifndef _ANTLR3_ENCODINGS_H -#define _ANTLR3_ENCODINGS_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> - - - -#endif - diff --git a/impl/antlr/libantlr3c-3.4/include/antlr3errors.h b/impl/antlr/libantlr3c-3.4/include/antlr3errors.h deleted file mode 100644 index 4419ee3..0000000 --- a/impl/antlr/libantlr3c-3.4/include/antlr3errors.h +++ /dev/null @@ -1,53 +0,0 @@ -#ifndef _ANTLR3ERRORS_H -#define _ANTLR3ERRORS_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. - -#define ANTLR3_SUCCESS 0 -#define ANTLR3_FAIL 1 - -#define ANTLR3_TRUE 1 -#define ANTLR3_FALSE 0 - -/** Indicates end of character stream and is an invalid Unicode code point. */ -#define ANTLR3_CHARSTREAM_EOF 0xFFFFFFFF - -/** Indicates memoizing on a rule failed. - */ -#define MEMO_RULE_FAILED 0xFFFFFFFE -#define MEMO_RULE_UNKNOWN 0xFFFFFFFF - - -#define ANTLR3_ERR_BASE 0 -#define ANTLR3_ERR_NOMEM (ANTLR3_ERR_BASE + 1) -#define ANTLR3_ERR_NOFILE (ANTLR3_ERR_BASE + 2) -#define ANTLR3_ERR_HASHDUP (ANTLR3_ERR_BASE + 3) - -#endif /* _ANTLR3ERRORS_H */ diff --git a/impl/antlr/libantlr3c-3.4/include/antlr3exception.h b/impl/antlr/libantlr3c-3.4/include/antlr3exception.h deleted file mode 100644 index 8fab8da..0000000 --- a/impl/antlr/libantlr3c-3.4/include/antlr3exception.h +++ /dev/null @@ -1,218 +0,0 @@ -/** \file - * Contains the definition of a basic ANTLR3 exception structure created - * by a recognizer when errors are found/predicted. - */ -#ifndef _ANTLR3_EXCEPTION_H -#define _ANTLR3_EXCEPTION_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> - -/** Indicates that the recognizer received a token - * in the input that was not predicted. - */ -#define ANTLR3_RECOGNITION_EXCEPTION 1 - -/** Name of exception #ANTLR3_RECOGNITION_EXCEPTION - */ -#define ANTLR3_RECOGNITION_EX_NAME "org.antlr.runtime.RecognitionException" - -/** Indicates that the recognizer was expecting one token and found a - * a different one. - */ -#define ANTLR3_MISMATCHED_TOKEN_EXCEPTION 2 - -/** Name of #ANTLR3_MISMATCHED_TOKEN_EXCEPTION - */ -#define ANTLR3_MISMATCHED_EX_NAME "org.antlr.runtime.MismatchedTokenException" - -/** Recognizer could not find a valid alternative from the input - */ -#define ANTLR3_NO_VIABLE_ALT_EXCEPTION 3 - -/** Name of #ANTLR3_NO_VIABLE_ALT_EXCEPTION - */ -#define ANTLR3_NO_VIABLE_ALT_NAME "org.antlr.runtime.NoViableAltException" - -/* Character in a set was not found - */ -#define ANTLR3_MISMATCHED_SET_EXCEPTION 4 - -/* Name of #ANTLR3_MISMATCHED_SET_EXCEPTION - */ -#define ANTLR3_MISMATCHED_SET_NAME "org.antlr.runtime.MismatchedSetException" - -/* A rule predicting at least n elements found less than that, - * such as: WS: " "+; - */ -#define ANTLR3_EARLY_EXIT_EXCEPTION 5 - -/* Name of #ANTLR3_EARLY_EXIT_EXCEPTION - */ -#define ANTLR3_EARLY_EXIT_NAME "org.antlr.runtime.EarlyExitException" - -#define ANTLR3_FAILED_PREDICATE_EXCEPTION 6 -#define ANTLR3_FAILED_PREDICATE_NAME "org.antlr.runtime.FailedPredicateException" - -#define ANTLR3_MISMATCHED_TREE_NODE_EXCEPTION 7 -#define ANTLR3_MISMATCHED_TREE_NODE_NAME "org.antlr.runtime.MismatchedTreeNodeException" - -#define ANTLR3_REWRITE_EARLY_EXCEPTION 8 -#define ANTLR3_REWRITE_EARLY_EXCEPTION_NAME "org.antlr.runtime.tree.RewriteEarlyExitException" - -#define ANTLR3_UNWANTED_TOKEN_EXCEPTION 9 -#define ANTLR3_UNWANTED_TOKEN_EXCEPTION_NAME "org.antlr.runtime.UnwantedTokenException" - -#define ANTLR3_MISSING_TOKEN_EXCEPTION 10 -#define ANTLR3_MISSING_TOKEN_EXCEPTION_NAME "org.antlr.runtime.MissingTokenException" - -#ifdef __cplusplus -extern "C" { -#endif - -/** Base structure for an ANTLR3 exception tracker - */ -typedef struct ANTLR3_EXCEPTION_struct -{ - /// Set to one of the exception type defines: - /// - /// - #ANTLR3_RECOGNITION_EXCEPTION - /// - #ANTLR3_MISMATCHED_TOKEN_EXCEPTION - /// - #ANTLR3_NO_VIABLE_ALT_EXCEPTION - /// - #ANTLR3_MISMATCHED_SET_EXCEPTION - /// - #ANTLR3_EARLY_EXIT_EXCEPTION - /// - #ANTLR3_FAILED_PREDICATE_EXCEPTION - /// - #ANTLR3_EARLY_EXIT_EXCEPTION - /// - ANTLR3_UINT32 type; - - /** The string name of the exception - */ - void * name; - - /** The printable message that goes with this exception, in your preferred - * encoding format. ANTLR just uses ASCII by default but you can ignore these - * messages or convert them to another format or whatever of course. They are - * really internal messages that you then decide how to print out in a form that - * the users of your product will understand, as they are unlikely to know what - * to do with "Recognition exception at: [[TOK_GERUND..... " ;-) - */ - void * message; - - /** Name of the file/input source for reporting. Note that this may be NULL!! - */ - pANTLR3_STRING streamName; - - /** If set to ANTLR3_TRUE, this indicates that the message element of this structure - * should be freed by calling ANTLR3_FREE() when the exception is destroyed. - */ - ANTLR3_BOOLEAN freeMessage; - - /** Indicates the index of the 'token' we were looking at when the - * exception occurred. - */ - ANTLR3_MARKER index; - - /** Indicates what the current token/tree was when the error occurred. Since not - * all input streams will be able to retrieve the nth token, we track it here - * instead. This is for parsers, and even tree parsers may set this. - */ - void * token; - - /** Indicates the token we were expecting to see next when the error occurred - */ - ANTLR3_UINT32 expecting; - - /** Indicates a set of tokens that we were expecting to see one of when the - * error occurred. It is a following bitset list, so you can use load it and use ->toIntList() on it - * to generate an array of integer tokens that it represents. - */ - pANTLR3_BITSET_LIST expectingSet; - - /** If this is a tree parser exception then the node is set to point to the node - * that caused the issue. - */ - void * node; - - /** The current character when an error occurred - for lexers. - */ - ANTLR3_UCHAR c; - - /** Track the line at which the error occurred in case this is - * generated from a lexer. We need to track this since the - * unexpected char doesn't carry the line info. - */ - ANTLR3_UINT32 line; - - /** Character position in the line where the error occurred. - */ - ANTLR3_INT32 charPositionInLine; - - /** decision number for NVE - */ - ANTLR3_UINT32 decisionNum; - - /** State for NVE - */ - ANTLR3_UINT32 state; - - /** Rule name for failed predicate exception - */ - void * ruleName; - - /** Pointer to the next exception in the chain (if any) - */ - struct ANTLR3_EXCEPTION_struct * nextException; - - /** Pointer to the input stream that this exception occurred in. - */ - pANTLR3_INT_STREAM input; - - /** Pointer for you, the programmer to add anything you like to an exception. - */ - void * custom; - - /** Pointer to a routine that is called to free the custom exception structure - * when the exception is destroyed. Set to NULL if nothing should be done. - */ - void (*freeCustom) (void * custom); - void (*print) (struct ANTLR3_EXCEPTION_struct * ex); - void (*freeEx) (struct ANTLR3_EXCEPTION_struct * ex); - -} - ANTLR3_EXCEPTION; - -#ifdef __cplusplus -} -#endif - - -#endif diff --git a/impl/antlr/libantlr3c-3.4/include/antlr3filestream.h b/impl/antlr/libantlr3c-3.4/include/antlr3filestream.h deleted file mode 100644 index b06eb45..0000000 --- a/impl/antlr/libantlr3c-3.4/include/antlr3filestream.h +++ /dev/null @@ -1,50 +0,0 @@ -#ifndef _ANTLR3_FILESTREAM_H -#define _ANTLR3_FILESTREAM_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> - -#ifdef __cplusplus -extern "C" { -#endif - -ANTLR3_API ANTLR3_FDSC antlr3Fopen (pANTLR3_UINT8 filename, const char * mode); -ANTLR3_API void antlr3Fclose (ANTLR3_FDSC fd); - -ANTLR3_API ANTLR3_UINT32 antlr3Fsize (pANTLR3_UINT8 filename); -ANTLR3_API ANTLR3_UINT32 antlr3read8Bit (pANTLR3_INPUT_STREAM input, pANTLR3_UINT8 fileName); -ANTLR3_API ANTLR3_UINT32 antlr3Fread (ANTLR3_FDSC fdsc, ANTLR3_UINT32 count, void * data); - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/impl/antlr/libantlr3c-3.4/include/antlr3input.h b/impl/antlr/libantlr3c-3.4/include/antlr3input.h deleted file mode 100644 index 3b01ae6..0000000 --- a/impl/antlr/libantlr3c-3.4/include/antlr3input.h +++ /dev/null @@ -1,281 +0,0 @@ -/** \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 */ diff --git a/impl/antlr/libantlr3c-3.4/include/antlr3interfaces.h b/impl/antlr/libantlr3c-3.4/include/antlr3interfaces.h deleted file mode 100644 index 160e04d..0000000 --- a/impl/antlr/libantlr3c-3.4/include/antlr3interfaces.h +++ /dev/null @@ -1,239 +0,0 @@ -/** \file - * Declarations for all the antlr3 C runtime interfaces/classes. This - * allows the structures that define the interfaces to contain pointers to - * each other without trying to sort out the cyclic interdependencies that - * would otherwise result. - */ -#ifndef _ANTLR3_INTERFACES_H -#define _ANTLR3_INTERFACES_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. - -#ifdef __cplusplus -extern "C" { -#endif - -typedef struct ANTLR3_INT_STREAM_struct *pANTLR3_INT_STREAM; - -/// Pointer to an instantiation of the 'class' #ANTLR3_BASE_RECOGNIZER -/// \ingroup ANTLR3_BASE_RECOGNIZER -/// -typedef struct ANTLR3_BASE_RECOGNIZER_struct *pANTLR3_BASE_RECOGNIZER; -/// Pointer to an instantiation of 'class' #ANTLR3_RECOGNIZER_SHARED_STATE -/// \ingroup ANTLR3_RECOGNIZER_SHARED_STATE -/// -typedef struct ANTLR3_RECOGNIZER_SHARED_STATE_struct *pANTLR3_RECOGNIZER_SHARED_STATE; - -/// Pointer to an instantiation of 'class' #ANTLR3_BITSET_LIST -/// \ingroup ANTLR3_BITSET_LIST -/// -typedef struct ANTLR3_BITSET_LIST_struct *pANTLR3_BITSET_LIST; - -/// Pointer to an instantiation of 'class' #ANTLR3_BITSET -/// \ingroup ANTLR3_BITSET -/// -typedef struct ANTLR3_BITSET_struct *pANTLR3_BITSET; - -/// Pointer to an instantiation of 'class' #ANTLR3_TOKEN_FACTORY -/// \ingroup ANTLR3_TOKEN_FACTORY -/// -typedef struct ANTLR3_TOKEN_FACTORY_struct *pANTLR3_TOKEN_FACTORY; -/// Pointer to an instantiation of 'class' #ANTLR3_COMMON_TOKEN -/// \ingroup ANTLR3_COMMON_TOKEN -/// -typedef struct ANTLR3_COMMON_TOKEN_struct *pANTLR3_COMMON_TOKEN; - -/// Pointer to an instantiation of 'class' #ANTLR3_EXCEPTION -/// \ingroup ANTLR3_EXCEPTION -/// -typedef struct ANTLR3_EXCEPTION_struct *pANTLR3_EXCEPTION; - -/// Pointer to an instantiation of 'class' #ANTLR3_HASH_BUCKET -/// \ingroup ANTLR3_HASH_BUCKET -/// -typedef struct ANTLR3_HASH_BUCKET_struct *pANTLR3_HASH_BUCKET; -/// Pointer to an instantiation of 'class' #ANTLR3_HASH_ENTRY -/// \ingroup ANTLR3_HASH_ENTRY -/// -typedef struct ANTLR3_HASH_ENTRY_struct *pANTLR3_HASH_ENTRY; -/// Pointer to an instantiation of 'class' #ANTLR3_HASH_ENUM -/// \ingroup ANTLR3_HASH_ENUM -/// -typedef struct ANTLR3_HASH_ENUM_struct *pANTLR3_HASH_ENUM; -/// Pointer to an instantiation of 'class' #ANTLR3_HASH_TABLE -/// \ingroup ANTLR3_HASH_TABLE -/// -typedef struct ANTLR3_HASH_TABLE_struct *pANTLR3_HASH_TABLE; - -/// Pointer to an instantiation of 'class' #ANTLR3_LIST -/// \ingroup ANTLR3_LIST -/// -typedef struct ANTLR3_LIST_struct *pANTLR3_LIST; -/// Pointer to an instantiation of 'class' #ANTLR3_VECTOR_FACTORY -/// \ingroup ANTLR3_VECTOR_FACTORY -/// -typedef struct ANTLR3_VECTOR_FACTORY_struct *pANTLR3_VECTOR_FACTORY; -/// Pointer to an instantiation of 'class' #ANTLR3_VECTOR -/// \ingroup ANTLR3_VECTOR -/// -typedef struct ANTLR3_VECTOR_struct *pANTLR3_VECTOR; -/// Pointer to an instantiation of 'class' #ANTLR3_STACK -/// \ingroup ANTLR3_STACK -/// -typedef struct ANTLR3_STACK_struct *pANTLR3_STACK; - -/// Pointer to an instantiation of 'class' #ANTLR3_TOPO -/// \ingroup ANTLR3_TOPO -/// -typedef struct ANTLR3_TOPO_struct *pANTLR3_TOPO; - -/// Pointer to an instantiation of 'class' #ANTLR3_INPUT_STREAM -/// \ingroup ANTLR3_INPUT_STREAM -/// -typedef struct ANTLR3_INPUT_STREAM_struct *pANTLR3_INPUT_STREAM; -/// Pointer to an instantiation of 'class' #ANTLR3_LEX_STATE -/// \ingroup ANTLR3_LEX_STATE -/// -typedef struct ANTLR3_LEX_STATE_struct *pANTLR3_LEX_STATE; - -/// Pointer to an instantiation of 'class' #ANTLR3_STRING_FACTORY -/// \ingroup ANTLR3_STRING_FACTORY -/// -typedef struct ANTLR3_STRING_FACTORY_struct *pANTLR3_STRING_FACTORY; -/// Pointer to an instantiation of 'class' #ANTLR3_STRING -/// \ingroup ANTLR3_STRING -/// -typedef struct ANTLR3_STRING_struct *pANTLR3_STRING; - -/// Pointer to an instantiation of 'class' #ANTLR3_TOKEN_SOURCE -/// \ingroup ANTLR3_TOKEN_SOURCE -/// -typedef struct ANTLR3_TOKEN_SOURCE_struct *pANTLR3_TOKEN_SOURCE; -/// Pointer to an instantiation of 'class' #ANTLR3_TOKEN_STREAM -/// \ingroup ANTLR3_TOKEN_STREAM -/// -typedef struct ANTLR3_TOKEN_STREAM_struct *pANTLR3_TOKEN_STREAM; -/// Pointer to an instantiation of 'class' #ANTLR3_COMMON_TOKEN_STREAM -/// \ingroup ANTLR3_COMMON_TOKEN_STREAM -/// -typedef struct ANTLR3_COMMON_TOKEN_STREAM_struct *pANTLR3_COMMON_TOKEN_STREAM; - -/// Pointer to an instantiation of 'class' #ANTLR3_CYCLIC_DFA -/// \ingroup ANTLR3_CYCLIC_DFA -/// -typedef struct ANTLR3_CYCLIC_DFA_struct *pANTLR3_CYCLIC_DFA; - -/// Pointer to an instantiation of 'class' #ANTLR3_LEXER -/// \ingroup ANTLR3_LEXER -/// -typedef struct ANTLR3_LEXER_struct *pANTLR3_LEXER; -/// Pointer to an instantiation of 'class' #ANTLR3_PARSER -/// \ingroup ANTLR3_PARSER -/// -typedef struct ANTLR3_PARSER_struct *pANTLR3_PARSER; - -/// Pointer to an instantiation of 'class' #ANTLR3_BASE_TREE -/// \ingroup ANTLR3_BASE_TREE -/// -typedef struct ANTLR3_BASE_TREE_struct *pANTLR3_BASE_TREE; -/// Pointer to an instantiation of 'class' #ANTLR3_COMMON_TREE -/// \ingroup ANTLR3_COMMON_TREE -/// -typedef struct ANTLR3_COMMON_TREE_struct *pANTLR3_COMMON_TREE; -/// Pointer to an instantiation of 'class' #ANTLR3_ARBORETUM -/// \ingroup ANTLR3_ARBORETUM -/// -typedef struct ANTLR3_ARBORETUM_struct *pANTLR3_ARBORETUM; -/// Pointer to an instantiation of 'class' #ANTLR3_PARSE_TREE -/// \ingroup ANTLR3_PARSE_TREE -/// -typedef struct ANTLR3_PARSE_TREE_struct *pANTLR3_PARSE_TREE; - -/// Pointer to an instantiation of 'class' #ANTLR3_TREE_NODE_STREAM -/// \ingroup ANTLR3_TREE_NODE_STREAM -/// -typedef struct ANTLR3_TREE_NODE_STREAM_struct *pANTLR3_TREE_NODE_STREAM; -/// Pointer to an instantiation of 'class' #ANTLR3_COMMON_TREE_NODE_STREAM -/// \ingroup ANTLR3_COMMON_TREE_NODE_STREAM -/// -typedef struct ANTLR3_COMMON_TREE_NODE_STREAM_struct *pANTLR3_COMMON_TREE_NODE_STREAM; -/// Pointer to an instantiation of 'class' #ANTLR3_TREE_WALK_STATE -/// \ingroup ANTLR3_TREE_WALK_STATE -/// -typedef struct ANTLR3_TREE_WALK_STATE_struct *pANTLR3_TREE_WALK_STATE; - -/// Pointer to an instantiation of 'class' #ANTLR3_BASE_TREE_ADAPTOR -/// \ingroup ANTLR3_BASE_TREE_ADAPTOR -/// -typedef struct ANTLR3_BASE_TREE_ADAPTOR_struct *pANTLR3_BASE_TREE_ADAPTOR; -/// Pointer to an instantiation of 'class' #ANTLR3_COMMON_TREE_ADAPTOR -/// \ingroup ANTLR3_COMMON_TREE_ADAPTOR -/// -typedef struct ANTLR3_COMMON_TREE_ADAPTOR_struct *pANTLR3_COMMON_TREE_ADAPTOR; - -/// Pointer to an instantiation of 'class' #ANTLR3_TREE_PARSER -/// \ingroup ANTLR3_TREE_PARSER -/// -typedef struct ANTLR3_TREE_PARSER_struct *pANTLR3_TREE_PARSER; - -/// Pointer to an instantiation of 'class' #ANTLR3_INT_TRIE -/// \ingroup ANTLR3_INT_TRIE -/// -typedef struct ANTLR3_INT_TRIE_struct *pANTLR3_INT_TRIE; - -/// Pointer to an instantiation of 'class' #ANTLR3_REWRITE_RULE_ELEMENT_STREAM -/// \ingroup ANTLR3_REWRITE_RULE_ELEMENT_STREAM -/// -typedef struct ANTLR3_REWRITE_RULE_ELEMENT_STREAM_struct *pANTLR3_REWRITE_RULE_ELEMENT_STREAM; -/// Pointer to an instantiation of 'class' #ANTLR3_REWRITE_RULE_ELEMENT_STREAM -/// \ingroup ANTLR3_REWRITE_RULE_ELEMENT_STREAM -/// -typedef struct ANTLR3_REWRITE_RULE_ELEMENT_STREAM_struct *pANTLR3_REWRITE_RULE_TOKEN_STREAM; - -/// Pointer to an instantiation of 'class' #ANTLR3_REWRITE_RULE_SUBSTREE_STREAM -/// \ingroup ANTLR3_REWRITE_RULE_SUBTREE_STREAM -/// -typedef struct ANTLR3_REWRITE_RULE_ELEMENT_STREAM_struct *pANTLR3_REWRITE_RULE_SUBTREE_STREAM; - -/// Pointer to an instantiation of 'class' #ANTLR3_REWRITE_RULE_NODE_STREAM -/// \ingroup ANTLR3_REWRITE_RULE_NODE_STREAM -/// -typedef struct ANTLR3_REWRITE_RULE_ELEMENT_STREAM_struct *pANTLR3_REWRITE_RULE_NODE_STREAM; - -/// Pointer to an instantiation of 'class' #ANTLR3_DEBUG_EVENT_LISTENER -/// \ingroup ANTLR3_DEBUG_EVENT_LISTENER -/// -typedef struct ANTLR3_DEBUG_EVENT_LISTENER_struct *pANTLR3_DEBUG_EVENT_LISTENER; - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/impl/antlr/libantlr3c-3.4/include/antlr3intstream.h b/impl/antlr/libantlr3c-3.4/include/antlr3intstream.h deleted file mode 100644 index 21bac5b..0000000 --- a/impl/antlr/libantlr3c-3.4/include/antlr3intstream.h +++ /dev/null @@ -1,205 +0,0 @@ -/** \file - * Defines the the class interface for an antlr3 INTSTREAM. - * - * Certain functionality (such as DFAs for instance) abstract the stream of tokens - * or characters in to a steam of integers. Hence this structure should be included - * in any stream that is able to provide the output as a stream of integers (which is anything - * basically. - * - * There are no specific implementations of the methods in this interface in general. Though - * for purposes of casting and so on, it may be necesssary to implement a function with - * the signature in this interface which abstracts the base immplementation. In essence though - * the base stream provides a pointer to this interface, within which it installs its - * normal match() functions and so on. Interaces such as DFA are then passed the pANTLR3_INT_STREAM - * and can treat any input as an int stream. - * - * For instance, a lexer implements a pANTLR3_BASE_RECOGNIZER, within which there is a pANTLR3_INT_STREAM. - * However, a pANTLR3_INPUT_STREAM also provides a pANTLR3_INT_STREAM, which it has constructed from - * it's normal interface when it was created. This is then pointed at by the pANTLR_BASE_RECOGNIZER - * when it is intialized with a pANTLR3_INPUT_STREAM. - * - * Similarly if a pANTLR3_BASE_RECOGNIZER is initialized with a pANTLR3_TOKEN_STREAM, then the - * pANTLR3_INT_STREAM is taken from the pANTLR3_TOKEN_STREAM. - * - * If a pANTLR3_BASE_RECOGNIZER is initialized with a pANTLR3_TREENODE_STREAM, then guess where - * the pANTLR3_INT_STREAM comes from? - * - * Note that because the context pointer points to the actual interface structure that is providing - * the ANTLR3_INT_STREAM it is defined as a (void *) in this interface. There is no direct implementation - * of an ANTLR3_INT_STREAM (unless someone did not understand what I was doing here =;?P - */ -#ifndef _ANTLR3_INTSTREAM_H -#define _ANTLR3_INTSTREAM_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 <antlr3commontoken.h> - -/** Type indicator for a character stream - * \remark if a custom stream is created but it can be treated as - * a char stream, then you may OR in this value to your type indicator - */ -#define ANTLR3_CHARSTREAM 0x0001 - -/** Type indicator for a Token stream - * \remark if a custom stream is created but it can be treated as - * a token stream, then you may OR in this value to your type indicator - */ -#define ANTLR3_TOKENSTREAM 0x0002 - -/** Type indicator for a common tree node stream - * \remark if a custom stream is created but it can be treated as - * a common tree node stream, then you may OR in this value to your type indicator - */ -#define ANTLR3_COMMONTREENODE 0x0004 - -/** Type mask for input stream so we can switch in the above types - * \remark DO NOT USE 0x0000 as a stream type! - */ -#define ANTLR3_INPUT_MASK 0x0007 - -#ifdef __cplusplus -extern "C" { -#endif - -typedef struct ANTLR3_INT_STREAM_struct -{ - /** Input stream type indicator. Sometimes useful for error reporting etc. - */ - ANTLR3_UINT32 type; - - /** Potentially useful in error reporting and so on, this string is - * an identification of the input source. It may be NULL, so anything - * attempting to access it needs to check this and substitute a sensible - * default. - */ - pANTLR3_STRING streamName; - - /** Pointer to the super structure that contains this interface. This - * will usually be a token stream or a tree stream. - */ - void * super; - - /** Last marker position allocated - */ - ANTLR3_MARKER lastMarker; - - // Return a string that identifies the input source - // - pANTLR3_STRING (*getSourceName) (struct ANTLR3_INT_STREAM_struct * intStream); - - /** Consume the next 'ANTR3_UINT32' in the stream - */ - void (*consume) (struct ANTLR3_INT_STREAM_struct * intStream); - - /** Get ANTLR3_UINT32 at current input pointer + i ahead where i=1 is next ANTLR3_UINT32 - */ - ANTLR3_UINT32 (*_LA) (struct ANTLR3_INT_STREAM_struct * intStream, ANTLR3_INT32 i); - - /** Tell the stream to start buffering if it hasn't already. Return - * current input position, index(), or some other marker so that - * when passed to rewind() you get back to the same spot. - * rewind(mark()) should not affect the input cursor. - */ - ANTLR3_MARKER (*mark) (struct ANTLR3_INT_STREAM_struct * intStream); - - /** Return the current input symbol index 0..n where n indicates the - * last symbol has been read. - */ - ANTLR3_MARKER (*index) (struct ANTLR3_INT_STREAM_struct * intStream); - - /** Reset the stream so that next call to index would return marker. - * The marker will usually be index() but it doesn't have to be. It's - * just a marker to indicate what state the stream was in. This is - * essentially calling release() and seek(). If there are markers - * created after this marker argument, this routine must unroll them - * like a stack. Assume the state the stream was in when this marker - * was created. - */ - void (*rewind) (struct ANTLR3_INT_STREAM_struct * intStream, ANTLR3_MARKER marker); - - /** Reset the stream to the last marker position, witouh destryoing the - * last marker position. - */ - void (*rewindLast) (struct ANTLR3_INT_STREAM_struct * intStream); - - /** You may want to commit to a backtrack but don't want to force the - * stream to keep bookkeeping objects around for a marker that is - * no longer necessary. This will have the same behavior as - * rewind() except it releases resources without the backward seek. - */ - void (*release) (struct ANTLR3_INT_STREAM_struct * intStream, ANTLR3_MARKER mark); - - /** Set the input cursor to the position indicated by index. This is - * normally used to seek ahead in the input stream. No buffering is - * required to do this unless you know your stream will use seek to - * move backwards such as when backtracking. - * - * This is different from rewind in its multi-directional - * requirement and in that its argument is strictly an input cursor (index). - * - * For char streams, seeking forward must update the stream state such - * as line number. For seeking backwards, you will be presumably - * backtracking using the mark/rewind mechanism that restores state and - * so this method does not need to update state when seeking backwards. - * - * Currently, this method is only used for efficient backtracking, but - * in the future it may be used for incremental parsing. - */ - void (*seek) (struct ANTLR3_INT_STREAM_struct * intStream, ANTLR3_MARKER index); - - /** Only makes sense for streams that buffer everything up probably, but - * might be useful to display the entire stream or for testing. - */ - ANTLR3_UINT32 (*size) (struct ANTLR3_INT_STREAM_struct * intStream); - - /** Because the indirect call, though small in individual cases can - * mount up if there are thousands of tokens (very large input streams), callers - * of size can optionally use this cached size field. - */ - ANTLR3_UINT32 cachedSize; - - /** Frees any resources that were allocated for the implementation of this - * interface. Usually this is just releasing the memory allocated - * for the structure itself, but it may of course do anything it need to - * so long as it does not stamp on anything else. - */ - void (*free) (struct ANTLR3_INT_STREAM_struct * stream); - -} - ANTLR3_INT_STREAM; - -#ifdef __cplusplus -} -#endif - -#endif - diff --git a/impl/antlr/libantlr3c-3.4/include/antlr3lexer.h b/impl/antlr/libantlr3c-3.4/include/antlr3lexer.h deleted file mode 100644 index 6cc10ef..0000000 --- a/impl/antlr/libantlr3c-3.4/include/antlr3lexer.h +++ /dev/null @@ -1,193 +0,0 @@ -/** \file - * Base interface for any ANTLR3 lexer. - * - * An ANLTR3 lexer builds from two sets of components: - * - * - The runtime components that provide common functionality such as - * traversing character streams, building tokens for output and so on. - * - The generated rules and struutre of the actual lexer, which call upon the - * runtime components. - * - * A lexer class contains a character input stream, a base recognizer interface - * (which it will normally implement) and a token source interface (which it also - * implements. The Tokensource interface is called by a token consumer (such as - * a parser, but in theory it can be anything that wants a set of abstract - * tokens in place of a raw character stream. - * - * So then, we set up a lexer in a sequence akin to: - * - * - Create a character stream (something which implements ANTLR3_INPUT_STREAM) - * and initialize it. - * - Create a lexer interface and tell it where it its input stream is. - * This will cause the creation of a base recognizer class, which it will - * override with its own implementations of some methods. The lexer creator - * can also then in turn override anything it likes. - * - The lexer token source interface is then passed to some interface that - * knows how to use it, byte calling for a next token. - * - When a next token is called, let ze lexing begin. - * - */ -#ifndef _ANTLR3_LEXER -#define _ANTLR3_LEXER - -// [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. - -/* Definitions - */ -#define ANTLR3_STRING_TERMINATOR 0xFFFFFFFF - -#include <antlr3defs.h> -#include <antlr3input.h> -#include <antlr3commontoken.h> -#include <antlr3tokenstream.h> -#include <antlr3baserecognizer.h> - -#ifdef __cplusplus -extern "C" { -#endif - -typedef struct ANTLR3_LEXER_struct -{ - /** If there is a super structure that is implementing the - * lexer, then a pointer to it can be stored here in case - * implementing functions are overridden by this super structure. - */ - void * super; - - /** A generated lexer has an mTokens() function, which needs - * the context pointer of the generated lexer, not the base lexer interface - * this is stored here and initialized by the generated code (or manually - * if this is a manually built lexer. - */ - void * ctx; - - /** A pointer to the character stream whence this lexer is receiving - * characters. - * TODO: I may come back to this and implement charstream outside - * the input stream as per the java implementation. - */ - pANTLR3_INPUT_STREAM input; - - /** Pointer to the implementation of a base recognizer, which the lexer - * creates and then overrides with its own lexer oriented functions (the - * default implementation is parser oriented). This also contains a - * token source interface, which the lexer instance will provide to anything - * that needs it, which is anything else that implements a base recognizer, - * such as a parser. - */ - pANTLR3_BASE_RECOGNIZER rec; - - /** Pointer to a function that sets the charstream source for the lexer and - * causes it to be reset. - */ - void (*setCharStream) (struct ANTLR3_LEXER_struct * lexer, pANTLR3_INPUT_STREAM input); - - /** Pointer to a function that switches the current character input stream to - * a new one, saving the old one, which we will revert to at the end of this - * new one. - */ - void (*pushCharStream) (struct ANTLR3_LEXER_struct * lexer, pANTLR3_INPUT_STREAM input); - - /** Pointer to a function that abandons the current input stream, whether it - * is empty or not and reverts to the previous stacked input stream. - */ - void (*popCharStream) (struct ANTLR3_LEXER_struct * lexer); - - /** Pointer to a function that emits the supplied token as the next token in - * the stream. - */ - void (*emitNew) (struct ANTLR3_LEXER_struct * lexer, pANTLR3_COMMON_TOKEN token); - - /** Pointer to a function that constructs a new token from the lexer stored information - */ - pANTLR3_COMMON_TOKEN (*emit) (struct ANTLR3_LEXER_struct * lexer); - - /** Pointer to the user provided (either manually or through code generation - * function that causes the lexer rules to run the lexing rules and produce - * the next token if there iss one. This is called from nextToken() in the - * pANTLR3_TOKEN_SOURCE. Note that the input parameter for this funciton is - * the generated lexer context (stored in ctx in this interface) it is a generated - * function and expects the context to be the generated lexer. - */ - void (*mTokens) (void * ctx); - - /** Pointer to a function that attempts to match and consume the specified string from the input - * stream. Note that strings muse be passed as terminated arrays of ANTLR3_UCHAR. Strings are terminated - * with 0xFFFFFFFF, which is an invalid UTF32 character - */ - ANTLR3_BOOLEAN (*matchs) (struct ANTLR3_LEXER_struct * lexer, ANTLR3_UCHAR * string); - - /** Pointer to a function that matches and consumes the specified character from the input stream. - * The input stream is required to provide characters via LA() as UTF32 characters. The default lexer - * implementation is source encoding agnostic and so input streams do not generally need to - * override the default implmentation. - */ - ANTLR3_BOOLEAN (*matchc) (struct ANTLR3_LEXER_struct * lexer, ANTLR3_UCHAR c); - - /** Pointer to a function that matches any character in the supplied range (I suppose it could be a token range too - * but this would only be useful if the tokens were in tsome guaranteed order which is - * only going to happen with a hand crafted token set). - */ - ANTLR3_BOOLEAN (*matchRange) (struct ANTLR3_LEXER_struct * lexer, ANTLR3_UCHAR low, ANTLR3_UCHAR high); - - /** Pointer to a function that matches the next token/char in the input stream - * regardless of what it actaully is. - */ - void (*matchAny) (struct ANTLR3_LEXER_struct * lexer); - - /** Pointer to a function that recovers from an error found in the input stream. - * Generally, this will be a #ANTLR3_EXCEPTION_NOVIABLE_ALT but it could also - * be from a mismatched token that the (*match)() could not recover from. - */ - void (*recover) (struct ANTLR3_LEXER_struct * lexer); - - /** Pointer to function to return the current line number in the input stream - */ - ANTLR3_UINT32 (*getLine) (struct ANTLR3_LEXER_struct * lexer); - ANTLR3_MARKER (*getCharIndex) (struct ANTLR3_LEXER_struct * lexer); - ANTLR3_UINT32 (*getCharPositionInLine)(struct ANTLR3_LEXER_struct * lexer); - - /** Pointer to function to return the text so far for the current token being generated - */ - pANTLR3_STRING (*getText) (struct ANTLR3_LEXER_struct * lexer); - - - /** Pointer to a function that knows how to free the resources of a lexer - */ - void (*free) (struct ANTLR3_LEXER_struct * lexer); - -} - ANTLR3_LEXER; - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/impl/antlr/libantlr3c-3.4/include/antlr3memory.h b/impl/antlr/libantlr3c-3.4/include/antlr3memory.h deleted file mode 100644 index 5e2d4c9..0000000 --- a/impl/antlr/libantlr3c-3.4/include/antlr3memory.h +++ /dev/null @@ -1,36 +0,0 @@ -#ifndef _ANTLR3MEMORY_H -#define _ANTLR3MEMORY_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> - - -#endif /* _ANTLR3MEMORY_H */ diff --git a/impl/antlr/libantlr3c-3.4/include/antlr3parser.h b/impl/antlr/libantlr3c-3.4/include/antlr3parser.h deleted file mode 100644 index 95b7d18..0000000 --- a/impl/antlr/libantlr3c-3.4/include/antlr3parser.h +++ /dev/null @@ -1,93 +0,0 @@ -/** \file - * Base implementation of an ANTLR3 parser. - * - * - */ -#ifndef _ANTLR3_PARSER_H -#define _ANTLR3_PARSER_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 <antlr3baserecognizer.h> - -#ifdef __cplusplus -extern "C" { -#endif - -/** This is the main interface for an ANTLR3 parser. - */ -typedef struct ANTLR3_PARSER_struct -{ - /** All superstructure implementers of this interface require a pointer to their selves, - * which they can reference using the super pointer here. - */ - void * super; - - /** A pointer to the base recognizer, where most of the parser functions actually - * live because they are shared between parser and tree parser and this is the - * easier way than copying the interface all over the place. Macros hide this - * for the generated code so it is easier on the eye (though not the debugger ;-). - */ - pANTLR3_BASE_RECOGNIZER rec; - - /** A provider of a tokenstream interface, for the parser to consume - * tokens from. - */ - pANTLR3_TOKEN_STREAM tstream; - - /** A pointer to a function that installs a debugger object (it also - * installs the debugging versions of the parser methods. This means that - * a non debug parser incurs no overhead because of the debugging stuff. - */ - void (*setDebugListener) (struct ANTLR3_PARSER_struct * parser, pANTLR3_DEBUG_EVENT_LISTENER dbg); - - /** A pointer to a function that installs a token stream - * for the parser. - */ - void (*setTokenStream) (struct ANTLR3_PARSER_struct * parser, pANTLR3_TOKEN_STREAM); - - /** A pointer to a function that returns the token stream for this - * parser. - */ - pANTLR3_TOKEN_STREAM (*getTokenStream) (struct ANTLR3_PARSER_struct * parser); - - /** Pointer to a function that knows how to free resources of an ANTLR3 parser. - */ - void (*free) (struct ANTLR3_PARSER_struct * parser); - -} - ANTLR3_PARSER; - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/impl/antlr/libantlr3c-3.4/include/antlr3parsetree.h b/impl/antlr/libantlr3c-3.4/include/antlr3parsetree.h deleted file mode 100644 index 0e8c157..0000000 --- a/impl/antlr/libantlr3c-3.4/include/antlr3parsetree.h +++ /dev/null @@ -1,85 +0,0 @@ -/** \file - * Abstraction of Common tree to provide payload and string representation of node. - * - * \todo May not need this in the end - */ - -#ifndef ANTLR3_PARSETREE_H -#define ANTLR3_PARSETREE_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 <antlr3basetree.h> - -#ifdef __cplusplus -extern "C" { -#endif - -typedef struct ANTLR3_PARSE_TREE_struct -{ - /** Any interface that implements methods in this interface - * may need to point back to itself using this pointer to its - * super structure. - */ - void * super; - - /** The payload that the parse tree node passes around - */ - void * payload; - - /** An encapsulated BASE TREE strcuture (NOT a pointer) - * that perfoms a lot of the dirty work of node management - */ - ANTLR3_BASE_TREE baseTree; - - /** How to dup this node - */ - pANTLR3_BASE_TREE (*dupNode) (struct ANTLR3_PARSE_TREE_struct * tree); - - /** Return the type of this node - */ - ANTLR3_UINT32 (*getType) (struct ANTLR3_PARSE_TREE_struct * tree); - - /** Return the string representation of the payload (must be installed - * when the payload is added and point to a function that knwos how to - * manifest a pANTLR3_STRING from a node. - */ - pANTLR3_STRING (*toString) (struct ANTLR3_PARSE_TREE_struct * payload); - - void (*free) (struct ANTLR3_PARSE_TREE_struct * tree); - -} - ANTLR3_PARSE_TREE; - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/impl/antlr/libantlr3c-3.4/include/antlr3recognizersharedstate.h b/impl/antlr/libantlr3c-3.4/include/antlr3recognizersharedstate.h deleted file mode 100644 index 9e024d8..0000000 --- a/impl/antlr/libantlr3c-3.4/include/antlr3recognizersharedstate.h +++ /dev/null @@ -1,218 +0,0 @@ -/** \file - * While the C runtime does not need to model the state of - * multiple lexers and parsers in the same way as the Java runtime does - * it is no overhead to reflect that model. In fact the - * C runtime has always been able to share recognizer state. - * - * This 'class' therefore defines all the elements of a recognizer - * (either lexer, parser or tree parser) that are need to - * track the current recognition state. Multiple recognizers - * may then share this state, for instance when one grammar - * imports another. - */ - -#ifndef _ANTLR3_RECOGNIZER_SHARED_STATE_H -#define _ANTLR3_RECOGNIZER_SHARED_STATE_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> - -#ifdef __cplusplus -extern "C" { -#endif - -/** All the data elements required to track the current state - * of any recognizer (lexer, parser, tree parser). - * May be share between multiple recognizers such that - * grammar inheritance is easily supported. - */ -typedef struct ANTLR3_RECOGNIZER_SHARED_STATE_struct -{ - /** If set to ANTLR3_TRUE then the recognizer has an exception - * condition (this is tested by the generated code for the rules of - * the grammar). - */ - ANTLR3_BOOLEAN error; - - /** Points to the first in a possible chain of exceptions that the - * recognizer has discovered. - */ - pANTLR3_EXCEPTION exception; - - /** Track around a hint from the creator of the recognizer as to how big this - * thing is going to get, as the actress said to the bishop. This allows us - * to tune hash tables accordingly. This might not be the best place for this - * in the end but we will see. - */ - ANTLR3_UINT32 sizeHint; - - /** Track the set of token types that can follow any rule invocation. - * Stack structure, to support: List<BitSet>. - */ - pANTLR3_STACK following; - - - /** This is true when we see an error and before having successfully - * matched a token. Prevents generation of more than one error message - * per error. - */ - ANTLR3_BOOLEAN errorRecovery; - - /** The index into the input stream where the last error occurred. - * This is used to prevent infinite loops where an error is found - * but no token is consumed during recovery...another error is found, - * ad nauseam. This is a failsafe mechanism to guarantee that at least - * one token/tree node is consumed for two errors. - */ - ANTLR3_MARKER lastErrorIndex; - - /** In lieu of a return value, this indicates that a rule or token - * has failed to match. Reset to false upon valid token match. - */ - ANTLR3_BOOLEAN failed; - - /** When the recognizer terminates, the error handling functions - * will have incremented this value if any error occurred (that was displayed). It can then be - * used by the grammar programmer without having to use static globals. - */ - ANTLR3_UINT32 errorCount; - - /** If 0, no backtracking is going on. Safe to exec actions etc... - * If >0 then it's the level of backtracking. - */ - ANTLR3_INT32 backtracking; - - /** ANTLR3_VECTOR of ANTLR3_LIST for rule memoizing. - * Tracks the stop token index for each rule. ruleMemo[ruleIndex] is - * the memoization table for ruleIndex. For key ruleStartIndex, you - * get back the stop token for associated rule or MEMO_RULE_FAILED. - * - * This is only used if rule memoization is on. - */ - pANTLR3_INT_TRIE ruleMemo; - - /** Pointer to an array of token names - * that are generally useful in error reporting. The generated parsers install - * this pointer. The table it points to is statically allocated as 8 bit ascii - * at parser compile time - grammar token names are thus restricted in character - * sets, which does not seem to terrible. - */ - pANTLR3_UINT8 * tokenNames; - - /** User programmable pointer that can be used for instance as a place to - * store some tracking structure specific to the grammar that would not normally - * be available to the error handling functions. - */ - void * userp; - - /** The goal of all lexer rules/methods is to create a token object. - * This is an instance variable as multiple rules may collaborate to - * create a single token. For example, NUM : INT | FLOAT ; - * In this case, you want the INT or FLOAT rule to set token and not - * have it reset to a NUM token in rule NUM. - */ - pANTLR3_COMMON_TOKEN token; - - /** The goal of all lexer rules being to create a token, then a lexer - * needs to build a token factory to create them. - */ - pANTLR3_TOKEN_FACTORY tokFactory; - - /** A lexer is a source of tokens, produced by all the generated (or - * hand crafted if you like) matching rules. As such it needs to provide - * a token source interface implementation. - */ - pANTLR3_TOKEN_SOURCE tokSource; - - /** The channel number for the current token - */ - ANTLR3_UINT32 channel; - - /** The token type for the current token - */ - ANTLR3_UINT32 type; - - /** The input line (where it makes sense) on which the first character of the current - * token resides. - */ - ANTLR3_INT32 tokenStartLine; - - /** The character position of the first character of the current token - * within the line specified by tokenStartLine - */ - ANTLR3_INT32 tokenStartCharPositionInLine; - - /** What character index in the stream did the current token start at? - * Needed, for example, to get the text for current token. Set at - * the start of nextToken. - */ - ANTLR3_MARKER tokenStartCharIndex; - - /** Text for the current token. This can be overridden by setting this - * variable directly or by using the SETTEXT() macro (preferred) in your - * lexer rules. - */ - pANTLR3_STRING text; - - /** User controlled variables that will be installed in a newly created - * token. - */ - ANTLR3_UINT32 user1, user2, user3; - void * custom; - - /** Input stream stack, which allows the C programmer to switch input streams - * easily and allow the standard nextToken() implementation to deal with it - * as this is a common requirement. - */ - pANTLR3_STACK streams; - - /// A stack of token/tree rewrite streams that are available for use - /// by a parser or tree parser that is using rewrites to generate - /// an AST. This saves each rule in the recongizer from having to - /// allocate and deallocate rewtire streams on entry and exit. As - /// the parser recurses throgh the rules it will reach a steady state - /// of the maximum number of allocated streams, which instead of - /// deallocating them at rule exit, it will place on this stack for - /// reuse. The streams are then all finally freed when this stack - /// is freed. - /// - pANTLR3_VECTOR rStreams; - -} - ANTLR3_RECOGNIZER_SHARED_STATE; - -#ifdef __cplusplus -} -#endif - -#endif - - diff --git a/impl/antlr/libantlr3c-3.4/include/antlr3rewritestreams.h b/impl/antlr/libantlr3c-3.4/include/antlr3rewritestreams.h deleted file mode 100644 index bf83fe9..0000000 --- a/impl/antlr/libantlr3c-3.4/include/antlr3rewritestreams.h +++ /dev/null @@ -1,180 +0,0 @@ -#ifndef ANTLR3REWRITESTREAM_H -#define ANTLR3REWRITESTREAM_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 <antlr3collections.h> -#include <antlr3commontreeadaptor.h> -#include <antlr3baserecognizer.h> - -#ifdef __cplusplus -extern "C" { -#endif - -/// A generic list of elements tracked in an alternative to be used in -/// a -> rewrite rule. -/// -/// In the C implementation, all tree oriented streams return a pointer to -/// the same type: pANTLR3_BASE_TREE. Anything that has subclassed from this -/// still passes this type, within which there is a super pointer, which points -/// to it's own data and methods. Hence we do not need to implement this as -/// the equivalent of an abstract class, but just fill in the appropriate interface -/// as usual with this model. -/// -/// Once you start next()ing, do not try to add more elements. It will -/// break the cursor tracking I believe. -/// -/// -/// \see #pANTLR3_REWRITE_RULE_NODE_STREAM -/// \see #pANTLR3_REWRITE_RULE_ELEMENT_STREAM -/// \see #pANTLR3_REWRITE_RULE_SUBTREE_STREAM -/// -/// TODO: add mechanism to detect/puke on modification after reading from stream -/// -typedef struct ANTLR3_REWRITE_RULE_ELEMENT_STREAM_struct -{ - - /// Cursor 0..n-1. If singleElement!=NULL, cursor is 0 until you next(), - /// which bumps it to 1 meaning no more elements. - /// - ANTLR3_UINT32 cursor; - - /// Track single elements w/o creating a list. Upon 2nd add, alloc list - /// - void * singleElement; - - /// The list of tokens or subtrees we are tracking - /// - pANTLR3_VECTOR elements; - - /// Indicates whether we should free the vector or it was supplied to us - /// - ANTLR3_BOOLEAN freeElements; - - /// The element or stream description; usually has name of the token or - /// rule reference that this list tracks. Can include rulename too, but - /// the exception would track that info. - /// - void * elementDescription; - - /// Pointer to the tree adaptor in use for this stream - /// - pANTLR3_BASE_TREE_ADAPTOR adaptor; - - /// Once a node / subtree has been used in a stream, it must be dup'ed - /// from then on. Streams are reset after sub rules so that the streams - /// can be reused in future sub rules. So, reset must set a dirty bit. - /// If dirty, then next() always returns a dup. - /// - ANTLR3_BOOLEAN dirty; - - // Pointer to the recognizer shared state to which this stream belongs - // - pANTLR3_BASE_RECOGNIZER rec; - - // Methods - - /// Reset the condition of this stream so that it appears we have - /// not consumed any of its elements. Elements themselves are untouched. - /// - void (*reset) (struct ANTLR3_REWRITE_RULE_ELEMENT_STREAM_struct * stream); - - /// Add a new pANTLR3_BASE_TREE to this stream - /// - void (*add) (struct ANTLR3_REWRITE_RULE_ELEMENT_STREAM_struct * stream, void *el, void (ANTLR3_CDECL *freePtr)(void *)); - - /// Return the next element in the stream. If out of elements, throw - /// an exception unless size()==1. If size is 1, then return elements[0]. - /// - void * (*next) (struct ANTLR3_REWRITE_RULE_ELEMENT_STREAM_struct * stream); - pANTLR3_BASE_TREE (*nextTree) (struct ANTLR3_REWRITE_RULE_ELEMENT_STREAM_struct * stream); - void * (*nextToken) (struct ANTLR3_REWRITE_RULE_ELEMENT_STREAM_struct * stream); - void * (*_next) (struct ANTLR3_REWRITE_RULE_ELEMENT_STREAM_struct * stream); - - /// When constructing trees, sometimes we need to dup a token or AST - /// subtree. Dup'ing a token means just creating another AST node - /// around it. For trees, you must call the adaptor.dupTree(). - /// - void * (*dup) (struct ANTLR3_REWRITE_RULE_ELEMENT_STREAM_struct * stream, void * el); - - /// Ensure stream emits trees; tokens must be converted to AST nodes. - /// AST nodes can be passed through unmolested. - /// - pANTLR3_BASE_TREE (*toTree) (struct ANTLR3_REWRITE_RULE_ELEMENT_STREAM_struct * stream, void * el); - - /// Returns ANTLR3_TRUE if there is a next element available - /// - ANTLR3_BOOLEAN (*hasNext) (struct ANTLR3_REWRITE_RULE_ELEMENT_STREAM_struct * stream); - - /// Treat next element as a single node even if it's a subtree. - /// This is used instead of next() when the result has to be a - /// tree root node. Also prevents us from duplicating recently-added - /// children; e.g., ^(type ID)+ adds ID to type and then 2nd iteration - /// must dup the type node, but ID has been added. - /// - /// Referencing to a rule result twice is ok; dup entire tree as - /// we can't be adding trees; e.g., expr expr. - /// - pANTLR3_BASE_TREE (*nextNode) (struct ANTLR3_REWRITE_RULE_ELEMENT_STREAM_struct * stream); - - /// Number of elements available in the stream - /// - ANTLR3_UINT32 (*size) (struct ANTLR3_REWRITE_RULE_ELEMENT_STREAM_struct * stream); - - /// Returns the description string if there is one available (check for NULL). - /// - void * (*getDescription) (struct ANTLR3_REWRITE_RULE_ELEMENT_STREAM_struct * stream); - - void (*free) (struct ANTLR3_REWRITE_RULE_ELEMENT_STREAM_struct * stream); - -} - ANTLR3_REWRITE_RULE_ELEMENT_STREAM; - -/// This is an implementation of a token stream, which is basically an element -/// stream that deals with tokens only. -/// -typedef struct ANTLR3_REWRITE_RULE_ELEMENT_STREAM_struct ANTLR3_REWRITE_RULE_TOKEN_STREAM; - -/// This is an implementation of a subtree stream which is a set of trees -/// modelled as an element stream. -/// -typedef struct ANTLR3_REWRITE_RULE_ELEMENT_STREAM_struct ANTLR3_REWRITE_RULE_SUBTREE_STREAM; - -/// This is an implementation of a node stream, which is basically an element -/// stream that deals with tree nodes only. -/// -typedef struct ANTLR3_REWRITE_RULE_ELEMENT_STREAM_struct ANTLR3_REWRITE_RULE_NODE_STREAM; - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/impl/antlr/libantlr3c-3.4/include/antlr3string.h b/impl/antlr/libantlr3c-3.4/include/antlr3string.h deleted file mode 100644 index 4a96e76..0000000 --- a/impl/antlr/libantlr3c-3.4/include/antlr3string.h +++ /dev/null @@ -1,272 +0,0 @@ -/** \file - * Simple string interface allows indiscriminate allocation of strings - * such that they can be allocated all over the place and released in - * one chunk via a string factory - saves lots of hassle in remembering what - * strings were allocated where. - */ -#ifndef _ANTLR3_STRING_H -#define _ANTLR3_STRING_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 <antlr3collections.h> - -#ifdef __cplusplus -extern "C" { -#endif - -/** Base string class tracks the allocations and provides simple string - * tracking functions. Mostly you can work directly on the string for things - * that don't reallocate it, like strchr() etc. Perhaps someone will want to provide implementations for UTF8 - * and so on. - */ -typedef struct ANTLR3_STRING_struct -{ - - /** The factory that created this string - */ - pANTLR3_STRING_FACTORY factory; - - /** Pointer to the current string value (starts at NULL unless - * the string allocator is told to create it with a pre known size. - */ - pANTLR3_UINT8 chars; - - /** Current length of the string up to and not including, the trailing '\0' - * Note that the actual allocation (->size) - * is always at least one byte more than this to accommodate trailing '\0' - */ - ANTLR3_UINT32 len; - - /** Current size of the string in bytes including the trailing '\0' - */ - ANTLR3_UINT32 size; - - /** Index of string (allocation number) in case someone wants - * to explicitly release it. - */ - ANTLR3_UINT32 index; - - /** Occasionally it is useful to know what the encoding of the string - * actually is, hence it is stored here as one the ANTLR3_ENCODING_ values - */ - ANTLR3_UINT8 encoding; - - /** Pointer to function that sets the string value to a specific string in the default encoding - * for this string. For instance, if this is 8 bit, then this function is the same as set8 - * but if the encoding is UTF16, then the pointer is assumed to point to UTF16 characters, not - * 8 bit. - */ - pANTLR3_UINT8 (*set) (struct ANTLR3_STRING_struct * string, const char * chars); - - /** Pointer to function that sets the string value to a specific 8 bit string in the default encoding - * for this string. For instance, if this is an 8 bit string, then this function is the same as set8 - * but if the encoding is UTF16, then the pointer is assumed to point to 8 bit characters that must - * be converted to UTF16 characters on the fly. - */ - pANTLR3_UINT8 (*set8) (struct ANTLR3_STRING_struct * string, const char * chars); - - /** Pointer to function adds a raw char * type pointer in the default encoding - * for this string. For instance, if this is 8 bit, then this function is the same as append8 - * but if the encoding is UTF16, then the pointer is assumed to point to UTF16 characters not - * 8 bit. - */ - pANTLR3_UINT8 (*append) (struct ANTLR3_STRING_struct * string, const char * newbit); - - /** Pointer to function adds a raw char * type pointer in the default encoding - * for this string. For instance, if this is a UTF16 string, then this function assumes the pointer - * points to 8 bit characters that must be converted on the fly. - */ - pANTLR3_UINT8 (*append8) (struct ANTLR3_STRING_struct * string, const char * newbit); - - /** Pointer to function that inserts the supplied string at the specified - * offset in the current string in the default encoding for this string. For instance, if this is an 8 - * bit string, then this is the same as insert8, but if this is a UTF16 string, then the pointer - * must point to UTF16 characters. - */ - pANTLR3_UINT8 (*insert) (struct ANTLR3_STRING_struct * string, ANTLR3_UINT32 point, const char * newbit); - - /** Pointer to function that inserts the supplied string at the specified - * offset in the current string in the default encoding for this string. For instance, if this is a UTF16 string - * then the pointer is assumed to point at 8 bit characteres that must be converted on the fly. - */ - pANTLR3_UINT8 (*insert8) (struct ANTLR3_STRING_struct * string, ANTLR3_UINT32 point, const char * newbit); - - /** Pointer to function that sets the string value to a copy of the supplied string (strings must be in the - * same encoding. - */ - pANTLR3_UINT8 (*setS) (struct ANTLR3_STRING_struct * string, struct ANTLR3_STRING_struct * chars); - - /** Pointer to function appends a copy of the characters contained in another string. Strings must be in the - * same encoding. - */ - pANTLR3_UINT8 (*appendS) (struct ANTLR3_STRING_struct * string, struct ANTLR3_STRING_struct * newbit); - - /** Pointer to function that inserts a copy of the characters in the supplied string at the specified - * offset in the current string. strings must be in the same encoding. - */ - pANTLR3_UINT8 (*insertS) (struct ANTLR3_STRING_struct * string, ANTLR3_UINT32 point, struct ANTLR3_STRING_struct * newbit); - - /** Pointer to function that inserts the supplied integer in string form at the specified - * offset in the current string. - */ - pANTLR3_UINT8 (*inserti) (struct ANTLR3_STRING_struct * string, ANTLR3_UINT32 point, ANTLR3_INT32 i); - - /** Pointer to function that adds a single character to the end of the string, in the encoding of the - * string - 8 bit, UTF16, utf-8 etc. Input is a single UTF32 (32 bits wide integer) character. - */ - pANTLR3_UINT8 (*addc) (struct ANTLR3_STRING_struct * string, ANTLR3_UINT32 c); - - /** Pointer to function that adds the stringified representation of an integer - * to the string. - */ - pANTLR3_UINT8 (*addi) (struct ANTLR3_STRING_struct * string, ANTLR3_INT32 i); - - /** Pointer to function that compares the text of a string to the supplied - * 8 bit character string and returns a result a la strcmp() - */ - ANTLR3_UINT32 (*compare8) (struct ANTLR3_STRING_struct * string, const char * compStr); - - /** Pointer to a function that compares the text of a string with the supplied character string - * (which is assumed to be in the same encoding as the string itself) and returns a result - * a la strcmp() - */ - ANTLR3_UINT32 (*compare) (struct ANTLR3_STRING_struct * string, const char * compStr); - - /** Pointer to a function that compares the text of a string with the supplied string - * (which is assumed to be in the same encoding as the string itself) and returns a result - * a la strcmp() - */ - ANTLR3_UINT32 (*compareS) (struct ANTLR3_STRING_struct * string, struct ANTLR3_STRING_struct * compStr); - - /** Pointer to a function that returns the character indexed at the supplied - * offset as a 32 bit character. - */ - ANTLR3_UCHAR (*charAt) (struct ANTLR3_STRING_struct * string, ANTLR3_UINT32 offset); - - /** Pointer to a function that returns a substring of the supplied string a la .subString(s,e) - * in the Java language. - */ - struct ANTLR3_STRING_struct * - (*subString) (struct ANTLR3_STRING_struct * string, ANTLR3_UINT32 startIndex, ANTLR3_UINT32 endIndex); - - /** Pointer to a function that returns the integer representation of any numeric characters - * at the beginning of the string - */ - ANTLR3_INT32 (*toInt32) (struct ANTLR3_STRING_struct * string); - - /** Pointer to a function that yields an 8 bit string regardless of the encoding of the supplied - * string. This is useful when you want to use the text of a token in some way that requires an 8 bit - * value, such as the key for a hashtable. The function is required to produce a usable string even - * if the text given as input has characters that do not fit in 8 bit space, it will replace them - * with some arbitrary character such as '?' - */ - struct ANTLR3_STRING_struct * - (*to8) (struct ANTLR3_STRING_struct * string); - - /// Pointer to a function that yields a UT8 encoded string of the current string, - /// regardless of the current encoding of the string. Because there is currently no UTF8 - /// handling in the string class, it creates therefore, a string that is useful only for read only - /// applications as it will not contain methods that deal with UTF8 at the moment. - /// - struct ANTLR3_STRING_struct * - (*toUTF8) (struct ANTLR3_STRING_struct * string); - -} - ANTLR3_STRING; - -/** Definition of the string factory interface, which creates and tracks - * strings for you of various shapes and sizes. - */ -typedef struct ANTLR3_STRING_FACTORY_struct -{ - /** List of all the strings that have been allocated by the factory - */ - pANTLR3_VECTOR strings; - - /* Index of next string that we allocate - */ - ANTLR3_UINT32 index; - - /** Pointer to function that manufactures an empty string - */ - pANTLR3_STRING (*newRaw) (struct ANTLR3_STRING_FACTORY_struct * factory); - - /** Pointer to function that manufactures a raw string with no text in it but space for size - * characters. - */ - pANTLR3_STRING (*newSize) (struct ANTLR3_STRING_FACTORY_struct * factory, ANTLR3_UINT32 size); - - /** Pointer to function that manufactures a string from a given pointer and length. The pointer is assumed - * to point to characters in the same encoding as the string type, hence if this is a UTF16 string the - * pointer should point to UTF16 characters. - */ - pANTLR3_STRING (*newPtr) (struct ANTLR3_STRING_FACTORY_struct * factory, pANTLR3_UINT8 string, ANTLR3_UINT32 size); - - /** Pointer to function that manufactures a string from a given pointer and length. The pointer is assumed to - * point at 8 bit characters which must be converted on the fly to the encoding of the actual string. - */ - pANTLR3_STRING (*newPtr8) (struct ANTLR3_STRING_FACTORY_struct * factory, pANTLR3_UINT8 string, ANTLR3_UINT32 size); - - /** Pointer to function that manufactures a string from a given pointer and works out the length. The pointer is - * assumed to point to characters in the same encoding as the string itself, i.e. UTF16 if a UTF16 - * string and so on. - */ - pANTLR3_STRING (*newStr) (struct ANTLR3_STRING_FACTORY_struct * factory, pANTLR3_UINT8 string); - - /** Pointer to function that manufactures a string from a given pointer and length. The pointer should - * point to 8 bit characters regardless of the actual encoding of the string. The 8 bit characters - * will be converted to the actual string encoding on the fly. - */ - pANTLR3_STRING (*newStr8) (struct ANTLR3_STRING_FACTORY_struct * factory, pANTLR3_UINT8 string); - - /** Pointer to function that deletes the string altogether - */ - void (*destroy) (struct ANTLR3_STRING_FACTORY_struct * factory, pANTLR3_STRING string); - - /** Pointer to function that returns a copy of the string in printable form without any control - * characters in it. - */ - pANTLR3_STRING (*printable)(struct ANTLR3_STRING_FACTORY_struct * factory, pANTLR3_STRING string); - - /** Pointer to function that closes the factory - */ - void (*close) (struct ANTLR3_STRING_FACTORY_struct * factory); - -} - ANTLR3_STRING_FACTORY; - -#ifdef __cplusplus -} -#endif - -#endif - diff --git a/impl/antlr/libantlr3c-3.4/include/antlr3tokenstream.h b/impl/antlr/libantlr3c-3.4/include/antlr3tokenstream.h deleted file mode 100644 index a5137ad..0000000 --- a/impl/antlr/libantlr3c-3.4/include/antlr3tokenstream.h +++ /dev/null @@ -1,303 +0,0 @@ -/** \file - * Defines the interface for an ANTLR3 common token stream. Custom token streams should create - * one of these and then override any functions by installing their own pointers - * to implement the various functions. - */ -#ifndef _ANTLR3_TOKENSTREAM_H -#define _ANTLR3_TOKENSTREAM_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 <antlr3collections.h> -#include <antlr3input.h> -#include <antlr3commontoken.h> -#include <antlr3bitset.h> -#include <antlr3debugeventlistener.h> - -#ifdef __cplusplus -extern "C" { -#endif - -/** Definition of a token source, which has a pointer to a function that - * returns the next token (using a token factory if it is going to be - * efficient) and a pointer to an ANTLR3_INPUT_STREAM. This is slightly - * different to the Java interface because we have no way to implement - * multiple interfaces without defining them in the interface structure - * or casting (void *), which is too convoluted. - */ -typedef struct ANTLR3_TOKEN_SOURCE_struct -{ - /** Pointer to a function that returns the next token in the stream. - */ - pANTLR3_COMMON_TOKEN (*nextToken)(struct ANTLR3_TOKEN_SOURCE_struct * tokenSource); - - /** Whoever is providing tokens, needs to provide a string factory too - */ - pANTLR3_STRING_FACTORY strFactory; - - /** A special pre-allocated token, which signifies End Of Tokens. Because this must - * be set up with the current input index and so on, we embed the structure and - * return the address of it. It is marked as factoryMade, so that it is never - * attempted to be freed. - */ - ANTLR3_COMMON_TOKEN eofToken; - - /// A special pre-allocated token, which is returned by mTokens() if the - /// lexer rule said to just skip the generated token altogether. - /// Having this single token stops us wasting memory by have the token factory - /// actually create something that we are going to SKIP(); anyway. - /// - ANTLR3_COMMON_TOKEN skipToken; - - /** Whatever is supplying the token source interface, needs a pointer to - * itself so that this pointer can be passed to it when the nextToken - * function is called. - */ - void * super; - - /** When the token source is constructed, it is populated with the file - * name from whence the tokens were produced by the lexer. This pointer is a - * copy of the one supplied by the CharStream (and may be NULL) so should - * not be manipulated other than to copy or print it. - */ - pANTLR3_STRING fileName; -} - ANTLR3_TOKEN_SOURCE; - -/** Definition of the ANTLR3 common token stream interface. - * \remark - * Much of the documentation for this interface is stolen from Ter's Java implementation. - */ -typedef struct ANTLR3_TOKEN_STREAM_struct -{ - /** Pointer to the token source for this stream - */ - pANTLR3_TOKEN_SOURCE tokenSource; - - /** Whatever is providing this interface needs a pointer to itself - * so that this can be passed back to it whenever the api functions - * are called. - */ - void * super; - - /** All input streams implement the ANTLR3_INT_STREAM interface... - */ - pANTLR3_INT_STREAM istream; - - /// Debugger interface, is this is a debugging token stream - /// - pANTLR3_DEBUG_EVENT_LISTENER debugger; - - /// Indicates the initial stream state for dbgConsume() - /// - ANTLR3_BOOLEAN initialStreamState; - - /** Get Token at current input pointer + i ahead where i=1 is next Token. - * i<0 indicates tokens in the past. So -1 is previous token and -2 is - * two tokens ago. LT(0) is undefined. For i>=n, return Token.EOFToken. - * Return null for LT(0) and any index that results in an absolute address - * that is negative. - */ - pANTLR3_COMMON_TOKEN (*_LT) (struct ANTLR3_TOKEN_STREAM_struct * tokenStream, ANTLR3_INT32 k); - - /** Get a token at an absolute index i; 0..n-1. This is really only - * needed for profiling and debugging and token stream rewriting. - * If you don't want to buffer up tokens, then this method makes no - * sense for you. Naturally you can't use the rewrite stream feature. - * I believe DebugTokenStream can easily be altered to not use - * this method, removing the dependency. - */ - pANTLR3_COMMON_TOKEN (*get) (struct ANTLR3_TOKEN_STREAM_struct * tokenStream, ANTLR3_UINT32 i); - - /** Where is this stream pulling tokens from? This is not the name, but - * a pointer into an interface that contains a ANTLR3_TOKEN_SOURCE interface. - * The Token Source interface contains a pointer to the input stream and a pointer - * to a function that returns the next token. - */ - pANTLR3_TOKEN_SOURCE (*getTokenSource) (struct ANTLR3_TOKEN_STREAM_struct * tokenStream); - - /** Function that installs a token source for teh stream - */ - void (*setTokenSource) (struct ANTLR3_TOKEN_STREAM_struct * tokenStream, - pANTLR3_TOKEN_SOURCE tokenSource); - - /** Return the text of all the tokens in the stream, as the old tramp in - * Leeds market used to say; "Get the lot!" - */ - pANTLR3_STRING (*toString) (struct ANTLR3_TOKEN_STREAM_struct * tokenStream); - - /** Return the text of all tokens from start to stop, inclusive. - * If the stream does not buffer all the tokens then it can just - * return an empty ANTLR3_STRING or NULL; Grammars should not access $ruleLabel.text in - * an action in that case. - */ - pANTLR3_STRING (*toStringSS) (struct ANTLR3_TOKEN_STREAM_struct * tokenStream, ANTLR3_UINT32 start, ANTLR3_UINT32 stop); - - /** Because the user is not required to use a token with an index stored - * in it, we must provide a means for two token objects themselves to - * indicate the start/end location. Most often this will just delegate - * to the other toString(int,int). This is also parallel with - * the pTREENODE_STREAM->toString(Object,Object). - */ - pANTLR3_STRING (*toStringTT) (struct ANTLR3_TOKEN_STREAM_struct * tokenStream, pANTLR3_COMMON_TOKEN start, pANTLR3_COMMON_TOKEN stop); - - - /** Function that sets the token stream into debugging mode - */ - void (*setDebugListener) (struct ANTLR3_TOKEN_STREAM_struct * tokenStream, pANTLR3_DEBUG_EVENT_LISTENER debugger); - - - - /** Function that knows how to free the memory for an ANTLR3_TOKEN_STREAM - */ - void (*free) (struct ANTLR3_TOKEN_STREAM_struct * tokenStream); -} - ANTLR3_TOKEN_STREAM; - -/** Common token stream is an implementation of ANTLR_TOKEN_STREAM for the default - * parsers and recognizers. You may of course build your own implementation if - * you are so inclined. - */ -typedef struct ANTLR3_COMMON_TOKEN_STREAM_struct -{ - /** The ANTLR3_TOKEN_STREAM interface implementation, which also includes - * the intstream implementation. We could duplicate the pANTLR_INT_STREAM - * in this interface and initialize it to a copy, but this could be confusing - * it just results in one more level of indirection and I think that with - * judicial use of 'const' later, the optimizer will do decent job. - */ - pANTLR3_TOKEN_STREAM tstream; - - /** Whatever is supplying the COMMON_TOKEN_STREAM needs a pointer to itself - * so that this can be accessed by any of the API functions which it implements. - */ - void * super; - - /** Records every single token pulled from the source indexed by the token index. - * There might be more efficient ways to do this, such as referencing directly in to - * the token factory pools, but for now this is convenient and the ANTLR3_LIST is not - * a huge overhead as it only stores pointers anyway, but allows for iterations and - * so on. - */ - pANTLR3_VECTOR tokens; - - /** Override map of tokens. If a token type has an entry in here, then - * the pointer in the table points to an int, being the override channel number - * that should always be used for this token type. - */ - pANTLR3_LIST channelOverrides; - - /** Discared set. If a token has an entry in this table, then it is thrown - * away (data pointer is always NULL). - */ - pANTLR3_LIST discardSet; - - /* The channel number that this token stream is tuned to. For instance, whitespace - * is usually tuned to channel 99, which no token stream would normally tune to and - * so it is thrown away. - */ - ANTLR3_UINT32 channel; - - /** If this flag is set to ANTLR3_TRUE, then tokens that the stream sees that are not - * in the channel that this stream is tuned to, are not tracked in the - * tokens table. When set to false, ALL tokens are added to the tracking. - */ - ANTLR3_BOOLEAN discardOffChannel; - - /** The index into the tokens list of the current token (the next one that will be - * consumed. p = -1 indicates that the token list is empty. - */ - ANTLR3_INT32 p; - - /** A simple filter mechanism whereby you can tell this token stream - * to force all tokens of type ttype to be on channel. For example, - * when interpreting, we cannot exec actions so we need to tell - * the stream to force all WS and NEWLINE to be a different, ignored - * channel. - */ - void (*setTokenTypeChannel) (struct ANTLR3_COMMON_TOKEN_STREAM_struct * tokenStream, - ANTLR3_UINT32 ttype, ANTLR3_UINT32 channel); - - /** Add a particular token type to the discard set. If a token is found to belong - * to this set, then it is skipped/thrown away - */ - void (*discardTokenType) (struct ANTLR3_COMMON_TOKEN_STREAM_struct * tokenStream, ANTLR3_INT32 ttype); - - /** Signal to discard off channel tokens from here on in. - */ - void (*discardOffChannelToks)(struct ANTLR3_COMMON_TOKEN_STREAM_struct * tokenStream, ANTLR3_BOOLEAN discard); - - /** Function that returns a pointer to the ANTLR3_LIST of all tokens - * in the stream (this causes the buffer to fill if we have not get any yet) - */ - pANTLR3_VECTOR (*getTokens) (struct ANTLR3_COMMON_TOKEN_STREAM_struct * tokenStream); - - /** Function that returns all the tokens between a start and a stop index. - * TODO: This is a new list (Ack! Maybe this is a reason to have factories for LISTS and HASHTABLES etc :-( come back to this) - */ - pANTLR3_LIST (*getTokenRange) (struct ANTLR3_COMMON_TOKEN_STREAM_struct * tokenStream, ANTLR3_UINT32 start, ANTLR3_UINT32 stop); - - /** Function that returns all the tokens indicated by the specified bitset, within a range of tokens - */ - pANTLR3_LIST (*getTokensSet) (struct ANTLR3_COMMON_TOKEN_STREAM_struct * tokenStream, - ANTLR3_UINT32 start, ANTLR3_UINT32 stop, pANTLR3_BITSET types); - - /** Function that returns all the tokens indicated by being a member of the supplied List - */ - pANTLR3_LIST (*getTokensList) (struct ANTLR3_COMMON_TOKEN_STREAM_struct * tokenStream, - ANTLR3_UINT32 start, ANTLR3_UINT32 stop, pANTLR3_LIST list); - - /** Function that returns all tokens of a certain type within a range. - */ - pANTLR3_LIST (*getTokensType) (struct ANTLR3_COMMON_TOKEN_STREAM_struct * tokenStream, - ANTLR3_UINT32 start, ANTLR3_UINT32 stop, ANTLR3_UINT32 type); - - /** Function that resets the token stream so that it can be reused, but - * but that does not free up any resources, such as the token factory - * the factory pool and so on. This prevents the need to keep freeing - * and reallocating the token pools if the thing you are building is - * a multi-shot dameon or somethign like that. It is much faster to - * just reuse all the vectors. - */ - void (*reset) (struct ANTLR3_COMMON_TOKEN_STREAM_struct * tokenStream); - - /** Function that knows how to free an ANTLR3_COMMON_TOKEN_STREAM - */ - void (*free) (struct ANTLR3_COMMON_TOKEN_STREAM_struct * tokenStream); -} - ANTLR3_COMMON_TOKEN_STREAM; - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/impl/antlr/libantlr3c-3.4/include/antlr3treeparser.h b/impl/antlr/libantlr3c-3.4/include/antlr3treeparser.h deleted file mode 100644 index 8ee0e58..0000000 --- a/impl/antlr/libantlr3c-3.4/include/antlr3treeparser.h +++ /dev/null @@ -1,81 +0,0 @@ -#ifndef ANTLR3TREEPARSER_H -#define ANTLR3TREEPARSER_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 <antlr3baserecognizer.h> -#include <antlr3commontreenodestream.h> - -#ifdef __cplusplus -extern "C" { -#endif - -/** Internal structure representing an element in a hash bucket. - * Stores the original key so that duplicate keys can be rejected - * if necessary, and contains function can be supported If the hash key - * could be unique I would have invented the perfect compression algorithm ;-) - */ -typedef struct ANTLR3_TREE_PARSER_struct -{ - /** Pointer to any super class - */ - void * super; - - /** A pointer to the base recognizer, where most of the parser functions actually - * live because they are shared between parser and tree parser and this is the - * easier way than copying the interface all over the place. Macros hide this - * for the generated code so it is easier on the eye (though not the debugger ;-). - */ - pANTLR3_BASE_RECOGNIZER rec; - - /** Pointer to the common tree node stream for the parser - */ - pANTLR3_COMMON_TREE_NODE_STREAM ctnstream; - - /** Set the input stream and reset the parser - */ - void (*setTreeNodeStream) (struct ANTLR3_TREE_PARSER_struct * parser, pANTLR3_COMMON_TREE_NODE_STREAM input); - - /** Return a pointer to the input stream - */ - pANTLR3_COMMON_TREE_NODE_STREAM (*getTreeNodeStream) (struct ANTLR3_TREE_PARSER_struct * parser); - - /** Pointer to a function that knows how to free resources of an ANTLR3 tree parser. - */ - void (*free) (struct ANTLR3_TREE_PARSER_struct * parser); -} - ANTLR3_TREE_PARSER; - -#ifdef __cplusplus -} -#endif - -#endif |