Add full source for antlr project (version 3.4)
This replaces the existing source for an unknown version of the antlr-runtime
with the full source for the antlr tool. However, we are still building
just the runtime jar, not the full tool.
The full tool will be included as a prebuilt jar, due to the complexities
of building this tool.
Since we will have both the full tool and the runtime jar in the Android tree,
the module name for the runtime jar has been changed from "antlr" to
"antlr-runtime"
Change-Id: I38d5f3e5e82392dc122f46bf7961aab5b42e40c5
Signed-off-by: Ben Gruver <bgruv@google.com>
diff --git a/antlr-3.4/runtime/C/include/antlr3.h b/antlr-3.4/runtime/C/include/antlr3.h
new file mode 100644
index 0000000..2ead975
--- /dev/null
+++ b/antlr-3.4/runtime/C/include/antlr3.h
@@ -0,0 +1,56 @@
+#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/antlr-3.4/runtime/C/include/antlr3baserecognizer.h b/antlr-3.4/runtime/C/include/antlr3baserecognizer.h
new file mode 100644
index 0000000..0a269d4
--- /dev/null
+++ b/antlr-3.4/runtime/C/include/antlr3baserecognizer.h
@@ -0,0 +1,371 @@
+/** \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/antlr-3.4/runtime/C/include/antlr3basetree.h b/antlr-3.4/runtime/C/include/antlr3basetree.h
new file mode 100644
index 0000000..023c4c2
--- /dev/null
+++ b/antlr-3.4/runtime/C/include/antlr3basetree.h
@@ -0,0 +1,143 @@
+/// \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/antlr-3.4/runtime/C/include/antlr3basetreeadaptor.h b/antlr-3.4/runtime/C/include/antlr3basetreeadaptor.h
new file mode 100644
index 0000000..bf9a72a
--- /dev/null
+++ b/antlr-3.4/runtime/C/include/antlr3basetreeadaptor.h
@@ -0,0 +1,152 @@
+/** \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/antlr-3.4/runtime/C/include/antlr3bitset.h b/antlr-3.4/runtime/C/include/antlr3bitset.h
new file mode 100644
index 0000000..7d816ab
--- /dev/null
+++ b/antlr-3.4/runtime/C/include/antlr3bitset.h
@@ -0,0 +1,119 @@
+/**
+ * \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/antlr-3.4/runtime/C/include/antlr3collections.h b/antlr-3.4/runtime/C/include/antlr3collections.h
new file mode 100644
index 0000000..7c73e36
--- /dev/null
+++ b/antlr-3.4/runtime/C/include/antlr3collections.h
@@ -0,0 +1,513 @@
+#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/antlr-3.4/runtime/C/include/antlr3commontoken.h b/antlr-3.4/runtime/C/include/antlr3commontoken.h
new file mode 100644
index 0000000..c48068e
--- /dev/null
+++ b/antlr-3.4/runtime/C/include/antlr3commontoken.h
@@ -0,0 +1,367 @@
+/** \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/antlr-3.4/runtime/C/include/antlr3commontree.h b/antlr-3.4/runtime/C/include/antlr3commontree.h
new file mode 100644
index 0000000..1516ecc
--- /dev/null
+++ b/antlr-3.4/runtime/C/include/antlr3commontree.h
@@ -0,0 +1,167 @@
+/** 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/antlr-3.4/runtime/C/include/antlr3commontreeadaptor.h b/antlr-3.4/runtime/C/include/antlr3commontreeadaptor.h
new file mode 100644
index 0000000..4827997
--- /dev/null
+++ b/antlr-3.4/runtime/C/include/antlr3commontreeadaptor.h
@@ -0,0 +1,70 @@
+/** \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/antlr-3.4/runtime/C/include/antlr3commontreenodestream.h b/antlr-3.4/runtime/C/include/antlr3commontreenodestream.h
new file mode 100644
index 0000000..beb0534
--- /dev/null
+++ b/antlr-3.4/runtime/C/include/antlr3commontreenodestream.h
@@ -0,0 +1,336 @@
+/// \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/antlr-3.4/runtime/C/include/antlr3convertutf.h b/antlr-3.4/runtime/C/include/antlr3convertutf.h
new file mode 100644
index 0000000..79cc82c
--- /dev/null
+++ b/antlr-3.4/runtime/C/include/antlr3convertutf.h
@@ -0,0 +1,176 @@
+/*
+ * 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/antlr-3.4/runtime/C/include/antlr3cyclicdfa.h b/antlr-3.4/runtime/C/include/antlr3cyclicdfa.h
new file mode 100644
index 0000000..78708a0
--- /dev/null
+++ b/antlr-3.4/runtime/C/include/antlr3cyclicdfa.h
@@ -0,0 +1,97 @@
+/// 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/antlr-3.4/runtime/C/include/antlr3debugeventlistener.h b/antlr-3.4/runtime/C/include/antlr3debugeventlistener.h
new file mode 100644
index 0000000..c9cd6ce
--- /dev/null
+++ b/antlr-3.4/runtime/C/include/antlr3debugeventlistener.h
@@ -0,0 +1,398 @@
+/**
+ * \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/antlr-3.4/runtime/C/include/antlr3defs.h b/antlr-3.4/runtime/C/include/antlr3defs.h
new file mode 100644
index 0000000..2435b02
--- /dev/null
+++ b/antlr-3.4/runtime/C/include/antlr3defs.h
@@ -0,0 +1,632 @@
+/** \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/antlr-3.4/runtime/C/include/antlr3encodings.h b/antlr-3.4/runtime/C/include/antlr3encodings.h
new file mode 100644
index 0000000..f706735
--- /dev/null
+++ b/antlr-3.4/runtime/C/include/antlr3encodings.h
@@ -0,0 +1,38 @@
+#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/antlr-3.4/runtime/C/include/antlr3errors.h b/antlr-3.4/runtime/C/include/antlr3errors.h
new file mode 100644
index 0000000..4419ee3
--- /dev/null
+++ b/antlr-3.4/runtime/C/include/antlr3errors.h
@@ -0,0 +1,53 @@
+#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/antlr-3.4/runtime/C/include/antlr3exception.h b/antlr-3.4/runtime/C/include/antlr3exception.h
new file mode 100644
index 0000000..8fab8da
--- /dev/null
+++ b/antlr-3.4/runtime/C/include/antlr3exception.h
@@ -0,0 +1,218 @@
+/** \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/antlr-3.4/runtime/C/include/antlr3filestream.h b/antlr-3.4/runtime/C/include/antlr3filestream.h
new file mode 100644
index 0000000..b06eb45
--- /dev/null
+++ b/antlr-3.4/runtime/C/include/antlr3filestream.h
@@ -0,0 +1,50 @@
+#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/antlr-3.4/runtime/C/include/antlr3input.h b/antlr-3.4/runtime/C/include/antlr3input.h
new file mode 100644
index 0000000..3b01ae6
--- /dev/null
+++ b/antlr-3.4/runtime/C/include/antlr3input.h
@@ -0,0 +1,281 @@
+/** \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/antlr-3.4/runtime/C/include/antlr3interfaces.h b/antlr-3.4/runtime/C/include/antlr3interfaces.h
new file mode 100644
index 0000000..160e04d
--- /dev/null
+++ b/antlr-3.4/runtime/C/include/antlr3interfaces.h
@@ -0,0 +1,239 @@
+/** \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/antlr-3.4/runtime/C/include/antlr3intstream.h b/antlr-3.4/runtime/C/include/antlr3intstream.h
new file mode 100644
index 0000000..21bac5b
--- /dev/null
+++ b/antlr-3.4/runtime/C/include/antlr3intstream.h
@@ -0,0 +1,205 @@
+/** \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/antlr-3.4/runtime/C/include/antlr3lexer.h b/antlr-3.4/runtime/C/include/antlr3lexer.h
new file mode 100644
index 0000000..6cc10ef
--- /dev/null
+++ b/antlr-3.4/runtime/C/include/antlr3lexer.h
@@ -0,0 +1,193 @@
+/** \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/antlr-3.4/runtime/C/include/antlr3memory.h b/antlr-3.4/runtime/C/include/antlr3memory.h
new file mode 100644
index 0000000..5e2d4c9
--- /dev/null
+++ b/antlr-3.4/runtime/C/include/antlr3memory.h
@@ -0,0 +1,36 @@
+#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/antlr-3.4/runtime/C/include/antlr3parser.h b/antlr-3.4/runtime/C/include/antlr3parser.h
new file mode 100644
index 0000000..95b7d18
--- /dev/null
+++ b/antlr-3.4/runtime/C/include/antlr3parser.h
@@ -0,0 +1,93 @@
+/** \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/antlr-3.4/runtime/C/include/antlr3parsetree.h b/antlr-3.4/runtime/C/include/antlr3parsetree.h
new file mode 100644
index 0000000..0e8c157
--- /dev/null
+++ b/antlr-3.4/runtime/C/include/antlr3parsetree.h
@@ -0,0 +1,85 @@
+/** \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/antlr-3.4/runtime/C/include/antlr3recognizersharedstate.h b/antlr-3.4/runtime/C/include/antlr3recognizersharedstate.h
new file mode 100644
index 0000000..9e024d8
--- /dev/null
+++ b/antlr-3.4/runtime/C/include/antlr3recognizersharedstate.h
@@ -0,0 +1,218 @@
+/** \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/antlr-3.4/runtime/C/include/antlr3rewritestreams.h b/antlr-3.4/runtime/C/include/antlr3rewritestreams.h
new file mode 100644
index 0000000..bf83fe9
--- /dev/null
+++ b/antlr-3.4/runtime/C/include/antlr3rewritestreams.h
@@ -0,0 +1,180 @@
+#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/antlr-3.4/runtime/C/include/antlr3string.h b/antlr-3.4/runtime/C/include/antlr3string.h
new file mode 100644
index 0000000..4a96e76
--- /dev/null
+++ b/antlr-3.4/runtime/C/include/antlr3string.h
@@ -0,0 +1,272 @@
+/** \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/antlr-3.4/runtime/C/include/antlr3tokenstream.h b/antlr-3.4/runtime/C/include/antlr3tokenstream.h
new file mode 100644
index 0000000..a5137ad
--- /dev/null
+++ b/antlr-3.4/runtime/C/include/antlr3tokenstream.h
@@ -0,0 +1,303 @@
+/** \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/antlr-3.4/runtime/C/include/antlr3treeparser.h b/antlr-3.4/runtime/C/include/antlr3treeparser.h
new file mode 100644
index 0000000..8ee0e58
--- /dev/null
+++ b/antlr-3.4/runtime/C/include/antlr3treeparser.h
@@ -0,0 +1,81 @@
+#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