Move antlr. Add `make test` to Makefile.

30 files changed, 0 insertions, 6142 deletions

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