From: <ibr...@us...> - 2013-03-11 15:11:32
|
Revision: 4567 http://sourceforge.net/p/tora/code/4567 Author: ibre5041 Date: 2013-03-11 15:11:21 +0000 (Mon, 11 Mar 2013) Log Message: ----------- gokul's ANTLR cpp parser Added Paths: ----------- branches/tora3/extlibs/libantlr3cpp-3.5.1/ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3bitset.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3bitset.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3collections.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3collections.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontoken.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontoken.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreenodestream.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreenodestream.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3convertutf.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3cyclicdfa.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3cyclicdfa.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3debugeventlistener.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3defs.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3errors.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3exception.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3exception.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3filestream.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3filestream.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3input.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3input.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3interfaces.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3intstream.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3intstream.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3lexer.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3lexer.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3memory.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3parser.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3parser.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3recognizersharedstate.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3recognizersharedstate.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3tokenstream.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3tokenstream.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3traits.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3treeparser.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3treeparser.inl branches/tora3/extlibs/parsing.cpp/ branches/tora3/extlibs/parsing.cpp/Makefile branches/tora3/extlibs/parsing.cpp/PLSQLCommons.g branches/tora3/extlibs/parsing.cpp/PLSQLKeys.g branches/tora3/extlibs/parsing.cpp/PLSQLLexer.g branches/tora3/extlibs/parsing.cpp/PLSQLParser.g branches/tora3/extlibs/parsing.cpp/PLSQL_DMLParser.g branches/tora3/extlibs/parsing.cpp/SQLPLUSParser.g branches/tora3/extlibs/parsing.cpp/antlr-complete-3.5.1-SNAPSHOT.jar branches/tora3/extlibs/parsing.cpp/t0.cpp branches/tora3/extlibs/parsing.cpp/t1.cpp branches/tora3/extlibs/parsing.cpp/t2.cpp branches/tora3/extlibs/parsing.cpp/t4.cpp branches/tora3/extlibs/parsing.cpp/utils.cpp branches/tora3/extlibs/parsing.cpp/utils.hpp Added: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3.hpp (rev 0) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3.hpp 2013-03-11 15:11:21 UTC (rev 4567) @@ -0,0 +1,60 @@ +#ifndef _ANTLR3_HPP +#define _ANTLR3_HPP + +// [The "BSD licence"] +// Copyright (c) 2005-2009 Gokulakannan Somasundaram, ElectronDB +// +// 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 <string> +#include <sstream> + +#include "antlr3defs.hpp" + +#include "antlr3errors.hpp" +#include "antlr3memory.hpp" + +#include "antlr3recognizersharedstate.hpp" +#include "antlr3baserecognizer.hpp" +#include "antlr3bitset.hpp" +#include "antlr3collections.hpp" +#include "antlr3commontoken.hpp" +#include "antlr3commontree.hpp" +#include "antlr3commontreeadaptor.hpp" +#include "antlr3cyclicdfa.hpp" +#include "antlr3debugeventlistener.hpp" +#include "antlr3exception.hpp" +#include "antlr3filestream.hpp" +#include "antlr3intstream.hpp" +#include "antlr3input.hpp" +#include "antlr3tokenstream.hpp" +#include "antlr3commontreenodestream.hpp" +#include "antlr3lexer.hpp" +#include "antlr3parser.hpp" +#include "antlr3rewritestreams.hpp" +#include "antlr3traits.hpp" +#include "antlr3treeparser.hpp" + +#endif Property changes on: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3.hpp ___________________________________________________________________ Added: svn:executable ## -0,0 +1 ## +* \ No newline at end of property Added: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3.inl (rev 0) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3.inl 2013-03-11 15:11:21 UTC (rev 4567) @@ -0,0 +1,9 @@ +ANTLR_BEGIN_NAMESPACE() + +//static +ANTLR_INLINE void GenericStream::displayRecognitionError( const StringType& str ) +{ + fprintf(stderr, str.c_str() ); +} + +ANTLR_END_NAMESPACE() \ No newline at end of file Property changes on: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3.inl ___________________________________________________________________ Added: svn:executable ## -0,0 +1 ## +* \ No newline at end of property Added: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.hpp (rev 0) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.hpp 2013-03-11 15:11:21 UTC (rev 4567) @@ -0,0 +1,512 @@ +/** \file + * Defines the basic structure to support recognizing by either a lexer, + * parser, or tree parser. + * \addtogroup BaseRecognizer + * @{ + */ +#ifndef _ANTLR3_BASERECOGNIZER_HPP +#define _ANTLR3_BASERECOGNIZER_HPP + +// [The "BSD licence"] +// Copyright (c) 2005-2009 Gokulakannan Somasundaram, ElectronDB + +// +// 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.hpp" +#include "antlr3collections.hpp" + +ANTLR_BEGIN_NAMESPACE() + +/** \brief Base tracking context structure for all types of + * recognizers. + */ +template< class ImplTraits, class StreamType > +class BaseRecognizer : public ImplTraits::AllocPolicyType +{ +public: + typedef typename ImplTraits::AllocPolicyType AllocPolicyType; + typedef typename StreamType::IntStreamType IntStreamType; + typedef typename ComponentTypeFinder<ImplTraits, StreamType>::ComponentType SuperType; + typedef typename StreamType::UnitType UnitType; + typedef typename ImplTraits::template ExceptionBaseType<StreamType> ExceptionBaseType; + typedef typename ImplTraits::BitsetType BitsetType; + typedef typename ImplTraits::BitsetListType BitsetListType; + typedef typename ImplTraits::StringType StringType; + typedef typename ImplTraits::template RecognizerSharedStateType<StreamType> RecognizerSharedStateType; + typedef typename ImplTraits::DebugEventListenerType DebugEventListenerType; + typedef typename ImplTraits::LexerType LexerType; + typedef typename ImplTraits::ParserType ParserType; + typedef typename ImplTraits::TreeParserType TreeParserType; + + typedef typename AllocPolicyType::template StackType<StringType> StringStackType; + typedef typename AllocPolicyType::template ListType<StringType> StringListType; + +private: + /// 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. + /// + RecognizerSharedStateType* m_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 + /// + DebugEventListenerType* m_debugger; + + +public: + BaseRecognizer(ANTLR_UINT32 sizeHint, RecognizerSharedStateType* state); + + SuperType* get_super(); + RecognizerSharedStateType* get_state() const; + DebugEventListenerType* get_debugger() const; + void set_state( RecognizerSharedStateType* state ); + void set_debugger( DebugEventListenerType* debugger ); + + /// Match current input symbol against ttype. Upon error, do one token + /// insertion or deletion if possible. + /// To turn off single token insertion or deletion error + /// recovery, override mismatchRecover() and have it call + /// plain mismatch(), which does not recover. Then any error + /// in a rule will cause an exception and immediate exit from + /// rule. Rule would recover by resynchronizing to the set of + /// symbols that can follow rule ref. + /// + const UnitType* match(ANTLR_UINT32 ttype, BitsetListType* follow); + + /// Consumes the next token, whatever it is, and resets the recognizer state + /// so that it is not in error. + /// + /// \param recognizer + /// Recognizer context pointer + /// + void matchAny(); + + /// 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. + /// + bool mismatchIsUnwantedToken(IntStreamType* input, ANTLR_UINT32 ttype); + + /// 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. + /// + bool mismatchIsMissingToken(IntStreamType* input, BitsetListType* follow); + + /// Factor out what to do upon token mismatch so tree parsers can behave + /// differently. Override and call mismatchRecover(input, ttype, follow) + /// to get single token insertion and deletion. Use this to turn off + /// single token insertion and deletion. Override mismatchRecover + /// to call this instead. + /// + /// \remark mismatch only works for parsers and must be overridden for anything else. + /// + void mismatch(ANTLR_UINT32 ttype, BitsetListType* follow); + + /// Report a recognition problem. + /// + /// 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 + /// + /// If you override, make sure to update errorCount if you care about that. + /// + void reportError(); + void reportError( ClassForwarder<LexerType> ); + template<typename CompType> + void reportError( ClassForwarder<CompType> ); + + /** 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(ANTLR_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() + /// + ANTLR_UINT32 getNumberOfSyntaxErrors(); + + /** 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(); + + /** 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(); + + /** 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(); + + /** 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(ANTLR_UINT32 level); + + /** 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(ANTLR_UINT32 level, bool successful); + + /// Compute the error recovery set for the current rule. + /// Documentation below is from the Java implementation. + /// + /// During rule invocation, the parser pushes the set of tokens that can + /// follow that rule reference on the stack; this amounts to + /// computing FIRST of what follows the rule reference in the + /// enclosing rule. This local follow set only includes tokens + /// from within the rule; i.e., the FIRST computation done by + /// ANTLR stops at the end of a rule. + // + /// EXAMPLE + // + /// When you find a "no viable alt exception", the input is not + /// consistent with any of the alternatives for rule r. The best + /// thing to do is to consume tokens until you see something that + /// can legally follow a call to r *or* any rule that called r. + /// You don't want the exact set of viable next tokens because the + /// input might just be missing a token--you might consume the + /// rest of the input looking for one of the missing tokens. + /// + /// Consider grammar: + /// + /// a : '[' b ']' + /// | '(' b ')' + /// ; + /// b : c '^' INT ; + /// c : ID + /// | INT + /// ; + /// + /// At each rule invocation, the set of tokens that could follow + /// that rule is pushed on a stack. Here are the various "local" + /// follow sets: + /// + /// FOLLOW(b1_in_a) = FIRST(']') = ']' + /// FOLLOW(b2_in_a) = FIRST(')') = ')' + /// FOLLOW(c_in_b) = FIRST('^') = '^' + /// + /// Upon erroneous input "[]", the call chain is + /// + /// a -> b -> c + /// + /// and, hence, the follow context stack is: + /// + /// depth local follow set after call to rule + /// 0 <EOF> a (from main()) + /// 1 ']' b + /// 3 '^' c + /// + /// Notice that ')' is not included, because b would have to have + /// been called from a different context in rule a for ')' to be + /// included. + /// + /// For error recovery, we cannot consider FOLLOW(c) + /// (context-sensitive or otherwise). We need the combined set of + /// all context-sensitive FOLLOW sets--the set of all tokens that + /// could follow any reference in the call chain. We need to + /// resync to one of those tokens. Note that FOLLOW(c)='^' and if + /// we resync'd to that token, we'd consume until EOF. We need to + /// sync to context-sensitive FOLLOWs for a, b, and c: {']','^'}. + /// In this case, for input "[]", LA(1) is in this set so we would + /// not consume anything and after printing an error rule c would + /// return normally. It would not find the required '^' though. + /// At this point, it gets a mismatched token error and throws an + /// exception (since LA(1) is not in the viable following token + /// set). The rule exception handler tries to recover, but finds + /// the same recovery set and doesn't consume anything. Rule b + /// exits normally returning to rule a. Now it finds the ']' (and + /// with the successful match exits errorRecovery mode). + /// + /// So, you can see that the parser walks up call chain looking + /// for the token that was a member of the recovery set. + /// + /// Errors are not generated in errorRecovery mode. + /// + /// ANTLR's error recovery mechanism is based upon original ideas: + /// + /// "Algorithms + Data Structures = Programs" by Niklaus Wirth + /// + /// and + /// + /// "A note on error recovery in recursive descent parsers": + /// http://portal.acm.org/citation.cfm?id=947902.947905 + /// + /// Later, Josef Grosch had some good ideas: + /// + /// "Efficient and Comfortable Error Recovery in Recursive Descent + /// Parsers": + /// ftp://www.cocolab.com/products/cocktail/doca4.ps/ell.ps.zip + /// + /// Like Grosch I implemented local FOLLOW sets that are combined + /// at run-time upon error to avoid overhead during parsing. + /// + BitsetType* computeErrorRecoverySet(); + + /// Compute the context-sensitive FOLLOW set for current rule. + /// Documentation below is from the Java runtime. + /// + /// This is the set of token types that can follow a specific rule + /// reference given a specific call chain. You get the set of + /// viable tokens that can possibly come next (look ahead depth 1) + /// given the current call chain. Contrast this with the + /// definition of plain FOLLOW for rule r: + /// + /// FOLLOW(r)={x | S=>*alpha r beta in G and x in FIRST(beta)} + /// + /// where x in T* and alpha, beta in V*; T is set of terminals and + /// V is the set of terminals and non terminals. In other words, + /// FOLLOW(r) is the set of all tokens that can possibly follow + /// references to r in///any* sentential form (context). At + /// runtime, however, we know precisely which context applies as + /// we have the call chain. We may compute the exact (rather + /// than covering superset) set of following tokens. + /// + /// For example, consider grammar: + /// + /// stat : ID '=' expr ';' // FOLLOW(stat)=={EOF} + /// | "return" expr '.' + /// ; + /// expr : atom ('+' atom)* ; // FOLLOW(expr)=={';','.',')'} + /// atom : INT // FOLLOW(atom)=={'+',')',';','.'} + /// | '(' expr ')' + /// ; + /// + /// The FOLLOW sets are all inclusive whereas context-sensitive + /// FOLLOW sets are precisely what could follow a rule reference. + /// For input input "i=(3);", here is the derivation: + /// + /// stat => ID '=' expr ';' + /// => ID '=' atom ('+' atom)* ';' + /// => ID '=' '(' expr ')' ('+' atom)* ';' + /// => ID '=' '(' atom ')' ('+' atom)* ';' + /// => ID '=' '(' INT ')' ('+' atom)* ';' + /// => ID '=' '(' INT ')' ';' + /// + /// At the "3" token, you'd have a call chain of + /// + /// stat -> expr -> atom -> expr -> atom + /// + /// What can follow that specific nested ref to atom? Exactly ')' + /// as you can see by looking at the derivation of this specific + /// input. Contrast this with the FOLLOW(atom)={'+',')',';','.'}. + /// + /// You want the exact viable token set when recovering from a + /// token mismatch. Upon token mismatch, if LA(1) is member of + /// the viable next token set, then you know there is most likely + /// a missing token in the input stream. "Insert" one by just not + /// throwing an exception. + /// + BitsetType* computeCSRuleFollow(); + + /// Compute the current followset for the input stream. + /// + BitsetType* combineFollows(bool exact); + + /// Attempt to recover from a single missing or extra token. + /// + /// EXTRA TOKEN + /// + /// LA(1) is not what we are looking for. If LA(2) has the right token, + /// however, then assume LA(1) is some extra spurious token. Delete it + /// and LA(2) as if we were doing a normal match(), which advances the + /// input. + /// + /// MISSING TOKEN + /// + /// If current token is consistent with what could come after + /// ttype then it is ok to "insert" the missing token, else throw + /// exception For example, Input "i=(3;" is clearly missing the + /// ')'. When the parser returns from the nested call to expr, it + /// will have call chain: + /// + /// stat -> expr -> atom + /// + /// and it will be trying to match the ')' at this point in the + /// derivation: + /// + /// => ID '=' '(' INT ')' ('+' atom)* ';' + /// ^ + /// match() will see that ';' doesn't match ')' and report a + /// mismatched token error. To recover, it sees that LA(1)==';' + /// is in the set of tokens that can follow the ')' token + /// reference in rule atom. It can assume that you forgot the ')'. + /// + /// The exception that was passed in, in the java implementation is + /// sorted in the recognizer exception stack in the C version. To 'throw' it we set the + /// error flag and rules cascade back when this is set. + /// + const UnitType* recoverFromMismatchedToken( ANTLR_UINT32 ttype, BitsetListType* follow); + + /** Function that recovers from a mismatched set in the token stream, in a similar manner + * to (*recoverFromMismatchedToken) + */ + const UnitType* recoverFromMismatchedSet(BitsetListType* follow); + + /** common routine to handle single token insertion for recovery functions. + */ + /// This code is factored out from mismatched token and mismatched set + /// recovery. It handles "single token insertion" error recovery for + /// both. No tokens are consumed to recover from insertions. Return + /// true if recovery was possible else return false. + /// + bool recoverFromMismatchedElement(BitsetListType* follow); + + /** function that consumes input until the next token matches + * the given token. + */ + void consumeUntil(ANTLR_UINT32 tokenType); + + /** function that consumes input until the next token matches + * one in the given set. + */ + void consumeUntilSet(BitsetType* set); + + /** 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. + */ + StringStackType getRuleInvocationStack(); + StringStackType getRuleInvocationStackNamed(ANTLR_UINT8* name); + + /** 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. + */ + StringListType toStrings( const StringListType& ); + + /** 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. + */ + ANTLR_MARKER getRuleMemoization( ANTLR_INTKEY ruleIndex, + ANTLR_MARKER ruleParseStart); + + /** function that determines whether the rule has parsed input at the current index + * in the input stream + */ + bool alreadyParsedRule(ANTLR_MARKER ruleIndex); + + /** Function that records whether the rule has parsed the input at a + * current position successfully or not. + */ + void memoize(ANTLR_MARKER ruleIndex, + ANTLR_MARKER ruleParseStart); + + /// 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. + /// + const UnitType* getCurrentInputSymbol(IntStreamType* istream); + const UnitType* getCurrentInputSymbol(IntStreamType* istream, ClassForwarder<LexerType>); + const UnitType* getCurrentInputSymbol(IntStreamType* istream, ClassForwarder<ParserType>); + const UnitType* getCurrentInputSymbol(IntStreamType* istream, ClassForwarder<TreeParserType>); + + /// 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. + /// + UnitType* getMissingSymbol( IntStreamType* istream, ExceptionBaseType* e, + ANTLR_UINT32 expectedTokenType, + BitsetListType* follow); + + /** 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. + */ + template<typename Predicate> + bool synpred( ClassForwarder<Predicate> ); + + //In place of exConstruct, just directly instantiate the Exception Object + + /** Reset the recognizer + */ + void reset(); + void reset( ClassForwarder<LexerType> ); + template<typename CompType> + void reset( ClassForwarder<CompType> ); + + void exConstruct(); + + ~BaseRecognizer(); + +}; + +ANTLR_END_NAMESPACE() + +#include "antlr3baserecognizer.inl" + +/// @} +/// + +#endif /* _ANTLR3_BASERECOGNIZER_H */ + Property changes on: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.hpp ___________________________________________________________________ Added: svn:executable ## -0,0 +1 ## +* \ No newline at end of property Added: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.inl (rev 0) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.inl 2013-03-11 15:11:21 UTC (rev 4567) @@ -0,0 +1,919 @@ +ANTLR_BEGIN_NAMESPACE() + +template< class ImplTraits, class StreamType > +BaseRecognizer<ImplTraits, StreamType>::BaseRecognizer(ANTLR_UINT32 sizeHint, + RecognizerSharedStateType* state) +{ + m_debugger = NULL; + + // If we have been supplied with a pre-existing recognizer state + // then we just install it, otherwise we must create one from scratch + // + if (state == NULL) + { + m_state = new RecognizerSharedStateType(); + m_state->set_sizeHint( sizeHint ); + } + else + { + // Install the one we were given, and do not reset it here + // as it will either already have been initialized or will + // be in a state that needs to be preserved. + // + m_state = state; + } +} + +template< class ImplTraits, class StreamType > +ANTLR_INLINE typename BaseRecognizer<ImplTraits, StreamType>::SuperType* BaseRecognizer<ImplTraits, StreamType>::get_super() +{ + return static_cast<SuperType*>(this); +} + +template< class ImplTraits, class StreamType > +ANTLR_INLINE typename BaseRecognizer<ImplTraits, StreamType>::RecognizerSharedStateType* BaseRecognizer<ImplTraits, StreamType>::get_state() const +{ + return m_state; +} +template< class ImplTraits, class StreamType > +ANTLR_INLINE typename BaseRecognizer<ImplTraits, StreamType>::DebugEventListenerType* BaseRecognizer<ImplTraits, StreamType>::get_debugger() const +{ + return m_debugger; +} +template< class ImplTraits, class StreamType > +ANTLR_INLINE void BaseRecognizer<ImplTraits, StreamType>::set_state( RecognizerSharedStateType* state ) +{ + m_state = state; +} +template< class ImplTraits, class StreamType > +ANTLR_INLINE void BaseRecognizer<ImplTraits, StreamType>::set_debugger( DebugEventListenerType* debugger ) +{ + m_debugger = debugger; +} + +template< class ImplTraits, class StreamType > +const typename BaseRecognizer<ImplTraits, StreamType>::UnitType* +BaseRecognizer<ImplTraits, StreamType>::match(ANTLR_UINT32 ttype, BitsetListType* follow) +{ + SuperType* super = static_cast<SuperType*>(this); + IntStreamType* is = super->get_istream(); + + // Pick up the current input token/node for assignment to labels + // + const UnitType* matchedSymbol = this->getCurrentInputSymbol(is); + + if (is->_LA(1) == ttype) + { + // The token was the one we were told to expect + // + is->consume(); // Consume that token from the stream + m_state->set_errorRecovery(false); // Not in error recovery now (if we were) + m_state->set_failed(false); // The match was a success + return matchedSymbol; // We are done + } + + // We did not find the expected token type, if we are backtracking then + // we just set the failed flag and return. + // + if ( m_state->get_backtracking() > 0) + { + // Backtracking is going on + // + m_state->set_failed(true); + return matchedSymbol; + } + + // We did not find the expected token and there is no backtracking + // going on, so we mismatch, which creates an exception in the recognizer exception + // stack. + // + matchedSymbol = this->recoverFromMismatchedToken(ttype, follow); + return matchedSymbol; + +} + +template< class ImplTraits, class StreamType > +void BaseRecognizer<ImplTraits, StreamType>::matchAny() +{ + SuperType* super = static_cast<SuperType*>(this); + IntStreamType* is = super->get_istream(); + + is->consume(); + m_state->set_errorRecovery(false); + m_state->set_failed(false); + return; +} + +template< class ImplTraits, class StreamType > +bool BaseRecognizer<ImplTraits, StreamType>::mismatchIsUnwantedToken(IntStreamType* is, ANTLR_UINT32 ttype) +{ + ANTLR_UINT32 nextt = is->_LA(2); + + if (nextt == ttype) + { + if(m_state->get_exception() != NULL) + m_state->get_exception()->set_expecting(nextt); + return true; // This token is unknown, but the next one is the one we wanted + } + else + return false; // Neither this token, nor the one following is the one we wanted +} + +template< class ImplTraits, class StreamType > +bool BaseRecognizer<ImplTraits, StreamType>::mismatchIsMissingToken(IntStreamType* is, BitsetListType* follow) +{ + bool retcode; + BitsetType* followClone; + BitsetType* viableTokensFollowingThisRule; + + if (follow == NULL) + { + // There is no information about the tokens that can follow the last one + // hence we must say that the current one we found is not a member of the + // follow set and does not indicate a missing token. We will just consume this + // single token and see if the parser works it out from there. + // + return false; + } + + followClone = NULL; + viableTokensFollowingThisRule = NULL; + + // The C bitset maps are laid down at compile time by the + // C code generation. Hence we cannot remove things from them + // and so on. So, in order to remove EOR (if we need to) then + // we clone the static bitset. + // + followClone = follow->bitsetLoad(); + if (followClone == NULL) + return false; + + // Compute what can follow this grammar reference + // + if (followClone->isMember( ImplTraits::CommonTokenType::EOR_TOKEN_TYPE)) + { + // EOR can follow, but if we are not the start symbol, we + // need to remove it. + // + followClone->remove(ImplTraits::CommonTokenType::EOR_TOKEN_TYPE); + + // Now compute the visiable tokens that can follow this rule, according to context + // and make them part of the follow set. + // + viableTokensFollowingThisRule = this->computeCSRuleFollow(); + followClone->borInPlace(viableTokensFollowingThisRule); + } + + /// if current token is consistent with what could come after set + /// then we know we're missing a token; error recovery is free to + /// "insert" the missing token + /// + /// BitSet cannot handle negative numbers like -1 (EOF) so I leave EOR + /// in follow set to indicate that the fall of the start symbol is + /// in the set (EOF can follow). + /// + if ( followClone->isMember(is->_LA(1)) + || followClone->isMember(ImplTraits::CommonTokenType::EOR_TOKEN_TYPE) + ) + { + retcode = true; + } + else + { + retcode = false; + } + + if (viableTokensFollowingThisRule != NULL) + { + delete viableTokensFollowingThisRule; + } + if (followClone != NULL) + { + delete followClone; + } + + return retcode; +} + +template< class ImplTraits, class StreamType > +void BaseRecognizer<ImplTraits, StreamType>::mismatch(ANTLR_UINT32 ttype, BitsetListType* follow) +{ + this->get_super()->mismatch( ttype, follow ); +} + +template< class ImplTraits, class StreamType > +void BaseRecognizer<ImplTraits, StreamType>::reportError() +{ + this->reportError( ClassForwarder<SuperType>() ); +} + +template< class ImplTraits, class StreamType > +void BaseRecognizer<ImplTraits, StreamType>::reportError( ClassForwarder<LexerType> ) +{ + // Indicate this recognizer had an error while processing. + // + m_state->inc_errorCount(); + + this->displayRecognitionError(m_state->get_tokenNames()); +} + +template< class ImplTraits, class StreamType > +template<typename CompType> +void BaseRecognizer<ImplTraits, StreamType>::reportError(ClassForwarder<CompType> ) +{ + // Invoke the debugger event if there is a debugger listening to us + // + if ( m_debugger != NULL) + { + m_debugger->recognitionException( m_state->get_exception() ); + } + + if ( m_state->get_errorRecovery() == true) + { + // Already in error recovery so don't display another error while doing so + // + return; + } + + // Signal we are in error recovery now + // + m_state->set_errorRecovery(true); + + // Indicate this recognizer had an error while processing. + // + m_state->inc_errorCount(); + + // Call the error display routine + // + this->displayRecognitionError( m_state->get_tokenNames() ); +} + +template< class ImplTraits, class StreamType > +void BaseRecognizer<ImplTraits, StreamType>::displayRecognitionError(ANTLR_UINT8** tokenNames) +{ + // Retrieve some info for easy reading. + // + ExceptionBaseType* ex = m_state->get_exception(); + StringType ttext; + + // See if there is a 'filename' we can use + // + SuperType* super = static_cast<SuperType*>(this); + super->displayRecognitionError(tokenNames, ex); +} + +template< class ImplTraits, class StreamType > +ANTLR_UINT32 BaseRecognizer<ImplTraits, StreamType>::getNumberOfSyntaxErrors() +{ + return m_state->get_errorCount(); +} + +template< class ImplTraits, class StreamType > +void BaseRecognizer<ImplTraits, StreamType>::recover() +{ + SuperType* super = static_cast<SuperType*>(this); + IntStreamType* is = super->get_parser_istream(); + // Are we about to repeat the same error? + // + if ( m_state->get_lastErrorIndex() == is->index()) + { + // The last error was at the same token index point. This must be a case + // where LT(1) is in the recovery token set so nothing is + // consumed. Consume a single token so at least to prevent + // an infinite loop; this is a failsafe. + // + is->consume(); + } + + // Record error index position + // + m_state->set_lastErrorIndex( is->index() ); + + // Work out the follows set for error recovery + // + BitsetType* followSet = this->computeErrorRecoverySet(); + + // Call resync hook (for debuggers and so on) + // + this->beginResync(); + + // Consume tokens until we have resynced to something in the follows set + // + this->consumeUntilSet(followSet); + + // End resync hook + // + this->endResync(); + + // Destroy the temporary bitset we produced. + // + delete followSet; + + // Reset the inError flag so we don't re-report the exception + // + m_state->set_error(false); + m_state->set_failed(false); +} + +template< class ImplTraits, class StreamType > +void BaseRecognizer<ImplTraits, StreamType>::beginResync() +{ + if (m_debugger != NULL) + { + m_debugger->beginResync(); + } +} + +template< class ImplTraits, class StreamType > +void BaseRecognizer<ImplTraits, StreamType>::endResync() +{ + if (m_debugger != NULL) + { + m_debugger->endResync(); + } +} + +template< class ImplTraits, class StreamType > +void BaseRecognizer<ImplTraits, StreamType>::beginBacktrack(ANTLR_UINT32 level) +{ + if (m_debugger != NULL) + { + m_debugger->beginBacktrack(level); + } +} + +template< class ImplTraits, class StreamType > +void BaseRecognizer<ImplTraits, StreamType>::endBacktrack(ANTLR_UINT32 level, bool successful) +{ + if (m_debugger != NULL) + { + m_debugger->endBacktrack(level); + } +} + +template< class ImplTraits, class StreamType > +typename BaseRecognizer<ImplTraits, StreamType>::BitsetType* BaseRecognizer<ImplTraits, StreamType>::computeErrorRecoverySet() +{ + return this->combineFollows(false); +} + +template< class ImplTraits, class StreamType > +typename BaseRecognizer<ImplTraits, StreamType>::BitsetType* BaseRecognizer<ImplTraits, StreamType>::computeCSRuleFollow() +{ + return this->combineFollows(false); +} + +template< class ImplTraits, class StreamType > +typename BaseRecognizer<ImplTraits, StreamType>::BitsetType* BaseRecognizer<ImplTraits, StreamType>::combineFollows(bool exact) +{ + BitsetType* followSet; + BitsetType* localFollowSet; + ANTLR_UINT32 top; + ANTLR_UINT32 i; + + top = static_cast<ANTLR_UINT32>( m_state->get_following().size() ); + + followSet = new BitsetType(0); + localFollowSet = NULL; + + for (i = top; i>0; i--) + { + localFollowSet = m_state->get_following().at(i-1).bitsetLoad(); + + if (localFollowSet != NULL) + { + followSet->borInPlace(localFollowSet); + + if (exact == true) + { + if (localFollowSet->isMember( ImplTraits::CommonTokenType::EOR_TOKEN_TYPE) == false) + { + // Only leave EOR in the set if at top (start rule); this lets us know + // if we have to include the follow(start rule); I.E., EOF + // + if (i>1) + { + followSet->remove(ImplTraits::CommonTokenType::EOR_TOKEN_TYPE); + } + } + else + { + break; // Cannot see End Of Rule from here, just drop out + } + } + delete localFollowSet; + localFollowSet = NULL; + } + } + + if (localFollowSet != NULL) + { + delete localFollowSet; + } + return followSet; +} + +template< class ImplTraits, class StreamType > +const typename BaseRecognizer<ImplTraits, StreamType>::UnitType* +BaseRecognizer<ImplTraits, StreamType>::recoverFromMismatchedToken( ANTLR_UINT32 ttype, BitsetListType* follow) +{ + SuperType* super = static_cast<SuperType*>(this); + IntStreamType* is = super->get_parser_istream(); + const UnitType* matchedSymbol; + + // If the next token after the one we are looking at in the input stream + // is what we are looking for then we remove the one we have discovered + // from the stream by consuming it, then consume this next one along too as + // if nothing had happened. + // + if ( this->mismatchIsUnwantedToken( is, ttype) == true) + { + // Create an exception if we need one + // + new ANTLR_Exception<ImplTraits, UNWANTED_TOKEN_EXCEPTION, StreamType>(this, ""); + + // Call resync hook (for debuggers and so on) + // + if (m_debugger != NULL) + { + m_debugger->beginResync(); + } + + // "delete" the extra token + // + this->beginResync(); + is->consume(); + this->endResync(); + // End resync hook + // + if (m_debugger != NULL) + { + m_debugger->endResync(); + } + + // Print out the error after we consume so that ANTLRWorks sees the + // token in the exception. + // + this->reportError(); + + // Return the token we are actually matching + // + matchedSymbol = this->getCurrentInputSymbol(is); + + // Consume the token that the rule actually expected to get as if everything + // was hunky dory. + // + is->consume(); + + m_state->set_error(false); // Exception is not outstanding any more + + return matchedSymbol; + } + + // Single token deletion (Unwanted above) did not work + // so we see if we can insert a token instead by calculating which + // token would be missing + // + if ( this->mismatchIsMissingToken(is, follow)) + { + // We can fake the missing token and proceed + // + new ANTLR_Exception<ImplTraits, MISSING_TOKEN_EXCEPTION, StreamType>(this, ""); + matchedSymbol = this->getMissingSymbol( is, m_state->get_exception(), ttype, follow); + m_state->get_exception()->set_token( matchedSymbol ); + m_state->get_exception()->set_expecting(ttype); + + // Print out the error after we insert so that ANTLRWorks sees the + // token in the exception. + // + this->reportError(); + + m_state->set_error(false); // Exception is not outstanding any more + + return matchedSymbol; + } + + // Create an exception if we need one + // + new ANTLR_Exception<ImplTraits, RECOGNITION_EXCEPTION, StreamType>(this, ""); + + // Neither deleting nor inserting tokens allows recovery + // must just report the exception. + // + m_state->set_error(true); + return NULL; +} + +template< class ImplTraits, class StreamType > +const typename BaseRecognizer<ImplTraits, StreamType>::UnitType* +BaseRecognizer<ImplTraits, StreamType>::recoverFromMismatchedSet(BitsetListType* follow) +{ + SuperType* super = static_cast<SuperType*>(this); + IntStreamType* is = super->get_parser_istream(); + const UnitType* matchedSymbol; + + if (this->mismatchIsMissingToken(is, follow) == true) + { + // We can fake the missing token and proceed + // + new ANTLR_Exception<ImplTraits, MISSING_TOKEN_EXCEPTION, StreamType>(this); + matchedSymbol = this->getMissingSymbol(is, m_state->get_exception(), follow); + m_state->get_exception()->set_token(matchedSymbol); + + // Print out the error after we insert so that ANTLRWorks sees the + // token in the exception. + // + this->reportError(); + + m_state->set_error(false); // Exception is not outstanding any more + + return matchedSymbol; + } + + // TODO - Single token deletion like in recoverFromMismatchedToken() + // + m_state->set_error(true); + m_state->set_failed(true); + return NULL; +} + +template< class ImplTraits, class StreamType > +bool BaseRecognizer<ImplTraits, StreamType>::recoverFromMismatchedElement(BitsetListType* followBits) +{ + SuperType* super = static_cast<SuperType*>(this); + IntStreamType* is = super->get_parser_istream(); + + BitsetType* follow = followBits->load(); + BitsetType* viableToksFollowingRule; + + if (follow == NULL) + { + /* The follow set is NULL, which means we don't know what can come + * next, so we "hit and hope" by just signifying that we cannot + * recover, which will just cause the next token to be consumed, + * which might dig us out. + */ + return false; + } + + /* We have a bitmap for the follow set, hence we can compute + * what can follow this grammar element reference. + */ + if (follow->isMember( ImplTraits::CommonTokenType::EOR_TOKEN_TYPE) == true) + { + /* First we need to know which of the available tokens are viable + * to follow this reference. + */ + viableToksFollowingRule = this->computeCSRuleFollow(); + + /* Remove the EOR token, which we do not wish to compute with + */ + follow->remove( ImplTraits::CommonTokenType::EOR_TOKEN_TYPE); + delete viableToksFollowingRule; + /* We now have the computed set of what can follow the current token + */ + } + + /* We can now see if the current token works with the set of tokens + * that could follow the current grammar reference. If it looks like it + * is consistent, then we can "insert" that token by not throwing + * an exception and assuming that we saw it. + */ + if ( follow->isMember(is->_LA(1)) == true) + { + /* report the error, but don't cause any rules to abort and stuff + */ + this->reportError(); + if (follow != NULL) + { + delete follow; + } + m_state->set_error(false); + m_state->set_failed(false); + return true; /* Success in recovery */ + } + + if (follow != NULL) + { + delete follow; + } + + /* We could not find anything viable to do, so this is going to + * cause an exception. + */ + return false; +} + +template< class ImplTraits, class StreamType > +void BaseRecognizer<ImplTraits, StreamType>::consumeUntil(ANTLR_UINT32 tokenType) +{ + SuperType* super = static_cast<SuperType*>(this); + IntStreamType* is = super->get_parser_istream(); + + // What do have at the moment? + // + ANTLR_UINT32 ttype = is->_LA(1); + + // Start eating tokens until we get to the one we want. + // + while (ttype != ImplTraits::CommonTokenType::TOKEN_EOF && ttype != tokenType) + { + is->consume(); + ttype = is->_LA(1); + } +} + +template< class ImplTraits, class StreamType > +void BaseRecognizer<ImplTraits, StreamType>::consumeUntilSet(BitsetType* set) +{ + ANTLR_UINT32 ttype; + SuperType* super = static_cast<SuperType*>(this); + IntStreamType* is = super->get_parser_istream(); + + // What do have at the moment? + // + ttype = is->_LA(1); + + // Start eating tokens until we get to one we want. + // + while (ttype != ImplTraits::CommonTokenType::TOKEN_EOF && set->isMember(ttype) == false) + { + is->consume(); + ttype = is->_LA(1); + } + +} + +template< class ImplTraits, class StreamType > +ANTLR_MARKER BaseRecognizer<ImplTraits, StreamType>::getRuleMemoization( ANTLR_INTKEY ruleIndex, ANTLR_MARKER ruleParseStart) +{ + /* The rule memos are an ANTLR3_LIST of ANTLR3_LIST. + */ + typedef IntTrie<ImplTraits, ANTLR_MARKER> RuleListType; + typedef TrieEntry<ImplTraits, RuleListType*> EntryType; + typedef TrieEntry<ImplTraits, ANTLR_MARKER> SubEntryType; + ANTLR_MARKER stopIndex; + EntryType* entry; + + /* See if we have a list in the ruleMemos for this rule, and if not, then create one + * as we will need it eventually if we are being asked for the memo here. + */ + entry = m_state->get_ruleMemo()->get(ruleIndex); + + if (entry == NULL) + { + /* Did not find it, so create a new one for it, with a bit depth based on the + * size of the input stream. We need the bit depth to incorporate the number if + * bits required to represent the largest possible stop index in the input, which is the + * last character. An int stream is free to return the largest 64 bit offset if it has + * no idea of the size, but you should remember that this will cause the leftmost + * bit match algorithm to run to 63 bits, which will be the whole time spent in the trie ;-) + */ + m_state->get_ruleMemo()->add( ruleIndex, new RuleListType(63) ); + + /* We cannot have a stopIndex in a trie we have just created of course + */ + return MEMO_RULE_UNKNOWN; + } + + RuleListType* ruleList = entry->get_data(); + + /* See if there is a stop index associated with the supplied start index. + */ + stopIndex = 0; + + SubEntryType* sub_entry = ruleList->get(ruleParseStart); + if (sub_entry != NULL) + { + stopIndex = sub_entry->get_data(); + } + + if (stopIndex == 0) + { + return MEMO_RULE_UNKNOWN; + } + + return stopIndex; +} + +template< class ImplTraits, class StreamType > +bool BaseRecognizer<ImplTraits, StreamType>::alreadyParsedRule(ANTLR_MARKER ruleIndex) +{ + SuperType* super = static_cast<SuperType*>(this); + IntStreamType* is = super->get_istream(); + + /* See if we have a memo marker for this. + */ + ANTLR_MARKER stopIndex = this->getRuleMemoization( ruleIndex, is->index() ); + + if (stopIndex == MEMO_RULE_UNKNOWN) + { + return false; + } + + if (stopIndex == MEMO_RULE_FAILED) + { + m_state->set_failed(true); + } + else + { + is->seek(stopIndex+1); + } + + /* If here then the rule was executed for this input already + */ + return true; +} + +template< class ImplTraits, class StreamType > +void BaseRecognizer<ImplTraits, StreamType>::memoize(ANTLR_MARKER ruleIndex, ANTLR_MARKER ruleParseStart) +{ + /* The rule memos are an ANTLR3_LIST of ANTLR3_LIST. + */ + typedef IntTrie<ImplTraits, ANTLR_MARKER> RuleListType; + typedef TrieEntry<ImplTraits, RuleListType*> EntryType; + EntryType* entry; + ANTLR_MARKER stopIndex; + SuperType* super = static_cast<SuperType*>(this); + IntStreamType* is = super->get_istream(); + + stopIndex = (m_state->get_failed() == true) ? MEMO_RULE_FAILED : is->index() - 1; + + entry = m_state->get_ruleMemo()->get(ruleIndex); + + if (entry != NULL) + { + RuleListType* ruleList = entry->get_data(); + + /* If we don't already have this entry, append it. The memoize trie does not + * accept duplicates so it won't add it if already there and we just ignore the + * return code as we don't care if it is there already. + */ + ruleList->add(ruleParseStart, stopIndex); + } +} + +template< class ImplTraits, class StreamType > +const typename BaseRecognizer<ImplTraits, StreamType>::UnitType* +BaseRecognizer<ImplTraits, StreamType>::getCurrentInputSymbol( IntStreamType* istream ) +{ + return this->getCurrentInputSymbol( istream, ClassForwarder<SuperType>() ); +} + +template< class ImplTraits, class StreamType > +const typename BaseRecognizer<ImplTraits, StreamType>::UnitType* +BaseRecognizer<ImplTraits, StreamType>::getCurrentInputSymbol(IntStreamType* istream, ClassForwarder<LexerType>) +{ + return NULL; +} + +template< class ImplTraits, class StreamType > +const typename BaseRecognizer<ImplTraits, StreamType>::UnitType* +BaseRecognizer<ImplTraits, StreamType>::getCurrentInputSymbol(IntStreamType* istream, ClassForwarder<ParserType>) +{ + typedef typename ImplTraits::TokenStreamType TokenStreamType; + TokenStreamType* token_stream = static_cast<TokenStreamType*>(istream); + return token_stream->_LT(1); +} + +template< class ImplTraits, class StreamType > +const typename BaseRecognizer<ImplTraits, StreamType>::UnitType* +BaseRecognizer<ImplTraits, StreamType>::getCurrentInputSymbol(IntStreamType* istream, ClassForwarder<TreeParserType>) +{ + typedef typename ImplTraits::TreeNodeStreamType TreeNodeStreamType; + TreeNodeStreamType* ctns = static_cast<TreeNodeStreamType*>(istream); + return ctns->_LT(1); +} + + +template< class ImplTraits, class StreamType > +typename BaseRecognizer<ImplTraits, StreamType>::UnitType* BaseRecognizer<ImplTraits, StreamType>::getMissingSymbol( IntStreamType* istream, + ExceptionBaseType* e, + ANTLR_UINT32 expectedTokenType, + BitsetListType* follow) +{ + return this->get_super()->getMissingSymbol( istream, e, expectedTokenType, follow ); +} + + +template< class ImplTraits, class StreamType > + template<typename Predicate> +bool BaseRecognizer<ImplTraits, StreamType>::synpred(ClassForwarder<Predicate> pred) +{ + ANTLR_MARKER start; + SuperType* super = static_cast<SuperType*>(this); + IntStreamType* is = super->get_istream(); + + /* Begin backtracking so we can get back to where we started after trying out + * the syntactic predicate. + */ + start = is->mark(); + m_state->inc_backtracking(); + + /* Try the syntactical predicate + */ + this->get_super()->synpred( pred ); + + /* Reset + */ + is->rewind(start); + m_state->dec_backtracking(); + + if ( m_state->get_failed() == true) + { + /* Predicate failed + */ + m_state->set_failed(false); + return false; + } + else + { + /* Predicate was successful + */ + m_state->set_failed(false); + return true; + } +} + +template< class ImplTraits, class StreamType > +void BaseRecognizer<ImplTraits, StreamType>::exConstruct() +{ + this->get_super()->exConstruct(); +} + +template< class ImplTraits, class StreamType > +void BaseRecognizer<ImplTraits, StreamType>::reset() +{ + this->reset( ClassForwarder<SuperType>() ); +} + +template< class ImplTraits, class StreamType > +template< typename CompType > +void BaseRecognizer<ImplTraits, StreamType>::reset( ClassForwarder<CompType> ) +{ + typedef typename RecognizerSharedStateType::RuleMemoType RuleMemoType; + m_state->get_following().clear(); + + // Reset the state flags + // + m_state->set_errorRecovery(false); + m_state->set_lastErrorIndex(-1); + m_state->set_failed(false); + m_state->set_errorCount(0); + m_state->set_backtracking(0); + + if (m_state->get_ruleMemo() != NULL) + { + delete m_state->get_ruleMemo(); + m_state->set_ruleMemo( new RuleMemoType(15) ); /* 16 bit depth is enough for 32768 rules! */ + } +} + +template< class ImplTraits, class StreamType > +void BaseRecognizer<ImplTraits, StreamType>::reset( ClassForwarder<LexerType> ) +{ + m_state->set_token_present( false ); + m_state->set_type( ImplTraits::CommonTokenType::TOKEN_INVALID ); + m_state->set_channel( TOKEN_DEFAULT_CHANNEL ); + m_state->set_tokenStartCharIndex( -1 ); + m_state->set_tokenStartCharPositionInLine(-1); + m_state->set_tokenStartLine( -1 ); + m_state->set_text(""); +} + +template< class ImplTraits, class StreamType > +BaseRecognizer<ImplTraits, StreamType>::~BaseRecognizer() +{ + // Did we have a state allocated? + // + if (m_state != NULL) + { + // Free any rule memoization we set up + // + if (m_state->get_ruleMemo() != NULL) + { + delete m_state->get_ruleMemo(); + m_state->set_ruleMemo(NULL); + } + + + // Free any exception space we have left around + // + ExceptionBaseType* thisE = m_state->get_exception(); + if (thisE != NULL) + { + delete thisE; + } + + // Free the shared state memory + // + delete m_state; + } + + // Free the actual recognizer space + // +} + + + +ANTLR_END_NAMESPACE() Property changes on: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.inl ___________________________________________________________________ Added: svn:executable ## -0,0 +1 ## +* \ No newline at end of property Added: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3bitset.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3bitset.hpp (rev 0) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3bitset.hpp 2013-03-11 15:11:21 UTC (rev 4567) @@ -0,0 +1,224 @@ +/** + * \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_HPP +#define _ANTLR3_BITSET_HPP + +// [The "BSD licence"] +// Copyright (c) 2005-2009 Gokulakannan Somasundaram, ElectronDB + +// +// 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 ... [truncated message content] |
From: <ibr...@us...> - 2013-04-17 15:18:32
|
Revision: 4627 http://sourceforge.net/p/tora/code/4627 Author: ibre5041 Date: 2013-04-17 15:18:27 +0000 (Wed, 17 Apr 2013) Log Message: ----------- const corectness Modified Paths: -------------- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontoken.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontoken.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3cyclicdfa.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3exception.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3exception.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3intstream.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3lexer.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3parser.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3tokenstream.inl branches/tora3/extlibs/parsing.cpp/Makefile branches/tora3/extlibs/parsing.cpp/antlr-complete-3.5.1-SNAPSHOT.jar branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/AST.stg branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/ASTParser.stg branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/Cpp.stg Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.inl 2013-04-17 08:31:56 UTC (rev 4626) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.inl 2013-04-17 15:18:27 UTC (rev 4627) @@ -112,7 +112,7 @@ if (nextt == ttype) { if(m_state->get_exception() != NULL) - m_state->get_exception()->set_expecting(nextt); + m_state->get_exception()->setExpecting(nextt); return true; // This token is unknown, but the next one is the one we wanted } else @@ -480,8 +480,8 @@ // new ANTLR_Exception<ImplTraits, MISSING_TOKEN_EXCEPTION, StreamType>(this, ""); matchedSymbol = this->getMissingSymbol( is, m_state->get_exception(), ttype, follow); - m_state->get_exception()->set_token( matchedSymbol ); - m_state->get_exception()->set_expecting(ttype); + m_state->get_exception()->setToken( matchedSymbol ); + m_state->get_exception()->setExpecting(ttype); // Print out the error after we insert so that ANTLRWorks sees the // token in the exception. Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontoken.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontoken.hpp 2013-04-17 08:31:56 UTC (rev 4626) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontoken.hpp 2013-04-17 15:18:27 UTC (rev 4627) @@ -138,10 +138,10 @@ bool operator==( const CommonToken& ctoken ) const; bool operator<( const CommonToken& ctoken ) const; - InputStreamType* get_input() const; - ANTLR_MARKER get_index() const; - void set_index( ANTLR_MARKER index ); - void set_input( InputStreamType* input ); + InputStreamType* getInput() const; + ANTLR_MARKER getIndex() const; + void setIndex( ANTLR_MARKER index ); + void setInput( InputStreamType* input ); /* ============================== * API @@ -152,16 +152,16 @@ */ StringType getText() const; - /** Pointer to a function that 'might' be able to set the text associated + /** 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 set_tokText( const StringType& text ); + void setTokText( const StringType& text ); - /** Pointer to a function that 'might' be able to set the text associated + /** 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 @@ -171,70 +171,68 @@ void setText(ANTLR_UINT8* text); void setText(const char* text); - /** Pointer to a function that returns the token type of this token + /** Function that returns the token type of this token */ - ANTLR_UINT32 get_type() const; ANTLR_UINT32 getType() const; - /** Pointer to a function that sets the type of this token + /** Function that sets the type of this token */ - void set_type(ANTLR_UINT32 ttype); + void setType(ANTLR_UINT32 ttype); - /** Pointer to a function that gets the 'line' number where this token resides + /** Function that gets the 'line' number where this token resides */ - ANTLR_UINT32 get_line() const; + ANTLR_UINT32 getLine() const; - /** Pointer to a function that sets the 'line' number where this token reside + /** Function that sets the 'line' number where this token reside */ - void set_line(ANTLR_UINT32 line); + void setLine(ANTLR_UINT32 line); - /** Pointer to a function that gets the offset in the line where this token exists + /** Function that gets the offset in the line where this token exists */ - ANTLR_INT32 get_charPositionInLine() const; - ANTLR_INT32 getCharPositionInLine() const; + ANTLR_INT32 getCharPositionInLine() const; - /** Pointer to a function that sets the offset in the line where this token exists + /** Function that sets the offset in the line where this token exists */ - void set_charPositionInLine(ANTLR_INT32 pos); + void setCharPositionInLine(ANTLR_INT32 pos); - /** Pointer to a function that gets the channel that this token was placed in (parsers + /** Function that gets the channel that this token was placed in (parsers * can 'tune' to these channels. */ - ANTLR_UINT32 get_channel() const; + ANTLR_UINT32 getChannel() const; - /** Pointer to a function that sets the channel that this token should belong to + /** Function that sets the channel that this token should belong to */ - void set_channel(ANTLR_UINT32 channel); + void setChannel(ANTLR_UINT32 channel); - /** Pointer to a function that returns an index 0...n-1 of the token in the token + /** Function that returns an index 0...n-1 of the token in the token * input stream. */ - ANTLR_MARKER get_tokenIndex() const; + ANTLR_MARKER getTokenIndex() const; - /** Pointer to a function that can set the token index of this token in the token + /** Function that can set the token index of this token in the token * input stream. */ - void set_tokenIndex(ANTLR_MARKER tokenIndex); + void setTokenIndex(ANTLR_MARKER tokenIndex); - /** Pointer to a function that gets the start index in the input stream for this token. + /** Function that gets the start index in the input stream for this token. */ - ANTLR_MARKER get_startIndex() const; + ANTLR_MARKER getStartIndex() const; - /** Pointer to a function that sets the start index in the input stream for this token. + /** Function that sets the start index in the input stream for this token. */ - void set_startIndex(ANTLR_MARKER index); + void setStartIndex(ANTLR_MARKER index); - /** Pointer to a function that gets the stop index in the input stream for this token. + /** Function that gets the stop index in the input stream for this token. */ - ANTLR_MARKER get_stopIndex() const; + ANTLR_MARKER getStopIndex() const; - /** Pointer to a function that sets the stop index in the input stream for this token. + /** Function that sets the stop index in the input stream for this token. */ - void set_stopIndex(ANTLR_MARKER index); - const StreamDataType* get_lineStart() const; - void set_lineStart( const StreamDataType* lineStart ); + void setStopIndex(ANTLR_MARKER index); + const StreamDataType* getLineStart() const; + void setLineStart( const StreamDataType* lineStart ); - /** Pointer to a function that returns this token as a text representation that can be + /** 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. Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontoken.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontoken.inl 2013-04-17 08:31:56 UTC (rev 4626) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontoken.inl 2013-04-17 15:18:27 UTC (rev 4627) @@ -95,25 +95,25 @@ } template<class ImplTraits> -ANTLR_INLINE typename CommonToken<ImplTraits>::InputStreamType* CommonToken<ImplTraits>::get_input() const +ANTLR_INLINE typename CommonToken<ImplTraits>::InputStreamType* CommonToken<ImplTraits>::getInput() const { return m_input; } template<class ImplTraits> -ANTLR_INLINE ANTLR_MARKER CommonToken<ImplTraits>::get_index() const +ANTLR_INLINE ANTLR_MARKER CommonToken<ImplTraits>::getIndex() const { return m_index; } template<class ImplTraits> -ANTLR_INLINE void CommonToken<ImplTraits>::set_index( ANTLR_MARKER index ) +ANTLR_INLINE void CommonToken<ImplTraits>::setIndex( ANTLR_MARKER index ) { m_index = index; } template<class ImplTraits> -void CommonToken<ImplTraits>::set_input( InputStreamType* input ) +void CommonToken<ImplTraits>::setInput( InputStreamType* input ) { m_input = input; } @@ -136,7 +136,7 @@ // from the input stream // if (m_input != NULL) - return m_input->substr( this->get_startIndex(), this->get_stopIndex() ); + return m_input->substr( this->getStartIndex(), this->getStopIndex() ); // Nothing to return, there is no input stream // @@ -144,7 +144,7 @@ } template<class ImplTraits> -ANTLR_INLINE void CommonToken<ImplTraits>::set_tokText( const StringType& text ) +ANTLR_INLINE void CommonToken<ImplTraits>::setTokText( const StringType& text ) { m_tokText = text; } @@ -168,109 +168,97 @@ } template<class ImplTraits> -ANTLR_INLINE ANTLR_UINT32 CommonToken<ImplTraits>::get_type() const -{ - return m_type; -} - -template<class ImplTraits> ANTLR_INLINE ANTLR_UINT32 CommonToken<ImplTraits>::getType() const { return m_type; } template<class ImplTraits> -ANTLR_INLINE void CommonToken<ImplTraits>::set_type(ANTLR_UINT32 ttype) +ANTLR_INLINE void CommonToken<ImplTraits>::setType(ANTLR_UINT32 ttype) { m_type = ttype; } template<class ImplTraits> -ANTLR_INLINE ANTLR_UINT32 CommonToken<ImplTraits>::get_line() const +ANTLR_INLINE ANTLR_UINT32 CommonToken<ImplTraits>::getLine() const { return m_line; } template<class ImplTraits> -ANTLR_INLINE void CommonToken<ImplTraits>::set_line(ANTLR_UINT32 line) +ANTLR_INLINE void CommonToken<ImplTraits>::setLine(ANTLR_UINT32 line) { m_line = line; } template<class ImplTraits> -ANTLR_INLINE ANTLR_INT32 CommonToken<ImplTraits>::get_charPositionInLine() const +ANTLR_INLINE ANTLR_INT32 CommonToken<ImplTraits>::getCharPositionInLine() const { return m_charPositionInLine; } template<class ImplTraits> -ANTLR_INLINE ANTLR_INT32 CommonToken<ImplTraits>::getCharPositionInLine() const +ANTLR_INLINE void CommonToken<ImplTraits>::setCharPositionInLine(ANTLR_INT32 pos) { - return this->get_charPositionInLine(); -} - -template<class ImplTraits> -ANTLR_INLINE void CommonToken<ImplTraits>::set_charPositionInLine(ANTLR_INT32 pos) -{ m_charPositionInLine = pos; } template<class ImplTraits> -ANTLR_INLINE ANTLR_UINT32 CommonToken<ImplTraits>::get_channel() const +ANTLR_INLINE ANTLR_UINT32 CommonToken<ImplTraits>::getChannel() const { return m_channel; } template<class ImplTraits> -ANTLR_INLINE void CommonToken<ImplTraits>::set_channel(ANTLR_UINT32 channel) +ANTLR_INLINE void CommonToken<ImplTraits>::setChannel(ANTLR_UINT32 channel) { m_channel = channel; } template<class ImplTraits> -ANTLR_INLINE ANTLR_MARKER CommonToken<ImplTraits>::get_tokenIndex() const +ANTLR_INLINE ANTLR_MARKER CommonToken<ImplTraits>::getTokenIndex() const { return m_index; } template<class ImplTraits> -ANTLR_INLINE void CommonToken<ImplTraits>::set_tokenIndex(ANTLR_MARKER tokenIndex) +ANTLR_INLINE void CommonToken<ImplTraits>::setTokenIndex(ANTLR_MARKER tokenIndex) { m_index = tokenIndex; } template<class ImplTraits> -ANTLR_INLINE ANTLR_MARKER CommonToken<ImplTraits>::get_startIndex() const +ANTLR_INLINE ANTLR_MARKER CommonToken<ImplTraits>::getStartIndex() const { return (m_startIndex == -1) ? (ANTLR_MARKER)(m_input->get_data()) : m_startIndex; } template<class ImplTraits> -ANTLR_INLINE void CommonToken<ImplTraits>::set_startIndex(ANTLR_MARKER index) +ANTLR_INLINE void CommonToken<ImplTraits>::setStartIndex(ANTLR_MARKER index) { m_startIndex = index; } template<class ImplTraits> -ANTLR_INLINE ANTLR_MARKER CommonToken<ImplTraits>::get_stopIndex() const +ANTLR_INLINE ANTLR_MARKER CommonToken<ImplTraits>::getStopIndex() const { return m_stopIndex; } template<class ImplTraits> -ANTLR_INLINE void CommonToken<ImplTraits>::set_stopIndex(ANTLR_MARKER index) +ANTLR_INLINE void CommonToken<ImplTraits>::setStopIndex(ANTLR_MARKER index) { m_stopIndex = index; } template<class ImplTraits> -ANTLR_INLINE const typename CommonToken<ImplTraits>::StreamDataType* CommonToken<ImplTraits>::get_lineStart() const +ANTLR_INLINE const typename CommonToken<ImplTraits>::StreamDataType* CommonToken<ImplTraits>::getLineStart() const { return m_lineStart; } template<class ImplTraits> -ANTLR_INLINE void CommonToken<ImplTraits>::set_lineStart( const StreamDataType* lineStart ) +ANTLR_INLINE void CommonToken<ImplTraits>::setLineStart( const StreamDataType* lineStart ) { m_lineStart = lineStart; } @@ -292,28 +280,28 @@ * return "[@"+getTokenIndex()+","+start+":"+stop+"='"+txt+"',<"+type+">"+channelStr+","+line+":"+getCharPositionInLine()+"]"; */ outtext << "[Index: "; - outtext << (int)this->get_tokenIndex(); + outtext << (int)this->getTokenIndex(); outtext << " (Start: "; - outtext << (int)this->get_startIndex(); + outtext << (int)this->getStartIndex(); outtext << "-Stop: "; - outtext << (int)this->get_stopIndex(); + outtext << (int)this->getStopIndex(); outtext << ") ='"; outtext << text; outtext << "', type<"; outtext << (int)m_type; outtext << "> "; - if (this->get_channel() > TOKEN_DEFAULT_CHANNEL) + if (this->getChannel() > TOKEN_DEFAULT_CHANNEL) { outtext << "(channel = "; - outtext << (int)this->get_channel(); + outtext << (int)this->getChannel(); outtext << ") "; } outtext << "Line: "; - outtext << (int)this->get_line(); + outtext << (int)this->getLine(); outtext << " LinePos:"; - outtext << (int)this->get_charPositionInLine(); + outtext << (int)this->getCharPositionInLine(); outtext << "]"; return outtext.str(); Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.hpp 2013-04-17 08:31:56 UTC (rev 4626) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.hpp 2013-04-17 15:18:27 UTC (rev 4627) @@ -70,7 +70,7 @@ /// A single token, this is the payload for the tree /// - CommonTokenType* m_token; + const CommonTokenType* m_token; /// Points to the node that has this node as a child. /// If this is NULL, then this is the root node. @@ -84,7 +84,7 @@ public: CommonTree(); - CommonTree( CommonTokenType* token ); + CommonTree( const CommonTokenType* token ); CommonTree( CommonTree* token ); CommonTree( const CommonTree& ctree ); @@ -92,12 +92,19 @@ ChildrenType& get_children(); const ChildrenType& get_children() const; ChildrenType* get_children_p(); - ANTLR_INT32 get_childIndex() const; - TreeType* get_parent() const; + ANTLR_INT32 getChildIndex() const; + TreeType* getParent() const; - void set_parent( TreeType* parent); - void set_childIndex( ANTLR_INT32 ); + ANTLR_MARKER getStartIndex() const; + void setStartIndex(ANTLR_MARKER index); + ANTLR_MARKER getStopIndex() const; + void setStopIndex(ANTLR_MARKER index); + + + void setParent( TreeType* parent); + void setChildIndex( ANTLR_INT32 ); + void addChild(TreeType* child); /// Add all elements of the supplied list as children of this node /// Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.inl 2013-04-17 08:31:56 UTC (rev 4626) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.inl 2013-04-17 15:18:27 UTC (rev 4627) @@ -24,7 +24,7 @@ } template<class ImplTraits> -CommonTree<ImplTraits>::CommonTree( CommonTokenType* token ) +CommonTree<ImplTraits>::CommonTree( const CommonTokenType* token ) { m_savedIndex = 0; m_startIndex = 0; @@ -352,13 +352,13 @@ } template<class ImplTraits> -void CommonTree<ImplTraits>::set_childIndex( ANTLR_INT32 i) +void CommonTree<ImplTraits>::setChildIndex( ANTLR_INT32 i) { m_childIndex = i; } template<class ImplTraits> -ANTLR_INT32 CommonTree<ImplTraits>::get_childIndex() const +ANTLR_INT32 CommonTree<ImplTraits>::getChildIndex() const { return m_childIndex; } @@ -370,18 +370,42 @@ } template<class ImplTraits> -typename CommonTree<ImplTraits>::TreeType* CommonTree<ImplTraits>::get_parent() const +typename CommonTree<ImplTraits>::TreeType* CommonTree<ImplTraits>::getParent() const { return m_parent; } template<class ImplTraits> -void CommonTree<ImplTraits>::set_parent( TreeType* parent) +void CommonTree<ImplTraits>::setParent( TreeType* parent) { m_parent = parent; } template<class ImplTraits> +ANTLR_MARKER CommonTree<ImplTraits>::getStartIndex() const +{ + return m_startIndex; +} + +template<class ImplTraits> +void CommonTree<ImplTraits>::setStartIndex( ANTLR_MARKER index) +{ + m_startIndex = index; +} + +template<class ImplTraits> +ANTLR_MARKER CommonTree<ImplTraits>::getStopIndex() const +{ + return m_stopIndex; +} + +template<class ImplTraits> +void CommonTree<ImplTraits>::setStopIndex( ANTLR_MARKER index) +{ + m_stopIndex = index; +} + +template<class ImplTraits> ANTLR_UINT32 CommonTree<ImplTraits>::getType() { if (this == NULL) Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.hpp 2013-04-17 08:31:56 UTC (rev 4626) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.hpp 2013-04-17 15:18:27 UTC (rev 4627) @@ -45,7 +45,7 @@ typedef typename ImplTraits::TreeType TreeType; typedef TreeType TokenType; typedef typename ImplTraits::CommonTokenType CommonTokenType; - typedef typename ImplTraits::DebugEventListener DebuggerType; + typedef typename ImplTraits::DebugEventListenerType DebuggerType; public: //The parameter is there only to provide uniform constructor interface @@ -59,7 +59,7 @@ void setParent( TreeType* child, TreeType* parent); TreeType* getParent( TreeType* child); - TreeType* errorNode( CommonTokenType* tnstream, CommonTokenType* startToken, CommonTokenType* stopToken); + TreeType* errorNode( CommonTokenType* tnstream, const CommonTokenType* startToken, const CommonTokenType* stopToken); bool isNilNode( TreeType* t); TreeType* becomeRoot( TreeType* newRoot, TreeType* oldRoot); @@ -67,7 +67,7 @@ TreeType* becomeRootToken(CommonTokenType* newRoot, TreeType* oldRoot); - TreeType* create( CommonTokenType* payload); + TreeType* create(const CommonTokenType* payload); TreeType* createTypeToken( ANTLR_UINT32 tokenType, CommonTokenType* fromToken); TreeType* createTypeTokenText ( ANTLR_UINT32 tokenType, CommonTokenType* fromToken, const ANTLR_UINT8* text); TreeType* createTypeText ( ANTLR_UINT32 tokenType, const ANTLR_UINT8* text); @@ -89,7 +89,7 @@ CommonTokenType* createTokenFromToken( CommonTokenType* fromToken); CommonTokenType* getToken( TreeType* t); - void setTokenBoundaries( TreeType* t, CommonTokenType* startToken, CommonTokenType* stopToken); + void setTokenBoundaries( TreeType* t, const CommonTokenType* startToken, const CommonTokenType* stopToken); ANTLR_MARKER getTokenStartIndex( TreeType* t); ANTLR_MARKER getTokenStopIndex( TreeType* t); Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.inl 2013-04-17 08:31:56 UTC (rev 4626) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.inl 2013-04-17 15:18:27 UTC (rev 4627) @@ -71,20 +71,24 @@ } template<class ImplTraits> -typename CommonTreeAdaptor<ImplTraits>::TreeType* CommonTreeAdaptor<ImplTraits>::getParent( TreeType* child) +typename CommonTreeAdaptor<ImplTraits>::TreeType* +CommonTreeAdaptor<ImplTraits>::getParent( TreeType* child) { return child->getParent(); } template<class ImplTraits> -typename CommonTreeAdaptor<ImplTraits>::TreeType* CommonTreeAdaptor<ImplTraits>::errorNode( CommonTokenType* tnstream, CommonTokenType* startToken, CommonTokenType* stopToken) +typename CommonTreeAdaptor<ImplTraits>::TreeType* +CommonTreeAdaptor<ImplTraits>::errorNode( CommonTokenType* tnstream, + const CommonTokenType* startToken, + const CommonTokenType* stopToken) { // Use the supplied common tree node stream to get another tree from the factory // TODO: Look at creating the erronode as in Java, but this is complicated by the // need to track and free the memory allocated to it, so for now, we just // want something in the tree that isn't a NULL pointer. // - return this->createTypeText( CommonTokenType::TOKEN_INVALID, "Tree Error Node"); + return this->createTypeText( CommonTokenType::TOKEN_INVALID, (const ANTLR_UINT8*)"Tree Error Node"); } @@ -95,7 +99,8 @@ } template<class ImplTraits> -typename CommonTreeAdaptor<ImplTraits>::TreeType* CommonTreeAdaptor<ImplTraits>::becomeRoot( TreeType* newRootTree, TreeType* oldRootTree) +typename CommonTreeAdaptor<ImplTraits>::TreeType* +CommonTreeAdaptor<ImplTraits>::becomeRoot( TreeType* newRootTree, TreeType* oldRootTree) { TreeType* saveRoot; @@ -172,7 +177,7 @@ } template<class ImplTraits> -typename CommonTreeAdaptor<ImplTraits>::TreeType* CommonTreeAdaptor<ImplTraits>::create( CommonTokenType* payload) +typename CommonTreeAdaptor<ImplTraits>::TreeType* CommonTreeAdaptor<ImplTraits>::create(const CommonTokenType* payload) { return new TreeType(payload); } @@ -297,7 +302,7 @@ if (newToken != NULL) { - newToken->set_tokText( (const char*) text ); + newToken->setTokText( (const char*) text ); newToken->setType(tokenType); } return newToken; @@ -337,7 +342,7 @@ } template<class ImplTraits> -void CommonTreeAdaptor<ImplTraits>::setTokenBoundaries( TreeType* t, CommonTokenType* startToken, CommonTokenType* stopToken) +void CommonTreeAdaptor<ImplTraits>::setTokenBoundaries( TreeType* t, const CommonTokenType* startToken, const CommonTokenType* stopToken) { ANTLR_MARKER start; ANTLR_MARKER stop; @@ -369,8 +374,8 @@ ct = t; - ct->set_startIndex(start); - ct->set_stopIndex(stop); + ct->setStartIndex(start); + ct->setStopIndex(stop); } template<class ImplTraits> Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3cyclicdfa.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3cyclicdfa.inl 2013-04-17 08:31:56 UTC (rev 4626) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3cyclicdfa.inl 2013-04-17 15:18:27 UTC (rev 4627) @@ -196,8 +196,8 @@ { ANTLR_Exception<ImplTraits, NO_VIABLE_ALT_EXCEPTION, StreamType>* ex = new ANTLR_Exception<ImplTraits, NO_VIABLE_ALT_EXCEPTION, StreamType>( rec, (const char*)m_description ); - ex->set_decisionNum( m_decisionNumber ); - ex->set_state(s); + ex->setDecisionNum( m_decisionNumber ); + ex->setState(s); } } Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3exception.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3exception.hpp 2013-04-17 08:31:56 UTC (rev 4626) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3exception.hpp 2013-04-17 15:18:27 UTC (rev 4627) @@ -138,36 +138,36 @@ IntStreamType* m_input; public: - StringType& get_message(); - StringType& get_streamName(); - ANTLR_MARKER get_index() const; - const TokenType* get_token() const; - ExceptionBaseType* get_nextException() const; - ANTLR_UINT32 get_expecting() const; - BitsetListType* get_expectingSet() const; - TokenType* get_node() const; - ANTLR_UCHAR get_c() const; - ANTLR_UINT32 get_line() const; - ANTLR_INT32 get_charPositionInLine() const; - ANTLR_UINT32 get_decisionNum() const; - ANTLR_UINT32 get_state() const; - StringType& get_ruleName(); - IntStreamType* get_input() const; - void set_message( const StringType& message ); - void set_streamName( const StringType& streamName ); - void set_index( ANTLR_MARKER index ); - void set_token( const TokenType* token ); - void set_nextException( ExceptionBaseType* nextException ); - void set_expecting( ANTLR_UINT32 expecting ); - void set_expectingSet( BitsetListType* expectingSet ); - void set_node( TokenType* node ); - void set_c( ANTLR_UCHAR c ); - void set_line( ANTLR_UINT32 line ); - void set_charPositionInLine( ANTLR_INT32 charPositionInLine ); - void set_decisionNum( ANTLR_UINT32 decisionNum ); - void set_state( ANTLR_UINT32 state ); - void set_ruleName( const StringType& ruleName ); - void set_input( IntStreamType* input ); + StringType& getMessage(); + StringType& getStreamName(); + ANTLR_MARKER getIndex() const; + const TokenType* getToken() const; + ExceptionBaseType* getNextException() const; + ANTLR_UINT32 getExpecting() const; + BitsetListType* getExpectingSet() const; + TokenType* getNode() const; + ANTLR_UCHAR getC() const; + ANTLR_UINT32 getLine() const; + ANTLR_INT32 getCharPositionInLine() const; + ANTLR_UINT32 getDecisionNum() const; + ANTLR_UINT32 getState() const; + StringType& getRuleName(); + IntStreamType* getInput() const; + void setMessage( const StringType& message ); + void setStreamName( const StringType& streamName ); + void setIndex( ANTLR_MARKER index ); + void setToken( const TokenType* token ); + void setNextException( ExceptionBaseType* nextException ); + void setExpecting( ANTLR_UINT32 expecting ); + void setExpectingSet( BitsetListType* expectingSet ); + void setNode( TokenType* node ); + void setC( ANTLR_UCHAR c ); + void setLine( ANTLR_UINT32 line ); + void setCharPositionInLine( ANTLR_INT32 charPositionInLine ); + void setDecisionNum( ANTLR_UINT32 decisionNum ); + void setState( ANTLR_UINT32 state ); + void setRuleName( const StringType& ruleName ); + void setInput( IntStreamType* input ); StringType getDescription() const; virtual StringType getName() const = 0; Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3exception.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3exception.inl 2013-04-17 08:31:56 UTC (rev 4626) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3exception.inl 2013-04-17 15:18:27 UTC (rev 4627) @@ -18,152 +18,152 @@ } template<class ImplTraits, class StreamType> -ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::StringType& ANTLR_ExceptionBase<ImplTraits, StreamType>::get_message() +ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::StringType& ANTLR_ExceptionBase<ImplTraits, StreamType>::getMessage() { return m_message; } template<class ImplTraits, class StreamType> -ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::StringType& ANTLR_ExceptionBase<ImplTraits, StreamType>::get_streamName() +ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::StringType& ANTLR_ExceptionBase<ImplTraits, StreamType>::getStreamName() { return m_streamName; } template<class ImplTraits, class StreamType> -ANTLR_INLINE ANTLR_MARKER ANTLR_ExceptionBase<ImplTraits, StreamType>::get_index() const +ANTLR_INLINE ANTLR_MARKER ANTLR_ExceptionBase<ImplTraits, StreamType>::getIndex() const { return m_index; } template<class ImplTraits, class StreamType> -ANTLR_INLINE const typename ANTLR_ExceptionBase<ImplTraits, StreamType>::TokenType* ANTLR_ExceptionBase<ImplTraits, StreamType>::get_token() const +ANTLR_INLINE const typename ANTLR_ExceptionBase<ImplTraits, StreamType>::TokenType* ANTLR_ExceptionBase<ImplTraits, StreamType>::getToken() const { return m_token; } template<class ImplTraits, class StreamType> -ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::ExceptionBaseType* ANTLR_ExceptionBase<ImplTraits, StreamType>::get_nextException() const +ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::ExceptionBaseType* ANTLR_ExceptionBase<ImplTraits, StreamType>::getNextException() const { return m_nextException; } template<class ImplTraits, class StreamType> -ANTLR_INLINE ANTLR_UINT32 ANTLR_ExceptionBase<ImplTraits, StreamType>::get_expecting() const +ANTLR_INLINE ANTLR_UINT32 ANTLR_ExceptionBase<ImplTraits, StreamType>::getExpecting() const { return m_expecting; } template<class ImplTraits, class StreamType> -ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::BitsetListType* ANTLR_ExceptionBase<ImplTraits, StreamType>::get_expectingSet() const +ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::BitsetListType* ANTLR_ExceptionBase<ImplTraits, StreamType>::getExpectingSet() const { return m_expectingSet; } template<class ImplTraits, class StreamType> -ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::TokenType* ANTLR_ExceptionBase<ImplTraits, StreamType>::get_node() const +ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::TokenType* ANTLR_ExceptionBase<ImplTraits, StreamType>::getNode() const { return m_node; } template<class ImplTraits, class StreamType> -ANTLR_INLINE ANTLR_UCHAR ANTLR_ExceptionBase<ImplTraits, StreamType>::get_c() const +ANTLR_INLINE ANTLR_UCHAR ANTLR_ExceptionBase<ImplTraits, StreamType>::getC() const { return m_c; } template<class ImplTraits, class StreamType> -ANTLR_INLINE ANTLR_UINT32 ANTLR_ExceptionBase<ImplTraits, StreamType>::get_line() const +ANTLR_INLINE ANTLR_UINT32 ANTLR_ExceptionBase<ImplTraits, StreamType>::getLine() const { return m_line; } template<class ImplTraits, class StreamType> -ANTLR_INLINE ANTLR_INT32 ANTLR_ExceptionBase<ImplTraits, StreamType>::get_charPositionInLine() const +ANTLR_INLINE ANTLR_INT32 ANTLR_ExceptionBase<ImplTraits, StreamType>::getCharPositionInLine() const { return m_charPositionInLine; } template<class ImplTraits, class StreamType> -ANTLR_INLINE ANTLR_UINT32 ANTLR_ExceptionBase<ImplTraits, StreamType>::get_decisionNum() const +ANTLR_INLINE ANTLR_UINT32 ANTLR_ExceptionBase<ImplTraits, StreamType>::getDecisionNum() const { return m_decisionNum; } template<class ImplTraits, class StreamType> -ANTLR_INLINE ANTLR_UINT32 ANTLR_ExceptionBase<ImplTraits, StreamType>::get_state() const +ANTLR_INLINE ANTLR_UINT32 ANTLR_ExceptionBase<ImplTraits, StreamType>::getState() const { return m_state; } template<class ImplTraits, class StreamType> -ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::StringType& ANTLR_ExceptionBase<ImplTraits, StreamType>::get_ruleName() +ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::StringType& ANTLR_ExceptionBase<ImplTraits, StreamType>::getRuleName() { return m_ruleName; } template<class ImplTraits, class StreamType> -ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::IntStreamType* ANTLR_ExceptionBase<ImplTraits, StreamType>::get_input() const +ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::IntStreamType* ANTLR_ExceptionBase<ImplTraits, StreamType>::getInput() const { return m_input; } template<class ImplTraits, class StreamType> -ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_message( const StringType& message ) +ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::setMessage( const StringType& message ) { m_message = message; } template<class ImplTraits, class StreamType> -ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_streamName( const StringType& streamName ) +ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::setStreamName( const StringType& streamName ) { m_streamName = streamName; } template<class ImplTraits, class StreamType> -ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_index( ANTLR_MARKER index ) +ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::setIndex( ANTLR_MARKER index ) { m_index = index; } template<class ImplTraits, class StreamType> -ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_token( const TokenType* token ) +ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::setToken( const TokenType* token ) { m_token = token; } template<class ImplTraits, class StreamType> -ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_nextException( ExceptionBaseType* nextException ) +ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::setNextException( ExceptionBaseType* nextException ) { m_nextException = nextException; } template<class ImplTraits, class StreamType> -ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_expecting( ANTLR_UINT32 expecting ) +ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::setExpecting( ANTLR_UINT32 expecting ) { m_expecting = expecting; } template<class ImplTraits, class StreamType> -ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_expectingSet( BitsetListType* expectingSet ) +ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::setExpectingSet( BitsetListType* expectingSet ) { m_expectingSet = expectingSet; } template<class ImplTraits, class StreamType> -ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_node( TokenType* node ) +ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::setNode( TokenType* node ) { m_node = node; } template<class ImplTraits, class StreamType> -ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_c( ANTLR_UCHAR c ) +ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::setC( ANTLR_UCHAR c ) { m_c = c; } template<class ImplTraits, class StreamType> -ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_line( ANTLR_UINT32 line ) +ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::setLine( ANTLR_UINT32 line ) { m_line = line; } template<class ImplTraits, class StreamType> -ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_charPositionInLine( ANTLR_INT32 charPositionInLine ) +ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::setCharPositionInLine( ANTLR_INT32 charPositionInLine ) { m_charPositionInLine = charPositionInLine; } template<class ImplTraits, class StreamType> -ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_decisionNum( ANTLR_UINT32 decisionNum ) +ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::setDecisionNum( ANTLR_UINT32 decisionNum ) { m_decisionNum = decisionNum; } template<class ImplTraits, class StreamType> -ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_state( ANTLR_UINT32 state ) +ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::setState( ANTLR_UINT32 state ) { m_state = state; } template<class ImplTraits, class StreamType> -ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_ruleName( const StringType& ruleName ) +ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::setRuleName( const StringType& ruleName ) { m_ruleName = ruleName; } template<class ImplTraits, class StreamType> -ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_input( IntStreamType* input ) +ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::setInput( IntStreamType* input ) { m_input = input; } Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3intstream.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3intstream.inl 2013-04-17 08:31:56 UTC (rev 4626) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3intstream.inl 2013-04-17 15:18:27 UTC (rev 4627) @@ -1486,7 +1486,7 @@ if (tok != NULL) { - return tok->get_type(); + return tok->getType(); } else { Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3lexer.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3lexer.inl 2013-04-17 08:31:56 UTC (rev 4626) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3lexer.inl 2013-04-17 15:18:27 UTC (rev 4627) @@ -50,36 +50,36 @@ } else { - err_stream << ex->get_streamName().c_str(); + err_stream << ex->getStreamName().c_str(); err_stream << "("; } - err_stream << ex->get_line() << ")"; + err_stream << ex->getLine() << ")"; err_stream << ": lexer error " << ex->getType() << " :\n\t" - << ex->get_message() << " at offset " - << ex->get_charPositionInLine()+1 << ", "; + << ex->getMessage() << " at offset " + << ex->getCharPositionInLine()+1 << ", "; { ANTLR_UINT32 width; width = ANTLR_UINT32_CAST(( (ANTLR_UINT8*)(m_input->get_data()) + - (m_input->size() )) - (ANTLR_UINT8*)( ex->get_index() )); + (m_input->size() )) - (ANTLR_UINT8*)( ex->getIndex() )); if (width >= 1) { - if (isprint(ex->get_c() )) + if (isprint(ex->getC() )) { - err_stream << "near '" << ex->get_c() << "' :\n"; + err_stream << "near '" << ex->getC() << "' :\n"; } else { char tmp[128]; - sprintf( tmp, "near char(%#02X) :\n", ex->get_c() ); + sprintf( tmp, "near char(%#02X) :\n", ex->getC() ); err_stream << tmp; } err_stream << "\t"; err_stream.width( width > 20 ? 20 : width ); - err_stream << ex->get_index() << "\n"; + err_stream << ex->getIndex() << "\n"; } else { @@ -110,12 +110,12 @@ template<class ImplTraits> void Lexer<ImplTraits>::fillExceptionData( ExceptionBaseType* ex ) { - ex->set_c( m_input->_LA(1) ); /* Current input character */ - ex->set_line( m_input->get_line() ); /* Line number comes from stream */ - ex->set_charPositionInLine( m_input->get_charPositionInLine() ); /* Line offset also comes from the stream */ - ex->set_index( m_input->index() ); - ex->set_streamName( m_input->get_fileName() ); - ex->set_message( "Unexpected character" ); + ex->setC( m_input->_LA(1) ); /* Current input character */ + ex->setLine( m_input->get_line() ); /* Line number comes from stream */ + ex->setCharPositionInLine( m_input->get_charPositionInLine() ); /* Line offset also comes from the stream */ + ex->setIndex( m_input->index() ); + ex->setStreamName( m_input->get_fileName() ); + ex->setMessage( "Unexpected character" ); } template<class ImplTraits> @@ -197,21 +197,21 @@ RecognizerSharedStateType* state = this->get_rec()->get_state(); state->set_token_present(true); CommonTokenType* token = state->get_token(); - token->set_input( this->get_input() ); + token->setInput( this->get_input() ); /* Install the supplied information, and some other bits we already know * get added automatically, such as the input stream it is associated with * (though it can all be overridden of course) */ - token->set_type( state->get_type() ); - token->set_channel( state->get_channel() ); - token->set_startIndex( state->get_tokenStartCharIndex() ); - token->set_stopIndex( this->getCharIndex() - 1 ); - token->set_line( state->get_tokenStartLine() ); - token->set_charPositionInLine( state->get_tokenStartCharPositionInLine() ); + token->setType( state->get_type() ); + token->setChannel( state->get_channel() ); + token->setStartIndex( state->get_tokenStartCharIndex() ); + token->setStopIndex( this->getCharIndex() - 1 ); + token->setLine( state->get_tokenStartLine() ); + token->setCharPositionInLine( state->get_tokenStartCharPositionInLine() ); - token->set_tokText( state->get_text() ); - token->set_lineStart( this->get_input()->get_currentLine() ); + token->setTokText( state->get_text() ); + token->setLineStart( this->get_input()->get_currentLine() ); return token; } Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3parser.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3parser.inl 2013-04-17 08:31:56 UTC (rev 4626) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3parser.inl 2013-04-17 15:18:27 UTC (rev 4627) @@ -52,19 +52,19 @@ template< class ImplTraits > void Parser<ImplTraits>::fillExceptionData( ExceptionBaseType* ex ) { - ex->set_token( m_tstream->_LT(1) ); /* Current input token */ - ex->set_line( ex->get_token()->get_line() ); - ex->set_charPositionInLine( ex->get_token()->get_charPositionInLine() ); - ex->set_index( this->get_istream()->index() ); - if( ex->get_token()->get_type() == CommonTokenType::TOKEN_EOF) + ex->setToken( m_tstream->_LT(1) ); /* Current input token */ + ex->setLine( ex->getToken()->getLine() ); + ex->setCharPositionInLine( ex->getToken()->getCharPositionInLine() ); + ex->setIndex( this->get_istream()->index() ); + if( ex->getToken()->getType() == CommonTokenType::TOKEN_EOF) { - ex->set_streamName(""); + ex->setStreamName(""); } else { - ex->set_streamName( ex->get_token()->get_input()->get_fileName() ); + ex->setStreamName( ex->getToken()->getInput()->get_fileName() ); } - ex->set_message("Unexpected token"); + ex->setMessage("Unexpected token"); } template< class ImplTraits > @@ -73,9 +73,9 @@ typename ImplTraits::StringStreamType errtext; // See if there is a 'filename' we can use // - if( ex->get_streamName().empty() ) + if( ex->getStreamName().empty() ) { - if(ex->get_token()->get_type() == CommonTokenType::TOKEN_EOF) + if(ex->getToken()->getType() == CommonTokenType::TOKEN_EOF) { errtext << "-end of input-("; } @@ -86,26 +86,26 @@ } else { - errtext << ex->get_streamName() << "("; + errtext << ex->getStreamName() << "("; } // Next comes the line number // - errtext << this->get_rec()->get_state()->get_exception()->get_line() << ") "; + errtext << this->get_rec()->get_state()->get_exception()->getLine() << ") "; errtext << " : error " << this->get_rec()->get_state()->get_exception()->getType() << " : " - << this->get_rec()->get_state()->get_exception()->get_message(); + << this->get_rec()->get_state()->get_exception()->getMessage(); // Prepare the knowledge we know we have // - const CommonTokenType* theToken = this->get_rec()->get_state()->get_exception()->get_token(); + const CommonTokenType* theToken = this->get_rec()->get_state()->get_exception()->getToken(); StringType ttext = theToken->toString(); errtext << ", at offset , " - << this->get_rec()->get_state()->get_exception()->get_charPositionInLine(); + << this->get_rec()->get_state()->get_exception()->getCharPositionInLine(); if (theToken != NULL) { - if (theToken->get_type() == CommonTokenType::TOKEN_EOF) + if (theToken->getType() == CommonTokenType::TOKEN_EOF) { errtext << ", at <EOF>"; } @@ -206,7 +206,7 @@ // If we are at EOF, we use the token before EOF // current = cts->_LT(1); - if (current->get_type() == CommonTokenType::TOKEN_EOF) + if (current->getType() == CommonTokenType::TOKEN_EOF) { current = cts->_LT(-1); } @@ -215,11 +215,11 @@ // Set some of the token properties based on the current token // - token->set_line(current->get_line()); - token->set_charPositionInLine( current->get_charPositionInLine()); - token->set_channel( TOKEN_DEFAULT_CHANNEL ); - token->set_type(expectedTokenType); - token->set_lineStart( current->get_lineStart() ); + token->setLine(current->getLine()); + token->setCharPositionInLine( current->getCharPositionInLine()); + token->setChannel( TOKEN_DEFAULT_CHANNEL ); + token->setType(expectedTokenType); + token->setLineStart( current->getLineStart() ); // Create the token text that shows it has been inserted // Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3tokenstream.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3tokenstream.inl 2013-04-17 08:31:56 UTC (rev 4626) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3tokenstream.inl 2013-04-17 15:18:27 UTC (rev 4627) @@ -89,9 +89,9 @@ // TokenType& teof = m_eofToken; - teof.set_startIndex(lexer->getCharIndex()); - teof.set_stopIndex(lexer->getCharIndex()); - teof.set_line(lexer->getLine()); + teof.setStartIndex(lexer->getCharIndex()); + teof.setStopIndex(lexer->getCharIndex()); + teof.setLine(lexer->getLine()); return &teof; } @@ -233,7 +233,7 @@ // that isn't EOF or we reach the actual end of the last input // stream on the stack. // - while(tok->get_type() == CommonTokenType::TOKEN_EOF) + while(tok->getType() == CommonTokenType::TOKEN_EOF) { typename ImplTraits::LexerType* lexer; lexer = static_cast<typename ImplTraits::LexerType*>( this->get_super() ); @@ -419,8 +419,8 @@ { TokenType& teof = cts->get_tokenSource()->get_eofToken(); - teof.set_startIndex( this->get_istream()->index()); - teof.set_stopIndex( this->get_istream()->index()); + teof.setStartIndex( this->get_istream()->index()); + teof.setStopIndex( this->get_istream()->index()); return &teof; } @@ -444,8 +444,8 @@ { TokenType& teof = cts->get_tokenSource()->get_eofToken(); - teof.set_startIndex(this->get_istream()->index()); - teof.set_stopIndex(this->get_istream()->index()); + teof.setStartIndex(this->get_istream()->index()); + teof.setStopIndex(this->get_istream()->index()); return &teof; } @@ -701,7 +701,7 @@ tok = this->get(i); if ( types == NULL - || (types->isMember( tok->get_type() ) == true ) + || (types->isMember( tok->getType() ) == true ) ) { filteredList.push_back(tok); @@ -776,7 +776,7 @@ */ tok = this->get_tokenSource()->nextToken(); - while ( tok->get_type() != TokenType::TOKEN_EOF ) + while ( tok->getType() != TokenType::TOKEN_EOF ) { discard = false; /* Assume we are not discarding */ @@ -786,12 +786,12 @@ * we can distinguish "not being there" from "being channel or type 0" */ - if ( m_discardSet.find(tok->get_type()) != m_discardSet.end() ) + if ( m_discardSet.find(tok->getType()) != m_discardSet.end() ) { discard = true; } else if ( m_discardOffChannel == true - && tok->get_channel() != m_channel + && tok->getChannel() != m_channel ) { discard = true; @@ -800,13 +800,13 @@ { /* See if this type is in the override map */ - typename ChannelOverridesType::iterator iter = m_channelOverrides.find( tok->get_type() + 1 ); + typename ChannelOverridesType::iterator iter = m_channelOverrides.find( tok->getType() + 1 ); if (iter != m_channelOverrides.end()) { /* Override found */ - tok->set_channel( ANTLR_UINT32_CAST(iter->second) - 1); + tok->setChannel( ANTLR_UINT32_CAST(iter->second) - 1); } } @@ -816,7 +816,7 @@ { /* Add it, indicating that we will delete it and the table should not */ - tok->set_tokenIndex(index); + tok->setTokenIndex(index); ++m_p; this->insertToken(*tok); index++; @@ -855,7 +855,7 @@ { const TokenType* tok = this->getToken(i); - if (tok->get_channel() != m_channel ) + if (tok->getChannel() != m_channel ) { i++; } @@ -874,7 +874,7 @@ { const TokenType* tok = this->getToken(x); - if( tok->get_channel() != m_channel ) + if( tok->getChannel() != m_channel ) { x--; } Modified: branches/tora3/extlibs/parsing.cpp/Makefile =================================================================== --- branches/tora3/extlibs/parsing.cpp/Makefile 2013-04-17 08:31:56 UTC (rev 4626) +++ branches/tora3/extlibs/parsing.cpp/Makefile 2013-04-17 15:18:27 UTC (rev 4627) @@ -18,7 +18,7 @@ TOBJS= utils.o -all: t0 m0 p0 +all: t0 m0 p0 s0 $(ANTLR): org/antlr/codegen/templates/Cpp/Cpp.stg \ org/antlr/codegen/templates/Cpp/AST.stg \ Modified: branches/tora3/extlibs/parsing.cpp/antlr-complete-3.5.1-SNAPSHOT.jar =================================================================== (Binary files differ) Modified: branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/AST.stg =================================================================== --- branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/AST.stg 2013-04-17 08:31:56 UTC (rev 4626) +++ branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/AST.stg 2013-04-17 15:18:27 UTC (rev 4627) @@ -59,6 +59,10 @@ @returnScope.ruleReturnMembers() ::= << <super.ASTLabelType()> tree; <super.ASTLabelType()> getTree() { return tree; } +void init () +{ + tree = NULL; +} >> /** Add a variable to track rule's return AST */ @@ -299,7 +303,7 @@ <root:rewriteElement()> <children:rewriteElement()> TreeAdaptorType::addChild(root_<enclosingTreeLevel>, root_<treeLevel>); -}<\n> +} >> rewriteElementList(elements) ::= "<elements:rewriteElement()>" Modified: branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/ASTParser.stg =================================================================== --- branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/ASTParser.stg 2013-04-17 08:31:56 UTC (rev 4626) +++ branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/ASTParser.stg 2013-04-17 15:18:27 UTC (rev 4627) @@ -39,8 +39,9 @@ */ @rule.setErrorReturnValue() ::= << -retval.tree = (<ASTLabelType>)TreeAdaptorType::errorNode(input, retval.start, input.LT(-1), re);<! - System.out.println("<ruleName> returns "+((CommonTree)retval.tree).toStringTree()); !> +//TODO +//retval.tree = (<ASTLabelType>)TreeAdaptorType::errorNode(input, retval.start, input.LT(-1)); +retval.tree = (<ASTLabelType>)TreeAdaptorType::errorNode(NULL, retval.start, LT(-1)); >> // TOKEN AST STUFF Modified: branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/Cpp.stg =================================================================== --- branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/Cpp.stg 2013-04-17 08:31:56 UTC (rev 4626) +++ branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/Cpp.stg 2013-04-17 15:18:27 UTC (rev 4627) @@ -384,7 +384,11 @@ /** Context tracking structure for <mainName()> */ -class <name> : public <componentBaseType()>, public <name>Tokens, <name>ImplTraits::TreeAdaptorType +class <name> : public <componentBaseType()> + , public <name>Tokens +<if(PARSER)> + , <name>ImplTraits::TreeAdaptorType +<endif> { public: typedef <name>ImplTraits ImplTraits; @@ -393,8 +397,10 @@ typedef <componentBaseType()> BaseType; typedef ImplTraits::RecognizerSharedStateType\<StreamType> RecognizerSharedStateType; typedef StreamType InputType; - typedef typename ImplTraits::CommonTokenType CommonTokenType; - typedef typename ImplTraits::TreeAdaptorType TreeAdaptorType; +<if(PARSER)> + typedef <name>ImplTraits::CommonTokenType CommonTokenType; + typedef <name>ImplTraits::TreeAdaptorType TreeAdaptorType; +<endif> <if(recognizer.filterMode)> static const bool IsFiltered = true; @@ -434,7 +440,7 @@ <if(recognizer.filterMode)> void memoize(ANTLR_MARKER ruleIndex, ANTLR_MARKER ruleParseStart); bool alreadyParsedRule(ANTLR_MARKER ruleIndex); - <filteringNextToken()> // Copied from Java Target byIvan + <filteringNextToken()> <endif> <rules:{r | <if(!r.ruleDescriptor.isSynPred)><headerReturnType(ruleDescriptor=r.ruleDescriptor)> m<r.ruleDescriptor.name>( <r.ruleDescriptor.parameterScope:parameterScope()>);<endif>}; separator="\n"> <rules:{r | <if(r.ruleDescriptor.isSynPred)> <headerReturnType(ruleDescriptor=r.ruleDescriptor)> msynpred( antlr3::ClassForwarder\< <r.ruleDescriptor.name> > <r.ruleDescriptor.parameterScope:parameterScope()>); @@ -564,7 +570,7 @@ numRules, filterMode, superClass, - labelType="ImplTraits::CommonTokenType*") ::= << + labelType="const ImplTraits::CommonTokenType*") ::= << using namespace antlr3; @@ -1029,7 +1035,7 @@ bitsets, ASTLabelType, superClass="Parser", - labelType="CommonTokenType*", + labelType="const CommonTokenType*", members={<actions.parser.members>} ) ::= << <beginNamespace(actions)> @@ -1069,7 +1075,7 @@ */ synpredRule(ruleName, ruleDescriptor, block, description, nakedBlock) ::= << -// $ANTLR start <ruleName> +// $ANTLR start synpredRule <ruleName> void <name>::m<ruleName>_fragment( <ruleDescriptor.parameterScope:parameterScope()> ) { <ruleLabelDefs()> @@ -1082,9 +1088,11 @@ <else> <block> <endif> -<ruleCleanUp()> + +goto rule<ruleDescriptor.name>Ex; /* Prevent compiler warnings */ +rule<ruleDescriptor.name>Ex: ; } -// $ANTLR end <ruleName> +// $ANTLR end synpredRule <ruleName> >> synpred(predname) ::= << @@ -1280,25 +1288,20 @@ >> ruleLabelDefs() ::= << -<[ruleDescriptor.tokenLabels,ruleDescriptor.tokenListLabels] - :{it |<labelType> <it.label.text>;}; separator="\n" +<[ruleDescriptor.tokenLabels,ruleDescriptor.tokenListLabels, + ruleDescriptor.wildcardTreeLabels,ruleDescriptor.wildcardTreeListLabels] + :{it |<labelType> <it.label.text> = NULL;}; separator="\n" > -<[ruleDescriptor.tokenListLabels,ruleDescriptor.ruleListLabels] - :{it | VectorType\<const CommonTokenType*> list_<it.label.text>;}; separator="\n" +<[ruleDescriptor.tokenListLabels,ruleDescriptor.ruleListLabels,ruleDescriptor.wildcardTreeListLabels] + :{it |List\<Object> list_<it.label.text> = NULL;}; separator="\n" > <ruleDescriptor.ruleLabels:ruleLabelDef(); separator="\n"> >> ruleLabelInitializations() ::= << -<[ruleDescriptor.tokenLabels,ruleDescriptor.tokenListLabels] - :{it |<it.label.text> = NULL;}; separator="\n" -> -<[ruleDescriptor.ruleLabels,ruleDescriptor.ruleListLabels] - :ruleLabelInitVal(); separator="\n" -> <if(ruleDescriptor.hasMultipleReturnValues)> <if(!ruleDescriptor.isSynPred)> -retval.call_start_placeholder(); <\n> +retval.call_start_placeholder(); <endif> <endif> >> @@ -1691,7 +1694,7 @@ mismatchedSetEx() ::= << new ANTLR_Exception\< <name>ImplTraits, MISMATCHED_SET_EXCEPTION, StreamType>( this->get_rec(), "" ); <if(PARSER)> -this->get_exception()->set_expectingSet(NULL); +this->get_exception()->setExpectingSet(NULL); <! use following code to make it recover inline; this->get_exception()->set_expectingSet( &FOLLOW_set_in_<ruleName><elementIndex> ); !> @@ -1888,8 +1891,8 @@ newNVException() ::= << ExceptionBaseType* ex = new ANTLR_Exception\< <name>ImplTraits, NO_VIABLE_ALT_EXCEPTION, StreamType>( this->get_rec(), "<description>" ); -ex->set_decisionNum( <decisionNumber> ); -ex->set_state( <stateNumber> ); +ex->setDecisionNum( <decisionNumber> ); +ex->setState( <stateNumber> ); <@noViableAltException()> <\n> >> @@ -2144,8 +2147,8 @@ } <endif> ExceptionBaseType* ex = new ANTLR_Exception\< <name>ImplTraits, NO_VIABLE_ALT_EXCEPTION, StreamType>( recognizer, "<dfa.description>" ); - ex->set_decisionNum( <dfa.decisionNumber> ); - ex->set_state(_s); + ex->setDecisionNum( <dfa.decisionNumber> ); + ex->setState(_s); <@noViableAltException()> return -1; } @@ -2383,16 +2386,16 @@ <name>ImplTraits::<recognizer.ASTLabelType> stop; <endif> <@ruleReturnMembers()> - <ruleDescriptor.returnScope.attributes:{it |<it.type> <it.name>;}; separator="\n"> + <ruleDescriptor.returnScope.attributes:{it |<it.type> <it.name>;}; separator="\n"> <if(!TREE_PARSER)> - <ruleDescriptor:returnStructName()>() {} - <ruleDescriptor:returnStructName()>( BaseParserType* parser ) : BaseType(parser) {} + <ruleDescriptor:returnStructName()>() { init(); } + <ruleDescriptor:returnStructName()>( BaseParserType* parser ) : BaseType(parser) { init(); } <ruleDescriptor:returnStructName()>( const <ruleDescriptor:returnStructName()>& n ) : BaseType(n) <if(ruleDescriptor.returnScope.attributes)> , <ruleDescriptor.returnScope.attributes:{it | <it.name>(n.<it.name>) }; separator=","> <endif> - {} + { init(); } <ruleDescriptor:returnStructName()>& operator=( const <ruleDescriptor:returnStructName()>& n ) @@ -2423,7 +2426,7 @@ <endif> -};<\n><\n> +}; <endif> <endif> This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <ibr...@us...> - 2013-04-18 13:23:02
|
Revision: 4628 http://sourceforge.net/p/tora/code/4628 Author: ibre5041 Date: 2013-04-18 13:22:51 +0000 (Thu, 18 Apr 2013) Log Message: ----------- Modified Paths: -------------- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3bitset.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3bitset.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3collections.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3collections.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontoken.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3cyclicdfa.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3exception.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3filestream.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3input.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3input.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3intstream.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3intstream.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3lexer.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3lexer.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3parser.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3parser.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3recognizersharedstate.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3recognizersharedstate.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3tokenstream.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3tokenstream.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3treeparser.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3treeparser.inl branches/tora3/extlibs/parsing.cpp/Makefile branches/tora3/extlibs/parsing.cpp/OraclePLSQL.g branches/tora3/extlibs/parsing.cpp/PLSQLGuiLexer.g branches/tora3/extlibs/parsing.cpp/SQLMini.g branches/tora3/extlibs/parsing.cpp/m0.cpp branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/AST.stg branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/ASTParser.stg branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/Cpp.stg branches/tora3/extlibs/parsing.cpp/p0.cpp branches/tora3/extlibs/parsing.cpp/s0.cpp branches/tora3/extlibs/parsing.cpp/t0.cpp Removed Paths: ------------- branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/ASTDbg.stg branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/ASTTreeParser.stg branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/Dbg.stg Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.hpp 2013-04-17 15:18:27 UTC (rev 4627) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.hpp 2013-04-18 13:22:51 UTC (rev 4628) @@ -83,11 +83,11 @@ public: BaseRecognizer(ANTLR_UINT32 sizeHint, RecognizerSharedStateType* state); - SuperType* get_super(); - RecognizerSharedStateType* get_state() const; - DebugEventListenerType* get_debugger() const; - void set_state( RecognizerSharedStateType* state ); - void set_debugger( DebugEventListenerType* debugger ); + SuperType* getSuper(); + RecognizerSharedStateType* getState() const; + DebugEventListenerType* getDebugger() const; + void setState( RecognizerSharedStateType* state ); + void setDebugger( DebugEventListenerType* debugger ); /// Match current input symbol against ttype. Upon error, do one token /// insertion or deletion if possible. Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.inl 2013-04-17 15:18:27 UTC (rev 4627) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.inl 2013-04-18 13:22:51 UTC (rev 4628) @@ -12,7 +12,7 @@ if (state == NULL) { m_state = new RecognizerSharedStateType(); - m_state->set_sizeHint( sizeHint ); + m_state->setSizeHint( sizeHint ); } else { @@ -25,28 +25,28 @@ } template< class ImplTraits, class StreamType > -ANTLR_INLINE typename BaseRecognizer<ImplTraits, StreamType>::SuperType* BaseRecognizer<ImplTraits, StreamType>::get_super() +ANTLR_INLINE typename BaseRecognizer<ImplTraits, StreamType>::SuperType* BaseRecognizer<ImplTraits, StreamType>::getSuper() { return static_cast<SuperType*>(this); } template< class ImplTraits, class StreamType > -ANTLR_INLINE typename BaseRecognizer<ImplTraits, StreamType>::RecognizerSharedStateType* BaseRecognizer<ImplTraits, StreamType>::get_state() const +ANTLR_INLINE typename BaseRecognizer<ImplTraits, StreamType>::RecognizerSharedStateType* BaseRecognizer<ImplTraits, StreamType>::getState() const { return m_state; } template< class ImplTraits, class StreamType > -ANTLR_INLINE typename BaseRecognizer<ImplTraits, StreamType>::DebugEventListenerType* BaseRecognizer<ImplTraits, StreamType>::get_debugger() const +ANTLR_INLINE typename BaseRecognizer<ImplTraits, StreamType>::DebugEventListenerType* BaseRecognizer<ImplTraits, StreamType>::getDebugger() const { return m_debugger; } template< class ImplTraits, class StreamType > -ANTLR_INLINE void BaseRecognizer<ImplTraits, StreamType>::set_state( RecognizerSharedStateType* state ) +ANTLR_INLINE void BaseRecognizer<ImplTraits, StreamType>::setState( RecognizerSharedStateType* state ) { m_state = state; } template< class ImplTraits, class StreamType > -ANTLR_INLINE void BaseRecognizer<ImplTraits, StreamType>::set_debugger( DebugEventListenerType* debugger ) +ANTLR_INLINE void BaseRecognizer<ImplTraits, StreamType>::setDebugger( DebugEventListenerType* debugger ) { m_debugger = debugger; } @@ -56,7 +56,7 @@ BaseRecognizer<ImplTraits, StreamType>::match(ANTLR_UINT32 ttype, BitsetListType* follow) { SuperType* super = static_cast<SuperType*>(this); - IntStreamType* is = super->get_istream(); + IntStreamType* is = super->getIstream(); // Pick up the current input token/node for assignment to labels // @@ -67,19 +67,19 @@ // The token was the one we were told to expect // is->consume(); // Consume that token from the stream - m_state->set_errorRecovery(false); // Not in error recovery now (if we were) - m_state->set_failed(false); // The match was a success + m_state->setErrorRecovery(false); // Not in error recovery now (if we were) + m_state->setFailed(false); // The match was a success return matchedSymbol; // We are done } // We did not find the expected token type, if we are backtracking then // we just set the failed flag and return. // - if ( m_state->get_backtracking() > 0) + if ( m_state->getBacktracking() > 0) { // Backtracking is going on // - m_state->set_failed(true); + m_state->setFailed(true); return matchedSymbol; } @@ -96,11 +96,11 @@ void BaseRecognizer<ImplTraits, StreamType>::matchAny() { SuperType* super = static_cast<SuperType*>(this); - IntStreamType* is = super->get_istream(); + IntStreamType* is = super->getIstream(); is->consume(); - m_state->set_errorRecovery(false); - m_state->set_failed(false); + m_state->setErrorRecovery(false); + m_state->setFailed(false); return; } @@ -111,8 +111,8 @@ if (nextt == ttype) { - if(m_state->get_exception() != NULL) - m_state->get_exception()->setExpecting(nextt); + if(m_state->getException() != NULL) + m_state->getException()->setExpecting(nextt); return true; // This token is unknown, but the next one is the one we wanted } else @@ -198,7 +198,7 @@ template< class ImplTraits, class StreamType > void BaseRecognizer<ImplTraits, StreamType>::mismatch(ANTLR_UINT32 ttype, BitsetListType* follow) { - this->get_super()->mismatch( ttype, follow ); + this->getSuper()->mismatch( ttype, follow ); } template< class ImplTraits, class StreamType > @@ -214,7 +214,7 @@ // m_state->inc_errorCount(); - this->displayRecognitionError(m_state->get_tokenNames()); + this->displayRecognitionError(m_state->getTokenNames()); } template< class ImplTraits, class StreamType > @@ -225,10 +225,10 @@ // if ( m_debugger != NULL) { - m_debugger->recognitionException( m_state->get_exception() ); + m_debugger->recognitionException( m_state->getException() ); } - if ( m_state->get_errorRecovery() == true) + if ( m_state->getErrorRecovery() == true) { // Already in error recovery so don't display another error while doing so // @@ -237,7 +237,7 @@ // Signal we are in error recovery now // - m_state->set_errorRecovery(true); + m_state->setErrorRecovery(true); // Indicate this recognizer had an error while processing. // @@ -245,7 +245,7 @@ // Call the error display routine // - this->displayRecognitionError( m_state->get_tokenNames() ); + this->displayRecognitionError( m_state->getTokenNames() ); } template< class ImplTraits, class StreamType > @@ -253,7 +253,7 @@ { // Retrieve some info for easy reading. // - ExceptionBaseType* ex = m_state->get_exception(); + ExceptionBaseType* ex = m_state->getException(); StringType ttext; // See if there is a 'filename' we can use @@ -265,7 +265,7 @@ template< class ImplTraits, class StreamType > ANTLR_UINT32 BaseRecognizer<ImplTraits, StreamType>::getNumberOfSyntaxErrors() { - return m_state->get_errorCount(); + return m_state->getErrorCount(); } template< class ImplTraits, class StreamType > @@ -275,7 +275,7 @@ IntStreamType* is = super->get_parser_istream(); // Are we about to repeat the same error? // - if ( m_state->get_lastErrorIndex() == is->index()) + if ( m_state->getLastErrorIndex() == is->index()) { // The last error was at the same token index point. This must be a case // where LT(1) is in the recovery token set so nothing is @@ -287,7 +287,7 @@ // Record error index position // - m_state->set_lastErrorIndex( is->index() ); + m_state->setLastErrorIndex( is->index() ); // Work out the follows set for error recovery // @@ -311,8 +311,8 @@ // Reset the inError flag so we don't re-report the exception // - m_state->set_error(false); - m_state->set_failed(false); + m_state->setError(false); + m_state->setFailed(false); } template< class ImplTraits, class StreamType > @@ -371,14 +371,14 @@ ANTLR_UINT32 top; ANTLR_UINT32 i; - top = static_cast<ANTLR_UINT32>( m_state->get_following().size() ); + top = static_cast<ANTLR_UINT32>( m_state->getFollowing().size() ); followSet = new BitsetType(0); localFollowSet = NULL; for (i = top; i>0; i--) { - localFollowSet = m_state->get_following().at(i-1).bitsetLoad(); + localFollowSet = m_state->getFollowing().at(i-1).bitsetLoad(); if (localFollowSet != NULL) { @@ -465,7 +465,7 @@ // is->consume(); - m_state->set_error(false); // Exception is not outstanding any more + m_state->setError(false); // Exception is not outstanding any more return matchedSymbol; } @@ -479,16 +479,16 @@ // We can fake the missing token and proceed // new ANTLR_Exception<ImplTraits, MISSING_TOKEN_EXCEPTION, StreamType>(this, ""); - matchedSymbol = this->getMissingSymbol( is, m_state->get_exception(), ttype, follow); - m_state->get_exception()->setToken( matchedSymbol ); - m_state->get_exception()->setExpecting(ttype); + matchedSymbol = this->getMissingSymbol( is, m_state->getException(), ttype, follow); + m_state->getException()->setToken( matchedSymbol ); + m_state->getException()->setExpecting(ttype); // Print out the error after we insert so that ANTLRWorks sees the // token in the exception. // this->reportError(); - m_state->set_error(false); // Exception is not outstanding any more + m_state->setError(false); // Exception is not outstanding any more return matchedSymbol; } @@ -500,7 +500,7 @@ // Neither deleting nor inserting tokens allows recovery // must just report the exception. // - m_state->set_error(true); + m_state->setError(true); return NULL; } @@ -517,23 +517,23 @@ // We can fake the missing token and proceed // new ANTLR_Exception<ImplTraits, MISSING_TOKEN_EXCEPTION, StreamType>(this); - matchedSymbol = this->getMissingSymbol(is, m_state->get_exception(), follow); - m_state->get_exception()->set_token(matchedSymbol); + matchedSymbol = this->getMissingSymbol(is, m_state->getException(), follow); + m_state->getException()->set_token(matchedSymbol); // Print out the error after we insert so that ANTLRWorks sees the // token in the exception. // this->reportError(); - m_state->set_error(false); // Exception is not outstanding any more + m_state->setError(false); // Exception is not outstanding any more return matchedSymbol; } // TODO - Single token deletion like in recoverFromMismatchedToken() // - m_state->set_error(true); - m_state->set_failed(true); + m_state->setError(true); + m_state->setFailed(true); return NULL; } @@ -588,8 +588,8 @@ { delete follow; } - m_state->set_error(false); - m_state->set_failed(false); + m_state->setError(false); + m_state->setFailed(false); return true; /* Success in recovery */ } @@ -658,7 +658,7 @@ /* See if we have a list in the ruleMemos for this rule, and if not, then create one * as we will need it eventually if we are being asked for the memo here. */ - entry = m_state->get_ruleMemo()->get(ruleIndex); + entry = m_state->getRuleMemo()->get(ruleIndex); if (entry == NULL) { @@ -669,14 +669,14 @@ * no idea of the size, but you should remember that this will cause the leftmost * bit match algorithm to run to 63 bits, which will be the whole time spent in the trie ;-) */ - m_state->get_ruleMemo()->add( ruleIndex, new RuleListType(63) ); + m_state->getRuleMemo()->add( ruleIndex, new RuleListType(63) ); /* We cannot have a stopIndex in a trie we have just created of course */ return MEMO_RULE_UNKNOWN; } - RuleListType* ruleList = entry->get_data(); + RuleListType* ruleList = entry->getData(); /* See if there is a stop index associated with the supplied start index. */ @@ -685,7 +685,7 @@ SubEntryType* sub_entry = ruleList->get(ruleParseStart); if (sub_entry != NULL) { - stopIndex = sub_entry->get_data(); + stopIndex = sub_entry->getData(); } if (stopIndex == 0) @@ -700,7 +700,7 @@ bool BaseRecognizer<ImplTraits, StreamType>::alreadyParsedRule(ANTLR_MARKER ruleIndex) { SuperType* super = static_cast<SuperType*>(this); - IntStreamType* is = super->get_istream(); + IntStreamType* is = super->getIstream(); /* See if we have a memo marker for this. */ @@ -713,7 +713,7 @@ if (stopIndex == MEMO_RULE_FAILED) { - m_state->set_failed(true); + m_state->setFailed(true); } else { @@ -735,15 +735,15 @@ EntryType* entry; ANTLR_MARKER stopIndex; SuperType* super = static_cast<SuperType*>(this); - IntStreamType* is = super->get_istream(); + IntStreamType* is = super->getIstream(); - stopIndex = (m_state->get_failed() == true) ? MEMO_RULE_FAILED : is->index() - 1; + stopIndex = (m_state->getFailed() == true) ? MEMO_RULE_FAILED : is->index() - 1; - entry = m_state->get_ruleMemo()->get(ruleIndex); + entry = m_state->getRuleMemo()->get(ruleIndex); if (entry != NULL) { - RuleListType* ruleList = entry->get_data(); + RuleListType* ruleList = entry->getData(); /* If we don't already have this entry, append it. The memoize trie does not * accept duplicates so it won't add it if already there and we just ignore the @@ -792,7 +792,7 @@ ANTLR_UINT32 expectedTokenType, BitsetListType* follow) { - return this->get_super()->getMissingSymbol( istream, e, expectedTokenType, follow ); + return this->getSuper()->getMissingSymbol( istream, e, expectedTokenType, follow ); } @@ -802,7 +802,7 @@ { ANTLR_MARKER start; SuperType* super = static_cast<SuperType*>(this); - IntStreamType* is = super->get_istream(); + IntStreamType* is = super->getIstream(); /* Begin backtracking so we can get back to where we started after trying out * the syntactic predicate. @@ -812,25 +812,25 @@ /* Try the syntactical predicate */ - this->get_super()->synpred( pred ); + this->getSuper()->synpred( pred ); /* Reset */ is->rewind(start); m_state->dec_backtracking(); - if ( m_state->get_failed() == true) + if ( m_state->getFailed() == true) { /* Predicate failed */ - m_state->set_failed(false); + m_state->setFailed(false); return false; } else { /* Predicate was successful */ - m_state->set_failed(false); + m_state->setFailed(false); return true; } } @@ -838,7 +838,7 @@ template< class ImplTraits, class StreamType > void BaseRecognizer<ImplTraits, StreamType>::exConstruct() { - this->get_super()->exConstruct(); + this->getSuper()->exConstruct(); } template< class ImplTraits, class StreamType > @@ -852,32 +852,32 @@ void BaseRecognizer<ImplTraits, StreamType>::reset( ClassForwarder<CompType> ) { typedef typename RecognizerSharedStateType::RuleMemoType RuleMemoType; - m_state->get_following().clear(); + m_state->getFollowing().clear(); // Reset the state flags // - m_state->set_errorRecovery(false); - m_state->set_lastErrorIndex(-1); - m_state->set_failed(false); - m_state->set_errorCount(0); - m_state->set_backtracking(0); + m_state->setErrorRecovery(false); + m_state->setLastErrorIndex(-1); + m_state->setFailed(false); + m_state->setErrorCount(0); + m_state->setBacktracking(0); - if (m_state->get_ruleMemo() != NULL) + if (m_state->getRuleMemo() != NULL) { - delete m_state->get_ruleMemo(); - m_state->set_ruleMemo( new RuleMemoType(15) ); /* 16 bit depth is enough for 32768 rules! */ + delete m_state->getRuleMemo(); + m_state->setRuleMemo( new RuleMemoType(15) ); /* 16 bit depth is enough for 32768 rules! */ } } template< class ImplTraits, class StreamType > void BaseRecognizer<ImplTraits, StreamType>::reset( ClassForwarder<LexerType> ) { - m_state->set_token_present( false ); - m_state->set_type( ImplTraits::CommonTokenType::TOKEN_INVALID ); - m_state->set_channel( TOKEN_DEFAULT_CHANNEL ); - m_state->set_tokenStartCharIndex( -1 ); - m_state->set_tokenStartCharPositionInLine(-1); - m_state->set_tokenStartLine( -1 ); + m_state->setTokenPresent( false ); + m_state->setType( ImplTraits::CommonTokenType::TOKEN_INVALID ); + m_state->setChannel( TOKEN_DEFAULT_CHANNEL ); + m_state->setTokenStartCharIndex( -1 ); + m_state->setTokenStartCharPositionInLine(-1); + m_state->setTokenStartLine( -1 ); m_state->set_text(""); } @@ -890,16 +890,16 @@ { // Free any rule memoization we set up // - if (m_state->get_ruleMemo() != NULL) + if (m_state->getRuleMemo() != NULL) { - delete m_state->get_ruleMemo(); - m_state->set_ruleMemo(NULL); + delete m_state->getRuleMemo(); + m_state->setRuleMemo(NULL); } // Free any exception space we have left around // - ExceptionBaseType* thisE = m_state->get_exception(); + ExceptionBaseType* thisE = m_state->getException(); if (thisE != NULL) { delete thisE; Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3bitset.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3bitset.hpp 2013-04-17 15:18:27 UTC (rev 4627) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3bitset.hpp 2013-04-18 13:22:51 UTC (rev 4628) @@ -88,10 +88,10 @@ BitsetList(); BitsetList( ANTLR_BITWORD* bits, ANTLR_UINT32 length ); - ANTLR_BITWORD* get_bits() const; - ANTLR_UINT32 get_length() const; - void set_bits( ANTLR_BITWORD* bits ); - void set_length( ANTLR_UINT32 length ); + ANTLR_BITWORD* getBits() const; + ANTLR_UINT32 getLength() const; + void setBits( ANTLR_BITWORD* bits ); + void setLength( ANTLR_UINT32 length ); /// /// \brief @@ -139,7 +139,7 @@ Bitset* clone() const; Bitset* bor(Bitset* bitset2); - BitsetListType& get_blist(); + BitsetListType& getBlist(); void borInPlace(Bitset* bitset2); ANTLR_UINT32 size() const; void add(ANTLR_INT32 bit); Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3bitset.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3bitset.inl 2013-04-17 15:18:27 UTC (rev 4627) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3bitset.inl 2013-04-18 13:22:51 UTC (rev 4628) @@ -15,25 +15,25 @@ } template <class ImplTraits> -ANTLR_INLINE ANTLR_BITWORD* BitsetList<ImplTraits>::get_bits() const +ANTLR_INLINE ANTLR_BITWORD* BitsetList<ImplTraits>::getBits() const { return m_bits; } template <class ImplTraits> -ANTLR_INLINE ANTLR_UINT32 BitsetList<ImplTraits>::get_length() const +ANTLR_INLINE ANTLR_UINT32 BitsetList<ImplTraits>::getLength() const { return m_length; } template <class ImplTraits> -ANTLR_INLINE void BitsetList<ImplTraits>::set_bits( ANTLR_BITWORD* bits ) +ANTLR_INLINE void BitsetList<ImplTraits>::setBits( ANTLR_BITWORD* bits ) { m_bits = bits; } template <class ImplTraits> -ANTLR_INLINE void BitsetList<ImplTraits>::set_length( ANTLR_UINT32 length ) +ANTLR_INLINE void BitsetList<ImplTraits>::setLength( ANTLR_UINT32 length ) { m_length = length; } @@ -58,10 +58,10 @@ ANTLR_UINT32 count=0; while (count < m_length) { - if( bitset->get_blist().get_length() <= count) + if( bitset->getBlist().getLength() <= count) bitset->grow(count+1); - typename ImplTraits::BitsetListType& blist = bitset->get_blist(); + typename ImplTraits::BitsetListType& blist = bitset->getBlist(); blist.m_bits[count] = *(m_bits+count); count++; } @@ -86,7 +86,7 @@ // Allocate memory for the bitset structure itself // bitset = new Bitset<ImplTraits>(numElements); - memcpy(bitset->get_blist().get_bits(), m_bits, numElements * sizeof(ANTLR_BITWORD)); + memcpy(bitset->getBlist().getBits(), m_bits, numElements * sizeof(ANTLR_BITWORD)); // All seems good // @@ -105,10 +105,10 @@ // ANTLR_UINT32 numelements = ((numBits -1) >> ANTLR_BITSET_LOG_BITS) + 1; - m_blist.set_bits( (ANTLR_BITWORD*) AllocPolicyType::alloc(numelements * sizeof(ANTLR_BITWORD))); + m_blist.setBits( (ANTLR_BITWORD*) AllocPolicyType::alloc(numelements * sizeof(ANTLR_BITWORD))); - memset( m_blist.get_bits(), 0, (numelements * sizeof(ANTLR_BITWORD))); - m_blist.set_length( numelements ); + memset( m_blist.getBits(), 0, (numelements * sizeof(ANTLR_BITWORD))); + m_blist.setLength( numelements ); } template <class ImplTraits> @@ -124,12 +124,12 @@ // Allocate memory for the bitset structure itself // - bitset = new Bitset( ANTLR_BITSET_BITS * m_blist.get_length() ); + bitset = new Bitset( ANTLR_BITSET_BITS * m_blist.getLength() ); // Install the actual bits in the source set // - memcpy(bitset->m_blist.get_bits(), m_blist.get_bits(), - m_blist.get_length() * sizeof(ANTLR_BITWORD) ); + memcpy(bitset->m_blist.getBits(), m_blist.getBits(), + m_blist.getLength() * sizeof(ANTLR_BITWORD) ); // All seems good // @@ -165,18 +165,18 @@ // First make sure that the target bitset is big enough // for the new bits to be ored in. // - if ( m_blist.get_length() < bitset2->m_blist.get_length() ) - this->growToInclude( bitset2->m_blist.get_length() * sizeof(ANTLR_BITWORD) ); + if ( m_blist.getLength() < bitset2->m_blist.getLength() ) + this->growToInclude( bitset2->m_blist.getLength() * sizeof(ANTLR_BITWORD) ); // Or the miniimum number of bits after any resizing went on // - if ( m_blist.get_length() < bitset2->m_blist.get_length() ) - minimum = m_blist.get_length(); + if ( m_blist.getLength() < bitset2->m_blist.getLength() ) + minimum = m_blist.getLength(); else - minimum = bitset2->m_blist.get_length(); + minimum = bitset2->m_blist.getLength(); - ANTLR_BITWORD* bits1 = m_blist.get_bits(); - ANTLR_BITWORD* bits2 = bitset2->m_blist.get_bits(); + ANTLR_BITWORD* bits1 = m_blist.getBits(); + ANTLR_BITWORD* bits2 = bitset2->m_blist.getBits(); for (ANTLR_UINT32 i = minimum; i > 0; i--) bits1[i-1] |= bits2[i-1]; } @@ -194,8 +194,8 @@ // anyway. // degree = 0; - ANTLR_BITWORD* bits = m_blist.get_bits(); - for (i = m_blist.get_length() - 1; i>= 0; i--) + ANTLR_BITWORD* bits = m_blist.getBits(); + for (i = m_blist.getLength() - 1; i>= 0; i--) { if (bits[i] != 0) { @@ -216,10 +216,10 @@ { ANTLR_UINT32 word = Bitset::WordNumber(bit); - if (word >= m_blist.get_length() ) + if (word >= m_blist.getLength() ) this->growToInclude(bit); - ANTLR_BITWORD* bits = m_blist.get_bits(); + ANTLR_BITWORD* bits = m_blist.getBits(); bits[word] |= Bitset::BitMask(bit); } @@ -232,21 +232,21 @@ // be more efficient... // newBits = (ANTLR_BITWORD*) AllocPolicyType::alloc0(newSize * sizeof(ANTLR_BITWORD) ); - if ( m_blist.get_bits() != NULL) + if ( m_blist.getBits() != NULL) { // Copy existing bits // - memcpy( newBits, m_blist.get_bits(), m_blist.get_length() * sizeof(ANTLR_BITWORD) ); + memcpy( newBits, m_blist.getBits(), m_blist.getLength() * sizeof(ANTLR_BITWORD) ); // Out with the old bits... de de de derrr // - AllocPolicyType::free( m_blist.get_bits() ); + AllocPolicyType::free( m_blist.getBits() ); } // In with the new bits... keerrrang. // - m_blist.set_bits(newBits); - m_blist.set_length(newSize); + m_blist.setBits(newBits); + m_blist.setLength(newSize); } template <class ImplTraits> @@ -260,17 +260,17 @@ // Work out the minimum comparison set // - if ( m_blist.get_length() < bitset2->m_blist.get_length() ) - minimum = m_blist.get_length(); + if ( m_blist.getLength() < bitset2->m_blist.getLength() ) + minimum = m_blist.getLength(); else - minimum = bitset2->m_blist.get_length(); + minimum = bitset2->m_blist.getLength(); // Make sure explict in common bits are equal // for (i = minimum - 1; i < minimum ; i--) { - ANTLR_BITWORD* bits1 = m_blist.get_bits(); - ANTLR_BITWORD* bits2 = bitset2->m_blist.get_bits(); + ANTLR_BITWORD* bits1 = m_blist.getBits(); + ANTLR_BITWORD* bits2 = bitset2->m_blist.getBits(); if ( bits1[i] != bits2[i]) return false; } @@ -278,19 +278,19 @@ // Now make sure the bits of the larger set are all turned // off. // - if ( m_blist.get_length() > minimum) + if ( m_blist.getLength() > minimum) { - for (i = minimum ; i < m_blist.get_length(); i++) + for (i = minimum ; i < m_blist.getLength(); i++) { - ANTLR_BITWORD* bits = m_blist.get_bits(); + ANTLR_BITWORD* bits = m_blist.getBits(); if(bits[i] != 0) return false; } } - else if (bitset2->m_blist.get_length() > minimum) + else if (bitset2->m_blist.getLength() > minimum) { - ANTLR_BITWORD* bits = m_blist.get_bits(); - for (i = minimum; i < bitset2->m_blist.get_length(); i++) + ANTLR_BITWORD* bits = m_blist.getBits(); + for (i = minimum; i < bitset2->m_blist.getLength(); i++) { if ( bits[i] != 0 ) return false; @@ -305,10 +305,10 @@ { ANTLR_UINT32 wordNo = Bitset::WordNumber(bit); - if (wordNo >= m_blist.get_length()) + if (wordNo >= m_blist.getLength()) return false; - ANTLR_BITWORD* bits = m_blist.get_bits(); + ANTLR_BITWORD* bits = m_blist.getBits(); if ( (bits[wordNo] & Bitset::BitMask(bit)) == 0) return false; else @@ -318,11 +318,11 @@ template <class ImplTraits> ANTLR_INLINE ANTLR_UINT32 Bitset<ImplTraits>::numBits() const { - return m_blist.get_length() << ANTLR_BITSET_LOG_BITS; + return m_blist.getLength() << ANTLR_BITSET_LOG_BITS; } template <class ImplTraits> -ANTLR_INLINE typename ImplTraits::BitsetListType& Bitset<ImplTraits>::get_blist() +ANTLR_INLINE typename ImplTraits::BitsetListType& Bitset<ImplTraits>::getBlist() { return m_blist; } @@ -332,9 +332,9 @@ { ANTLR_UINT32 wordNo = Bitset::WordNumber(bit); - if (wordNo < m_blist.get_length()) + if (wordNo < m_blist.getLength()) { - ANTLR_BITWORD* bits = m_blist.get_bits(); + ANTLR_BITWORD* bits = m_blist.getBits(); bits[wordNo] &= ~(Bitset::BitMask(bit)); } } @@ -343,8 +343,8 @@ ANTLR_INLINE bool Bitset<ImplTraits>::isNilNode() const { ANTLR_UINT32 i; - ANTLR_BITWORD* bits = m_blist.get_bits(); - for (i = m_blist.get_length() -1 ; i < m_blist.get_length(); i--) + ANTLR_BITWORD* bits = m_blist.getBits(); + for (i = m_blist.getLength() -1 ; i < m_blist.getLength(); i--) { if(bits[i] != 0) return false; @@ -385,8 +385,8 @@ template <class ImplTraits> ANTLR_INLINE Bitset<ImplTraits>::~Bitset() { - if (m_blist.get_bits() != NULL) - AllocPolicyType::free(m_blist.get_bits()); + if (m_blist.getBits() != NULL) + AllocPolicyType::free(m_blist.getBits()); return; } @@ -396,7 +396,7 @@ ANTLR_UINT32 bl; ANTLR_UINT32 nw; - bl = (m_blist.get_length() << 1); + bl = (m_blist.getLength() << 1); nw = Bitset::NumWordsToHold(bit); if (bl > nw) @@ -435,18 +435,18 @@ // First make sure that the target bitset is big enough // for the new bits to be ored in. // - if ( m_blist.get_length() < bitset2->m_blist.get_length() ) - this->growToInclude( bitset2->m_blist.get_length() * sizeof(ANTLR_BITWORD) ); + if ( m_blist.getLength() < bitset2->m_blist.getLength() ) + this->growToInclude( bitset2->m_blist.getLength() * sizeof(ANTLR_BITWORD) ); // Or the miniimum number of bits after any resizing went on // - if ( m_blist.get_length() < bitset2->m_blist.get_length() ) - minimum = m_blist.get_length(); + if ( m_blist.getLength() < bitset2->m_blist.getLength() ) + minimum = m_blist.getLength(); else - minimum = bitset2->m_blist.get_length(); + minimum = bitset2->m_blist.getLength(); - ANTLR_BITWORD* bits1 = m_blist.get_bits(); - ANTLR_BITWORD* bits2 = bitset2->m_blist.get_bits(); + ANTLR_BITWORD* bits1 = m_blist.getBits(); + ANTLR_BITWORD* bits2 = bitset2->m_blist.getBits(); for (i = minimum; i > 0; i--) bits1[i-1] |= bits2[i-1]; } Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3collections.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3collections.hpp 2013-04-17 15:18:27 UTC (rev 4627) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3collections.hpp 2013-04-18 13:22:51 UTC (rev 4628) @@ -49,8 +49,8 @@ public: TrieEntry(const DataType& data, TrieEntry* next); - DataType& get_data(); - const DataType& get_data() const; + DataType& getData(); + const DataType& getData() const; TrieEntry* get_next() const; void set_next( TrieEntry* next ); }; @@ -75,16 +75,16 @@ IntTrieNode(); ~IntTrieNode(); - ANTLR_UINT32 get_bitNum() const; + ANTLR_UINT32 getBitNum() const; ANTLR_INTKEY get_key() const; - BucketsType* get_buckets() const; - IntTrieNode* get_leftN() const; - IntTrieNode* get_rightN() const; - void set_bitNum( ANTLR_UINT32 bitNum ); + BucketsType* getBuckets() const; + IntTrieNode* getLeftN() const; + IntTrieNode* getRightN() const; + void setBitNum( ANTLR_UINT32 bitNum ); void set_key( ANTLR_INTKEY key ); - void set_buckets( BucketsType* buckets ); - void set_leftN( IntTrieNode* leftN ); - void set_rightN( IntTrieNode* rightN ); + void setBuckets( BucketsType* buckets ); + void setLeftN( IntTrieNode* leftN ); + void setRightN( IntTrieNode* rightN ); }; /** Structure that defines an ANTLR3_INT_TRIE. For this particular implementation, @@ -106,8 +106,8 @@ class IntTrieBase { public: - static const ANTLR_UINT8* get_bitIndex(); - static const ANTLR_UINT64* get_bitMask(); + static const ANTLR_UINT8* getBitIndex(); + static const ANTLR_UINT64* getBitMask(); }; template< class ImplTraits, class DataType > Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3collections.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3collections.inl 2013-04-17 15:18:27 UTC (rev 4627) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3collections.inl 2013-04-18 13:22:51 UTC (rev 4628) @@ -7,12 +7,12 @@ m_next = next; } template< class ImplTraits, class DataType > -ANTLR_INLINE DataType& TrieEntry<ImplTraits, DataType>::get_data() +ANTLR_INLINE DataType& TrieEntry<ImplTraits, DataType>::getData() { return m_data; } template< class ImplTraits, class DataType > -ANTLR_INLINE const DataType& TrieEntry<ImplTraits, DataType>::get_data() const +ANTLR_INLINE const DataType& TrieEntry<ImplTraits, DataType>::getData() const { return m_data; } @@ -29,7 +29,7 @@ } template< class ImplTraits, class DataType > -ANTLR_INLINE ANTLR_UINT32 IntTrieNode<ImplTraits, DataType>::get_bitNum() const +ANTLR_INLINE ANTLR_UINT32 IntTrieNode<ImplTraits, DataType>::getBitNum() const { return m_bitNum; } @@ -39,22 +39,22 @@ return m_key; } template< class ImplTraits, class DataType > -ANTLR_INLINE typename IntTrieNode<ImplTraits, DataType>::BucketsType* IntTrieNode<ImplTraits, DataType>::get_buckets() const +ANTLR_INLINE typename IntTrieNode<ImplTraits, DataType>::BucketsType* IntTrieNode<ImplTraits, DataType>::getBuckets() const { return m_buckets; } template< class ImplTraits, class DataType > -ANTLR_INLINE IntTrieNode<ImplTraits, DataType>* IntTrieNode<ImplTraits, DataType>::get_leftN() const +ANTLR_INLINE IntTrieNode<ImplTraits, DataType>* IntTrieNode<ImplTraits, DataType>::getLeftN() const { return m_leftN; } template< class ImplTraits, class DataType > -ANTLR_INLINE IntTrieNode<ImplTraits, DataType>* IntTrieNode<ImplTraits, DataType>::get_rightN() const +ANTLR_INLINE IntTrieNode<ImplTraits, DataType>* IntTrieNode<ImplTraits, DataType>::getRightN() const { return m_rightN; } template< class ImplTraits, class DataType > -ANTLR_INLINE void IntTrieNode<ImplTraits, DataType>::set_bitNum( ANTLR_UINT32 bitNum ) +ANTLR_INLINE void IntTrieNode<ImplTraits, DataType>::setBitNum( ANTLR_UINT32 bitNum ) { m_bitNum = bitNum; } @@ -64,22 +64,22 @@ m_key = key; } template< class ImplTraits, class DataType > -ANTLR_INLINE void IntTrieNode<ImplTraits, DataType>::set_buckets( BucketsType* buckets ) +ANTLR_INLINE void IntTrieNode<ImplTraits, DataType>::setBuckets( BucketsType* buckets ) { m_buckets = buckets; } template< class ImplTraits, class DataType > -ANTLR_INLINE void IntTrieNode<ImplTraits, DataType>::set_leftN( IntTrieNode* leftN ) +ANTLR_INLINE void IntTrieNode<ImplTraits, DataType>::setLeftN( IntTrieNode* leftN ) { m_leftN = leftN; } template< class ImplTraits, class DataType > -ANTLR_INLINE void IntTrieNode<ImplTraits, DataType>::set_rightN( IntTrieNode* rightN ) +ANTLR_INLINE void IntTrieNode<ImplTraits, DataType>::setRightN( IntTrieNode* rightN ) { m_rightN = rightN; } -ANTLR_INLINE const ANTLR_UINT8* IntTrieBase::get_bitIndex() +ANTLR_INLINE const ANTLR_UINT8* IntTrieBase::getBitIndex() { static ANTLR_UINT8 bitIndex[256] = { @@ -107,7 +107,7 @@ return bitIndex; } -ANTLR_INLINE const ANTLR_UINT64* IntTrieBase::get_bitMask() +ANTLR_INLINE const ANTLR_UINT64* IntTrieBase::getBitMask() { static ANTLR_UINT64 bitMask[64] = { @@ -146,13 +146,13 @@ * keys in the trie. This is the trie 'depth'. The limit for * this implementation is 63 (bits 0..63). */ - m_root->set_bitNum( depth ); + m_root->setBitNum( depth ); /* And as we have nothing in here yet, we set both child pointers * of the root node to point back to itself. */ - m_root->set_leftN( m_root ); - m_root->set_rightN( m_root ); + m_root->setLeftN( m_root ); + m_root->setRightN( m_root ); m_count = 0; /* Finally, note that the key for this root node is 0 because @@ -195,12 +195,12 @@ * tree branches. */ thisNode = m_root; /* Start at the root node */ - nextNode = thisNode->get_leftN(); /* Examine the left node from the root */ + nextNode = thisNode->getLeftN(); /* Examine the left node from the root */ /* While we are descending the tree nodes... */ - const ANTLR_UINT64* bitMask = this->get_bitMask(); - while( thisNode->get_bitNum() > nextNode->get_bitNum() ) + const ANTLR_UINT64* bitMask = this->getBitMask(); + while( thisNode->getBitNum() > nextNode->getBitNum() ) { /* Next node now becomes the new 'current' node */ @@ -210,13 +210,13 @@ * in the key we are searching for. The new next node is the * right node if that bit is set and the left node it is not. */ - if (key & bitMask[nextNode->get_bitNum()]) + if (key & bitMask[nextNode->getBitNum()]) { - nextNode = nextNode->get_rightN(); /* 1 is right */ + nextNode = nextNode->getRightN(); /* 1 is right */ } else { - nextNode = nextNode->get_leftN(); /* 0 is left */ + nextNode = nextNode->getLeftN(); /* 0 is left */ } } @@ -235,7 +235,7 @@ { /* This was the key, so return the entry pointer */ - return nextNode->get_buckets(); + return nextNode->getBuckets(); } else { @@ -268,32 +268,32 @@ /* Cache the bit depth of this trie, which is always the highest index, * which is in the root node */ - depth = m_root->get_bitNum(); + depth = m_root->getBitNum(); thisNode = m_root; /* Start with the root node */ - nextNode = m_root->get_leftN(); /* And assume we start to the left */ + nextNode = m_root->getLeftN(); /* And assume we start to the left */ /* Now find the only node that can be currently reached by the bits in the * key we are being asked to insert. */ - const ANTLR_UINT64* bitMask = this->get_bitMask(); - while (thisNode->get_bitNum() > nextNode->get_bitNum() ) + const ANTLR_UINT64* bitMask = this->getBitMask(); + while (thisNode->getBitNum() > nextNode->getBitNum() ) { /* Still descending the structure, next node becomes current. */ thisNode = nextNode; - if (key & bitMask[nextNode->get_bitNum()]) + if (key & bitMask[nextNode->getBitNum()]) { /* Bit at the required index was 1, so travers the right node from here */ - nextNode = nextNode->get_rightN(); + nextNode = nextNode->getRightN(); } else { /* Bit at the required index was 0, so we traverse to the left */ - nextNode = nextNode->get_leftN(); + nextNode = nextNode->getLeftN(); } } /* Here we have located the only node that can be reached by the @@ -315,7 +315,7 @@ * added as duplicate keys. We might need to revise this opinion if we end up having many duplicate keys * as perhaps reverse order is just as good, so long as it is ordered. */ - nextEnt = nextNode->get_buckets(); + nextEnt = nextNode->getBuckets(); while (nextEnt->get_next() != NULL) { nextEnt = nextEnt->get_next(); @@ -344,7 +344,7 @@ /* Most common case is a 32 bit key really */ - const ANTLR_UINT8* bitIndex = this->get_bitIndex(); + const ANTLR_UINT8* bitIndex = this->getBitIndex(); #ifdef ANTLR_USE_64BIT if (xorKey & 0xFFFFFFFF00000000) { @@ -410,27 +410,27 @@ * according to whether we skip the bit that differs or not. */ thisNode = m_root; - entNode = m_root->get_leftN(); + entNode = m_root->getLeftN(); /* Note the slight difference in the checks here to cover both cases */ - while (thisNode->get_bitNum() > entNode->get_bitNum() && entNode->get_bitNum() > depth) + while (thisNode->getBitNum() > entNode->getBitNum() && entNode->getBitNum() > depth) { /* Still descending the structure, next node becomes current. */ thisNode = entNode; - if (key & bitMask[entNode->get_bitNum()]) + if (key & bitMask[entNode->getBitNum()]) { /* Bit at the required index was 1, so traverse the right node from here */ - entNode = entNode->get_rightN(); + entNode = entNode->getRightN(); } else { /* Bit at the required index was 0, so we traverse to the left */ - entNode = entNode->get_leftN(); + entNode = entNode->getLeftN(); } } @@ -445,9 +445,9 @@ /* Install it */ - nextNode->set_buckets(newEnt); + nextNode->setBuckets(newEnt); nextNode->set_key(key); - nextNode->set_bitNum( depth ); + nextNode->setBitNum( depth ); /* Work out the right and left pointers for this new node, which involve * terminating with the current found node either right or left according @@ -455,13 +455,13 @@ */ if (key & bitMask[depth]) { - nextNode->set_leftN(entNode); /* Terminates at previous position */ - nextNode->set_rightN(nextNode); /* Terminates with itself */ + nextNode->setLeftN(entNode); /* Terminates at previous position */ + nextNode->setRightN(nextNode); /* Terminates with itself */ } else { - nextNode->set_rightN(entNode); /* Terminates at previous position */ - nextNode->set_leftN(nextNode); /* Terminates with itself */ + nextNode->setRightN(entNode); /* Terminates at previous position */ + nextNode->setLeftN(nextNode); /* Terminates with itself */ } /* Finally, we need to change the pointers at the node we located @@ -469,13 +469,13 @@ * pointer for that node becomes the newly created node, otherwise the left * pointer does. */ - if (key & bitMask[thisNode->get_bitNum()] ) + if (key & bitMask[thisNode->getBitNum()] ) { - thisNode->set_rightN( nextNode ); + thisNode->setRightN( nextNode ); } else { - thisNode->set_leftN(nextNode); + thisNode->setLeftN(nextNode); } /* Et voila @@ -503,7 +503,7 @@ /* If this node has a left pointer that is not a back pointer * then recursively call to free this */ - if ( m_bitNum > m_leftN->get_bitNum()) + if ( m_bitNum > m_leftN->getBitNum()) { /* We have a left node that needs descending, so do it. */ @@ -513,7 +513,7 @@ /* The left nodes from here should now be dealt with, so * we need to descend any right nodes that are not back pointers */ - if ( m_bitNum > m_rightN->get_bitNum() ) + if ( m_bitNum > m_rightN->getBitNum() ) { /* There are some right nodes to descend and deal with. */ Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontoken.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontoken.inl 2013-04-17 15:18:27 UTC (rev 4627) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontoken.inl 2013-04-18 13:22:51 UTC (rev 4628) @@ -230,7 +230,7 @@ template<class ImplTraits> ANTLR_INLINE ANTLR_MARKER CommonToken<ImplTraits>::getStartIndex() const { - return (m_startIndex == -1) ? (ANTLR_MARKER)(m_input->get_data()) : m_startIndex; + return (m_startIndex == -1) ? (ANTLR_MARKER)(m_input->getData()) : m_startIndex; } template<class ImplTraits> Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.hpp 2013-04-17 15:18:27 UTC (rev 4627) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.hpp 2013-04-18 13:22:51 UTC (rev 4628) @@ -89,8 +89,8 @@ CommonTree( const CommonTree& ctree ); TokenType* get_token() const; - ChildrenType& get_children(); - const ChildrenType& get_children() const; + ChildrenType& getChildren(); + const ChildrenType& getChildren() const; ChildrenType* get_children_p(); ANTLR_INT32 getChildIndex() const; TreeType* getParent() const; Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.inl 2013-04-17 15:18:27 UTC (rev 4627) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.inl 2013-04-18 13:22:51 UTC (rev 4628) @@ -52,13 +52,13 @@ } template<class ImplTraits> -typename CommonTree<ImplTraits>::ChildrenType& CommonTree<ImplTraits>::get_children() +typename CommonTree<ImplTraits>::ChildrenType& CommonTree<ImplTraits>::getChildren() { return m_children; } template<class ImplTraits> -const typename CommonTree<ImplTraits>::ChildrenType& CommonTree<ImplTraits>::get_children() const +const typename CommonTree<ImplTraits>::ChildrenType& CommonTree<ImplTraits>::getChildren() const { return m_children; } @@ -78,8 +78,8 @@ if (child == NULL) return; - ChildrenType& child_children = child->get_children(); - ChildrenType& tree_children = this->get_children(); + ChildrenType& child_children = child->getChildren(); + ChildrenType& tree_children = this->getChildren(); if (child->isNilNode() == true) { @@ -219,7 +219,7 @@ for (i = startChildIndex; i <= stopChildIndex; i++) { child = newChildren->at(j); - ChildrenType& parent_children = this->get_children(); + ChildrenType& parent_children = this->getChildren(); parent_children[i] = child; child->setParent(this); child->setChildIndex(i); @@ -232,7 +232,7 @@ // Less nodes than there were before // reuse what we have then delete the rest // - ChildrenType& parent_children = this->get_children(); + ChildrenType& parent_children = this->getChildren(); for (j = 0; j < numNewChildren; j++) { parent_children[ startChildIndex + j ] = newChildren->at(j); @@ -251,7 +251,7 @@ } else { - ChildrenType& parent_children = this->get_children(); + ChildrenType& parent_children = this->getChildren(); ANTLR_UINT32 numToInsert; // More nodes than there were before Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3cyclicdfa.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3cyclicdfa.inl 2013-04-17 15:18:27 UTC (rev 4627) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3cyclicdfa.inl 2013-04-18 13:22:51 UTC (rev 4628) @@ -100,7 +100,7 @@ // If the predicate/rule raised an exception then we leave it // in tact, else we have an NVA. // - if (recognizer->get_state()->get_error() != true) + if (recognizer->getState()->getError() != true) { this->noViableAlt(recognizer, s); } @@ -188,9 +188,9 @@ // alt can just exit right now. If we are parsing though, then // we want the exception to be raised. // - if (rec->get_state()->get_backtracking() > 0) + if (rec->getState()->getBacktracking() > 0) { - rec->get_state()->set_failed(true); + rec->getState()->setFailed(true); } else { Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3exception.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3exception.inl 2013-04-17 15:18:27 UTC (rev 4627) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3exception.inl 2013-04-18 13:22:51 UTC (rev 4628) @@ -174,11 +174,11 @@ ANTLR_Exception<ImplTraits, Ex, StreamType>::ANTLR_Exception(BaseRecognizerType* recognizer, const StringType& message) :BaseType( message ) { - recognizer->get_super()->fillExceptionData( this ); - BaseType::m_input = recognizer->get_super()->get_istream(); - BaseType::m_nextException = recognizer->get_state()->get_exception(); /* So we don't leak the memory */ - recognizer->get_state()->set_exception(this); - recognizer->get_state()->set_error( true ); /* Exception is outstanding */ + recognizer->getSuper()->fillExceptionData( this ); + BaseType::m_input = recognizer->getSuper()->getIstream(); + BaseType::m_nextException = recognizer->getState()->getException(); /* So we don't leak the memory */ + recognizer->getState()->setException(this); + recognizer->getState()->setError( true ); /* Exception is outstanding */ } template<class ImplTraits, ExceptionType Ex, class StreamType> Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3filestream.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3filestream.inl 2013-04-17 15:18:27 UTC (rev 4627) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3filestream.inl 2013-04-18 13:22:51 UTC (rev 4628) @@ -59,10 +59,10 @@ */ FileUtils<ImplTraits>::AntlrFread(infile, fSize, data ); - input->set_data( (unsigned char*) data ); - input->set_sizeBuf( fSize ); + input->setData( (unsigned char*) data ); + input->setSizeBuf( fSize ); - input->set_isAllocated(true); + input->setIsAllocated(true); /* And close the file handle */ Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3input.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3input.hpp 2013-04-17 15:18:27 UTC (rev 4627) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3input.hpp 2013-04-18 13:22:51 UTC (rev 4628) @@ -138,41 +138,41 @@ InputStream(const ANTLR_UINT8* fileName, ANTLR_UINT32 encoding); InputStream(const ANTLR_UINT8* data, ANTLR_UINT32 encoding, ANTLR_UINT32 size, ANTLR_UINT8* name); ~InputStream(); - const DataType* get_data() const; - bool get_isAllocated() const; - const DataType* get_nextChar() const; - ANTLR_UINT32 get_sizeBuf() const; - ANTLR_UINT32 get_line() const; - const DataType* get_currentLine() const; - ANTLR_INT32 get_charPositionInLine() const; - ANTLR_UINT32 get_markDepth() const; - MarkersType& get_markers(); - const StringType& get_fileName() const; - ANTLR_UINT32 get_fileNo() const; - ANTLR_UCHAR get_newlineChar() const; - ANTLR_UINT8 get_charByteSize() const; - ANTLR_UINT32 get_encoding() const; + const DataType* getData() const; + bool getIsAllocated() const; + const DataType* getNextChar() const; + ANTLR_UINT32 getSizeBuf() const; + ANTLR_UINT32 getLine() const; + const DataType* getCurrentLine() const; + ANTLR_INT32 getCharPositionInLine() const; + ANTLR_UINT32 getMarkDepth() const; + MarkersType& getMarkers(); + const StringType& getFileName() const; + ANTLR_UINT32 getFileNo() const; + ANTLR_UCHAR getNewlineChar() const; + ANTLR_UINT8 getCharByteSize() const; + ANTLR_UINT32 getEncoding() const; - void set_data( DataType* data ); - void set_isAllocated( bool isAllocated ); - void set_nextChar( const DataType* nextChar ); - void set_sizeBuf( ANTLR_UINT32 sizeBuf ); - void set_line( ANTLR_UINT32 line ); - void set_currentLine( const DataType* currentLine ); - void set_charPositionInLine( ANTLR_INT32 charPositionInLine ); - void set_markDepth( ANTLR_UINT32 markDepth ); - void set_markers( const MarkersType& markers ); - void set_fileName( const StringType& fileName ); - void set_fileNo( ANTLR_UINT32 fileNo ); - void set_newlineChar( ANTLR_UCHAR newlineChar ); - void set_charByteSize( ANTLR_UINT8 charByteSize ); - void set_encoding( ANTLR_UINT32 encoding ); + void setData( DataType* data ); + void setIsAllocated( bool isAllocated ); + void setNextChar( const DataType* nextChar ); + void setSizeBuf( ANTLR_UINT32 sizeBuf ); + void setLine( ANTLR_UINT32 line ); + void setCurrentLine( const DataType* currentLine ); + void setCharPositionInLine( ANTLR_INT32 charPositionInLine ); + void setMarkDepth( ANTLR_UINT32 markDepth ); + void setMarkers( const MarkersType& markers ); + void setFileName( const StringType& fileName ); + void setFileNo( ANTLR_UINT32 fileNo ); + void setNewlineChar( ANTLR_UCHAR newlineChar ); + void setCharByteSize( ANTLR_UINT8 charByteSize ); + void setEncoding( ANTLR_UINT32 encoding ); void inc_charPositionInLine(); void inc_line(); void inc_markDepth(); - IntStreamType* get_istream(); + IntStreamType* getIstream(); /** Function that resets the input stream */ @@ -198,7 +198,7 @@ /** Function to return the current line number in the input stream */ - ANTLR_UINT32 get_line(); + ANTLR_UINT32 getLine(); /** Function to return the current line buffer in the input stream * The pointer returned is directly into the input stream so you must copy @@ -213,11 +213,11 @@ /** Function to return the current offset in the current input stream line */ - ANTLR_UINT32 get_charPositionInLine(); + ANTLR_UINT32 getCharPositionInLine(); /** Function to set the current position in the current line. */ - void set_charPositionInLine(ANTLR_UINT32 position); + void setCharPositionInLine(ANTLR_UINT32 position); /** Function to override the default newline character that the input stream * looks for to trigger the line/offset and line buffer recording information. @@ -302,14 +302,14 @@ public: LexState(); - const DataType* get_nextChar() const; - ANTLR_UINT32 get_line() const; - const DataType* get_currentLine() const; - ANTLR_INT32 get_charPositionInLine() const; - void set_nextChar( const DataType* nextChar ); - void set_line( ANTLR_UINT32 line ); - void set_currentLine( const DataType* currentLine ); - void set_charPositionInLine( ANTLR_INT32 charPositionInLine ); + const DataType* getNextChar() const; + ANTLR_UINT32 getLine() const; + const DataType* getCurrentLine() const; + ANTLR_INT32 getCharPositionInLine() const; + void setNextChar( const DataType* nextChar ); + void setLine( ANTLR_UINT32 line ); + void setCurrentLine( const DataType* currentLine ); + void setCharPositionInLine( ANTLR_INT32 charPositionInLine ); }; class ParseNullStringException : public std::exception Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3input.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3input.inl 2013-04-17 15:18:27 UTC (rev 4627) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3input.inl 2013-04-18 13:22:51 UTC (rev 4628) @@ -98,7 +98,7 @@ template<class ImplTraits> void InputStream<ImplTraits>::genericSetupStream() { - this->set_charByteSize(1); + this->setCharByteSize(1); /* Set up the input stream brand new */ @@ -120,142 +120,142 @@ } template<class ImplTraits> -ANTLR_INLINE const typename InputStream<ImplTraits>::DataType* InputStream<ImplTraits>::get_data() const +ANTLR_INLINE const typename InputStream<ImplTraits>::DataType* InputStream<ImplTraits>::getData() const { return m_data; } template<class ImplTraits> -ANTLR_INLINE bool InputStream<ImplTraits>::get_isAllocated() const +ANTLR_INLINE bool InputStream<ImplTraits>::getIsAllocated() const { return m_isAllocated; } template<class ImplTraits> -ANTLR_INLINE const typename InputStream<ImplTraits>::DataType* InputStream<ImplTraits>::get_nextChar() const +ANTLR_INLINE const typename InputStream<ImplTraits>::DataType* InputStream<ImplTraits>::getNextChar() const { return m_nextChar; } template<class ImplTraits> -ANTLR_INLINE ANTLR_UINT32 InputStream<ImplTraits>::get_sizeBuf() const +ANTLR_INLINE ANTLR_UINT32 InputStream<ImplTraits>::getSizeBuf() const { return m_sizeBuf; } template<class ImplTraits> -ANTLR_INLINE ANTLR_UINT32 InputStream<ImplTraits>::get_line() const +ANTLR_INLINE ANTLR_UINT32 InputStream<ImplTraits>::getLine() const { return m_line; } template<class ImplTraits> -ANTLR_INLINE const typename InputStream<ImplTraits>::DataType* InputStream<ImplTraits>::get_currentLine() const +ANTLR_INLINE const typename InputStream<ImplTraits>::DataType* InputStream<ImplTraits>::getCurrentLine() const { return m_currentLine; } template<class ImplTraits> -ANTLR_INLINE ANTLR_INT32 InputStream<ImplTraits>::get_charPositionInLine() const +ANTLR_INLINE ANTLR_INT32 InputStream<ImplTraits>::getCharPositionInLine() const { return m_charPositionInLine; } template<class ImplTraits> -ANTLR_INLINE ANTLR_UINT32 InputStream<ImplTraits>::get_markDepth() const +ANTLR_INLINE ANTLR_UINT32 InputStream<ImplTraits>::getMarkDepth() const { return m_markDepth; } template<class ImplTraits> -ANTLR_INLINE typename InputStream<ImplTraits>::MarkersType& InputStream<ImplTraits>::get_markers() +ANTLR_INLINE typename InputStream<ImplTraits>::MarkersType& InputStream<ImplTraits>::getMarkers() { return m_markers; } template<class ImplTraits> -ANTLR_INLINE const typename InputStream<ImplTraits>::StringType& InputStream<ImplTraits>::get_fileName() const +ANTLR_INLINE const typename InputStream<ImplTraits>::StringType& InputStream<ImplTraits>::getFileName() const { return m_fileName; } template<class ImplTraits> -ANTLR_INLINE ANTLR_UINT32 InputStream<ImplTraits>::get_fileNo() const +ANTLR_INLINE ANTLR_UINT32 InputStream<ImplTraits>::getFileNo() const { return m_fileNo; } template<class ImplTraits> -ANTLR_INLINE ANTLR_UCHAR InputStream<ImplTraits>::get_newlineChar() const +ANTLR_INLINE ANTLR_UCHAR InputStream<ImplTraits>::getNewlineChar() const { return m_newlineChar; } template<class ImplTraits> -ANTLR_INLINE ANTLR_UINT8 InputStream<ImplTraits>::get_charByteSize() const +ANTLR_INLINE ANTLR_UINT8 InputStream<ImplTraits>::getCharByteSize() const { return m_charByteSize; } template<class ImplTraits> -ANTLR_INLINE ANTLR_UINT32 InputStream<ImplTraits>::get_encoding() const +ANTLR_INLINE ANTLR_UINT32 InputStream<ImplTraits>::getEncoding() const { return m_encoding; } template<class ImplTraits> -ANTLR_INLINE void InputStream<ImplTraits>::set_data( DataType* data ) +ANTLR_INLINE void InputStream<ImplTraits>::setData( DataType* data ) { m_data = data; } template<class ImplTraits> -ANTLR_INLINE void InputStream<ImplTraits>::set_isAllocated( bool isAllocated ) +ANTLR_INLINE void InputStream<ImplTraits>::setIsAllocated( bool isAllocated ) { m_isAllocated = isAllocated; } template<class ImplTraits> -ANTLR_INLINE void InputStream<ImplTraits>::set_nextChar( const DataType* nextChar ) +ANTLR_INLINE void InputStream<ImplTraits>::setNextChar( const DataType* nextChar ) { m_nextChar = nextChar; } template<class ImplTraits> -ANTLR_INLINE void InputStream<ImplTraits>::set_sizeBuf( ANTLR_UINT32 sizeBuf ) +ANTLR_INLINE void InputStream<ImplTraits>::setSizeBuf( ANTLR_UINT32 sizeBuf ) { m_sizeBuf = sizeBuf; } template<class ImplTraits> -ANTLR_INLINE void InputStream<ImplTraits>::set_line( ANTLR_UINT32 line ) +ANTLR_INLINE void InputStream<ImplTraits>::setLine( ANTLR_UINT32 line ) { m_line = line; } template<class ImplTraits> -ANTLR_INLINE void InputStream<ImplTraits>::set_currentLine( const DataType* currentLine ) +ANTLR_INLINE void InputStream<ImplTraits>::setCurrentLine( const DataType* currentLine ) { m_currentLine = currentLine; } template<class ImplTraits> -ANTLR_INLINE void InputStream<ImplTraits>::set_charPositionInLine( ANTLR_INT32 charPositionInLine ) +ANTLR_INLINE void InputStream<ImplTraits>::setCharPositionInLine( ANTLR_INT32 charPositionInLine ) { m_charPositionInLine = charPositionInLine; } template<class ImplTraits> -ANTLR_INLINE void InputStream<ImplTraits>::set_markDepth( ANTLR_UINT32 markDepth ) +ANTLR_INLINE void InputStream<ImplTraits>::setMarkDepth( ANTLR_UINT32 markDepth ) { m_markDepth = markDepth; } template<class ImplTraits> -ANTLR_INLINE void InputStream<ImplTraits>::set_markers( const MarkersType& markers ) +ANTLR_INLINE void InputStream<ImplTraits>::setMarkers( const MarkersType& markers ) { m_markers = markers; } template<class ImplTraits> -ANTLR_INLINE void InputStream<ImplTraits>::set_fileName( const StringType& fileName ) +ANTLR_INLINE void InputStream<ImplTraits>::setFileName( const StringType& fileName ) { m_fileName = fileName; } template<class ImplTraits> -ANTLR_INLINE v... [truncated message content] |
From: <ibr...@us...> - 2013-04-19 10:48:13
|
Revision: 4629 http://sourceforge.net/p/tora/code/4629 Author: ibre5041 Date: 2013-04-19 10:48:03 +0000 (Fri, 19 Apr 2013) Log Message: ----------- Modified Paths: -------------- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3parser.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3traits.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3treeparser.hpp branches/tora3/extlibs/parsing.cpp/SQLMini.g branches/tora3/extlibs/parsing.cpp/antlr-complete-3.5.1-SNAPSHOT.jar branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/AST.stg branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/Cpp.stg Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.inl 2013-04-18 13:22:51 UTC (rev 4628) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.inl 2013-04-19 10:48:03 UTC (rev 4629) @@ -87,7 +87,7 @@ // going on, so we mismatch, which creates an exception in the recognizer exception // stack. // - matchedSymbol = this->recoverFromMismatchedToken(ttype, follow); + matchedSymbol = this->recoverFromMismatchedToken(ttype, follow); return matchedSymbol; } Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3parser.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3parser.hpp 2013-04-18 13:22:51 UTC (rev 4628) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3parser.hpp 2013-04-19 10:48:03 UTC (rev 4629) @@ -64,10 +64,10 @@ typedef typename ImplTraits::DebugEventListenerType DebuggerType; private: - /** A provider of a tokenstream interface, for the parser to consume - * tokens from. - */ - TokenStreamType* m_tstream; + /** A provider of a tokenstream interface, for the parser to consume + * tokens from. + */ + TokenStreamType* m_tstream; public: Parser( ANTLR_UINT32 sizeHint, RecognizerSharedStateType* state ); @@ -89,24 +89,24 @@ */ void setDebugListener(DebugEventListenerType* dbg); - /** A pointer to a function that installs a token stream - * for the parser. - */ - void setTokenStream(TokenStreamType*); + /** A pointer to a function that installs a token stream + * for the parser. + */ + void setTokenStream(TokenStreamType*); + + /** A pointer to a function that returns the token stream for this + * parser. + */ + TokenStreamType* getTokenStream(); - /** A pointer to a function that returns the token stream for this - * parser. - */ - TokenStreamType* getTokenStream(); - void exConstruct(); TokenType* getMissingSymbol( IntStreamType* istream, ExceptionBaseType* e, - ANTLR_UINT32 expectedTokenType, BitsetListType* follow); + ANTLR_UINT32 expectedTokenType, BitsetListType* follow); void mismatch(ANTLR_UINT32 ttype, BitsetListType* follow); - /** Pointer to a function that knows how to free resources of an ANTLR3 parser. - */ + /** Pointer to a function that knows how to free resources of an ANTLR3 parser. + */ ~Parser(); void fillExceptionData( ExceptionBaseType* ex ); Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.hpp 2013-04-18 13:22:51 UTC (rev 4628) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.hpp 2013-04-19 10:48:03 UTC (rev 4629) @@ -68,38 +68,38 @@ protected: /// Track single elements w/o creating a list. Upon 2nd add, alloc list - /// - TokenType* m_singleElement; + /// + TokenType* m_singleElement; - /// The list of tokens or subtrees we are tracking - /// - ElementsType m_elements; + /// The list of tokens or subtrees we are tracking + /// + ElementsType m_elements; - /// 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. - /// - StringType m_elementDescription; + /// 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. + /// + StringType m_elementDescription; /// Pointer to the tree adaptor in use for this stream /// - TreeAdaptorType* m_adaptor; + TreeAdaptorType* m_adaptor; // Pointer to the recognizer shared state to which this stream belongs // - RecognizerType* m_rec; + RecognizerType* m_rec; /// Cursor 0..n-1. If singleElement!=NULL, cursor is 0 until you next(), - /// which bumps it to 1 meaning no more elements. - /// - ANTLR_UINT32 m_cursor; + /// which bumps it to 1 meaning no more elements. + /// + ANTLR_UINT32 m_cursor; /// 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. /// - bool m_dirty; + bool m_dirty; public: RewriteRuleElementStream(TreeAdaptorType* adaptor, RecognizerType* rec, ANTLR_UINT8* description); @@ -107,58 +107,59 @@ RewriteRuleElementStream(TreeAdaptorType* adaptor, RecognizerType* rec, ANTLR_UINT8* description, const ElementsType& elements); ~RewriteRuleElementStream(); - // Methods + + // 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(); + /// Reset the condition of this stream so that it appears we have + /// not consumed any of its elements. Elements themselves are untouched. + /// + void reset(); - /// Add a new pANTLR3_BASE_TREE to this stream - /// - void add(TokenType* el); + /// Add a new pANTLR3_BASE_TREE to this stream + /// + void add(TokenType* el); - /// 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]. - /// - TokenType* next(); - TreeType* nextTree(); - TokenType* nextToken(); - TokenType* _next(); + /// 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]. + /// + TokenType* next(); + TreeType* nextTree(); + TokenType* nextToken(); + TokenType* _next(); /// 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(). - /// + /// subtree. Dup'ing a token means just creating another AST node + /// around it. For trees, you must call the adaptor.dupTree(). + /// TokenType* dup( TokenType* el ); - /// Ensure stream emits trees; tokens must be converted to AST nodes. - /// AST nodes can be passed through unmolested. - /// - TreeType* toTree(TreeType* el); + /// Ensure stream emits trees; tokens must be converted to AST nodes. + /// AST nodes can be passed through unmolested. + /// + TreeType* toTree(TreeType* el); - /// Returns true if there is a next element available - /// - bool hasNext(); + /// Returns true if there is a next element available + /// + bool hasNext(); - /// 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. - /// - TreeType* nextNode(); + /// 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. + /// + TreeType* nextNode(); - /// Number of elements available in the stream - /// - ANTLR_UINT32 size(); + /// Number of elements available in the stream + /// + ANTLR_UINT32 size(); - /// Returns the description string if there is one available (check for NULL). - /// - StringType getDescription(); + /// Returns the description string if there is one available (check for NULL). + /// + StringType getDescription(); protected: void init(TreeAdaptorType* adaptor, RecognizerType* rec, ANTLR_UINT8* description); @@ -192,7 +193,7 @@ }; /// This is an implementation of a subtree stream which is a set of trees -/// modelled as an element stream. +/// modeled as an element stream. /// template<class ImplTraits> class RewriteRuleSubtreeStream : public ImplTraits::template RewriteRuleElementStreamType< typename ImplTraits::TreeParserType> Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.inl 2013-04-18 13:22:51 UTC (rev 4628) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.inl 2013-04-19 10:48:03 UTC (rev 4629) @@ -26,7 +26,7 @@ template<class ImplTraits, class SuperType> void RewriteRuleElementStream<ImplTraits, SuperType>::init(TreeAdaptorType* adaptor, - RecognizerType* rec, ANTLR_UINT8* description) + RecognizerType* rec, ANTLR_UINT8* description) { m_rec = rec; m_adaptor = adaptor; @@ -331,43 +331,43 @@ { TreeType* tree; - // Before placing the stream back in the pool, we + // Before placing the stream back in the pool, we // need to clear any vector it has. This is so any // free pointers that are associated with the // entires are called. However, if this particular function is called - // then we know that the entries in the stream are definately - // tree nodes. Hence we check to see if any of them were nilNodes as - // if they were, we can reuse them. + // then we know that the entries in the stream are definately + // tree nodes. Hence we check to see if any of them were nilNodes as + // if they were, we can reuse them. // if ( !m_elements.empty() ) { - // We have some elements to traverse - // - ANTLR_UINT32 i; + // We have some elements to traverse + // + ANTLR_UINT32 i; - for (i = 1; i<= m_elements.size(); i++) - { - tree = m_elements.at(i-1); - if ( (tree != NULL) && tree->isNilNode() ) - { - // Had to remove this for now, check is not comprehensive enough - // tree->reuse(tree); - } - } + for (i = 1; i<= m_elements.size(); i++) + { + tree = m_elements.at(i-1); + if ( (tree != NULL) && tree->isNilNode() ) + { + // Had to remove this for now, check is not comprehensive enough + // tree->reuse(tree); + } + } m_elements.clear(); } else { - if (m_singleElement != NULL) - { - tree = m_singleElement; - if (tree->isNilNode()) - { - // Had to remove this for now, check is not comprehensive enough - // tree->reuse(tree); - } - } - m_singleElement = NULL; + if (m_singleElement != NULL) + { + tree = m_singleElement; + if (tree->isNilNode()) + { + // Had to remove this for now, check is not comprehensive enough + // tree->reuse(tree); + } + } + m_singleElement = NULL; } } Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3traits.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3traits.hpp 2013-04-18 13:22:51 UTC (rev 4628) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3traits.hpp 2013-04-19 10:48:03 UTC (rev 4629) @@ -5,8 +5,12 @@ ANTLR_BEGIN_NAMESPACE() - -//Users implementing overrides should inherit from this + +/** + * Users implementing overrides should inherit from this + * + * All classes typenames reffer to Empty class + */ template<class ImplTraits> class CustomTraitsBase { @@ -87,6 +91,9 @@ static void displayRecognitionError( const std::string& str ) { printf("%s", str.c_str() ); } }; +/** + * Traits manipulation classes + */ template<class A, class B> class TraitsSelector { @@ -129,100 +136,121 @@ typedef B selected; }; +/** + * Base traits template + * + * This class contains default typenames for every trait + */ template< template<class ImplTraits> class UserTraits > class TraitsBase { public: typedef TraitsBase TraitsType; - typedef typename TraitsSelector< typename UserTraits<TraitsType>::AllocPolicyType, DefaultAllocPolicy >::selected AllocPolicyType; + typedef typename TraitsSelector< typename UserTraits<TraitsType>::AllocPolicyType, + DefaultAllocPolicy + >::selected AllocPolicyType; typedef typename TraitsSelector< typename UserTraits<TraitsType>::StringType, - std::string >::selected StringType; + std::string + >::selected StringType; typedef typename TraitsSelector< typename UserTraits<TraitsType>::StringStreamType, - std::stringstream >::selected StringStreamType; + std::stringstream + >::selected StringStreamType; typedef typename TraitsSelector< typename UserTraits<TraitsType>::StreamDataType, - ANTLR_UINT8 >::selected StreamDataType; + ANTLR_UINT8 + >::selected StreamDataType; typedef typename TraitsSelector< typename UserTraits<TraitsType>::Endianness, - RESOLVE_ENDIAN_AT_RUNTIME >::selected Endianness; + RESOLVE_ENDIAN_AT_RUNTIME + >::selected Endianness; typedef typename TraitsSelector< typename UserTraits<TraitsType>::BitsetType, - Bitset<TraitsType> >::selected BitsetType; + Bitset<TraitsType> + >::selected BitsetType; typedef typename TraitsSelector< typename UserTraits<TraitsType>::BitsetListType, - BitsetList<TraitsType> >::selected BitsetListType; + BitsetList<TraitsType> + >::selected BitsetListType; typedef typename TraitsSelector< typename UserTraits<TraitsType>::InputStreamType, - InputStream<TraitsType> >::selected InputStreamType; + InputStream<TraitsType> + >::selected InputStreamType; template<class SuperType> - class IntStreamType - : public TraitsOneArgSelector< - typename UserTraits<TraitsType>::template IntStreamType<SuperType>, - IntStream<TraitsType, SuperType>, - typename UserTraits<TraitsType>::template IntStreamType<SuperType>::BaseType - >::selected + class IntStreamType : public TraitsOneArgSelector< typename UserTraits<TraitsType>::template IntStreamType<SuperType>, + IntStream<TraitsType, SuperType>, + typename UserTraits<TraitsType>::template IntStreamType<SuperType>::BaseType + >::selected { }; typedef typename TraitsSelector< typename UserTraits<TraitsType>::LexStateType, - LexState<TraitsType> >::selected LexStateType; + LexState<TraitsType> + >::selected LexStateType; static const bool TOKENS_ACCESSED_FROM_OWNING_RULE = UserTraits<TraitsType>::TOKENS_ACCESSED_FROM_OWNING_RULE; static const int TOKEN_FILL_BUFFER_INCREMENT = UserTraits<TraitsType>::TOKEN_FILL_BUFFER_INCREMENT; //used only if the above val is true - static void displayRecognitionError( const StringType& str ) { UserTraits<TraitsType>::displayRecognitionError(str); } + static void displayRecognitionError( const StringType& str ) { UserTraits<TraitsType>::displayRecognitionError(str); } }; -template< - class LxrType, - class PsrType, - template<class ImplTraits> class UserTraits = CustomTraitsBase, - class TreePsrType = antlr3::Empty - > -class Traits : public TraitsBase<UserTraits> +/** + * Final traits + * + * They combine Traits and user provided traits(UserTraits) + */ +template< class LxrType, + class PsrType, + template<class ImplTraits> class UserTraits = CustomTraitsBase + //, + //class TreePsrType = antlr3::Empty + //template<class ImplTraits> class TreePsrType = TreeParser + > +class Traits : public TraitsBase<UserTraits> { public: typedef Traits TraitsType; typedef TraitsBase<UserTraits> BaseTraitsType; + // CommonTokenType typedef typename TraitsSelector< typename UserTraits<TraitsType>::CommonTokenType, - CommonToken<TraitsType> >::selected CommonTokenType; + CommonToken<TraitsType> >::selected CommonTokenType; + // TokenIntStreamType typedef typename TraitsSelector< typename UserTraits<TraitsType>::TokenIntStreamType, - TokenIntStream<TraitsType> >::selected TokenIntStreamType; - + TokenIntStream<TraitsType> >::selected TokenIntStreamType; + + // TokenStreamType typedef typename TraitsSelector< typename UserTraits<TraitsType>::TokenStreamType, - CommonTokenStream<TraitsType> >::selected TokenStreamType; + CommonTokenStream<TraitsType> >::selected TokenStreamType; + // TreeNodeStreamType typedef typename TraitsSelector< typename UserTraits<TraitsType>::TreeNodeStreamType, - CommonTreeNodeStream<TraitsType> >::selected TreeNodeStreamType; - + CommonTreeNodeStream<TraitsType> >::selected TreeNodeStreamType; + + // DebugEventListenerType typedef typename TraitsSelector< typename UserTraits<TraitsType>::DebugEventListenerType, - DebugEventListener<TraitsType> >::selected DebugEventListenerType; - + DebugEventListener<TraitsType> >::selected DebugEventListenerType; + + // RecognizerSharedStateType template<class StreamType> - class RecognizerSharedStateType - : public TraitsOneArgSelector< - typename UserTraits<TraitsType>::template RecognizerSharedStateType<StreamType>, - RecognizerSharedState<TraitsType, StreamType>, - typename UserTraits<TraitsType>::template RecognizerSharedStateType<StreamType>::BaseType - >::selected + class RecognizerSharedStateType : public TraitsOneArgSelector< typename UserTraits<TraitsType>::template RecognizerSharedStateType<StreamType>, + RecognizerSharedState<TraitsType, StreamType>, + typename UserTraits<TraitsType>::template RecognizerSharedStateType<StreamType>::BaseType + >::selected {}; + // RecognizerType template<class StreamType> - class RecognizerType - : public TraitsOneArgSelector< - typename UserTraits<TraitsType>::template RecognizerType<StreamType>, - BaseRecognizer<TraitsType, StreamType>, - typename UserTraits<TraitsType>::template RecognizerType<StreamType>::BaseType - >::selected + class RecognizerType : public TraitsOneArgSelector< typename UserTraits<TraitsType>::template RecognizerType<StreamType>, + BaseRecognizer<TraitsType, StreamType>, + typename UserTraits<TraitsType>::template RecognizerType<StreamType>::BaseType + >::selected { public: - typedef typename TraitsOneArgSelector< - typename UserTraits<TraitsType>::template RecognizerType<StreamType>, - BaseRecognizer<TraitsType, StreamType>, - typename UserTraits<TraitsType>::template RecognizerType<StreamType>::BaseType - >::selected BaseType; + typedef typename TraitsOneArgSelector< typename UserTraits<TraitsType>::template RecognizerType<StreamType>, + BaseRecognizer<TraitsType, StreamType>, + typename UserTraits<TraitsType>::template RecognizerType<StreamType>::BaseType + >::selected BaseType; typedef typename BaseType::RecognizerSharedStateType RecognizerSharedStateType; public: @@ -232,24 +260,25 @@ } }; + // TreeType typedef typename TraitsSelector< typename UserTraits<TraitsType>::TreeType, - CommonTree<TraitsType> >::selected TreeType; + CommonTree<TraitsType> >::selected TreeType; + // TreeAdaptorType typedef typename TraitsSelector< typename UserTraits<TraitsType>::TreeAdaptorType, - CommonTreeAdaptor<TraitsType> >::selected TreeAdaptorType; - + CommonTreeAdaptor<TraitsType> >::selected TreeAdaptorType; + + // ExceptionBaseType template<class StreamType> - class ExceptionBaseType : public TraitsOneArgSelector< - typename UserTraits<TraitsType>::template ExceptionBaseType<StreamType>, - ANTLR_ExceptionBase<TraitsType, StreamType>, - typename UserTraits<TraitsType>::template ExceptionBaseType<StreamType>::BaseType - >::selected + class ExceptionBaseType : public TraitsOneArgSelector< typename UserTraits<TraitsType>::template ExceptionBaseType<StreamType>, + ANTLR_ExceptionBase<TraitsType, StreamType>, + typename UserTraits<TraitsType>::template ExceptionBaseType<StreamType>::BaseType + >::selected { public: - typedef typename TraitsOneArgSelector< - typename UserTraits<TraitsType>::template ExceptionBaseType<StreamType>, - ANTLR_ExceptionBase<TraitsType, StreamType>, - typename UserTraits<TraitsType>::template ExceptionBaseType<StreamType>::BaseType - >::selected BaseType; + typedef typename TraitsOneArgSelector< typename UserTraits<TraitsType>::template ExceptionBaseType<StreamType>, + ANTLR_ExceptionBase<TraitsType, StreamType>, + typename UserTraits<TraitsType>::template ExceptionBaseType<StreamType>::BaseType + >::selected BaseType; protected: ExceptionBaseType( const typename BaseTraitsType::StringType& message ) @@ -258,35 +287,41 @@ } }; - //this should be overridden with generated lexer + // this should be overridden with generated lexer + // BaseLexerType typedef typename TraitsSelector< typename UserTraits<TraitsType>::BaseLexerType, - Lexer<TraitsType> >::selected BaseLexerType; + Lexer<TraitsType> >::selected BaseLexerType; typedef LxrType LexerType; + // TokenSourceType typedef typename TraitsSelector< typename UserTraits<TraitsType>::TokenSourceType, - TokenSource<TraitsType> >::selected TokenSourceType; + TokenSource<TraitsType> >::selected TokenSourceType; + + // this should be overridden with generated parser + // BaseParserType typedef typename TraitsSelector< typename UserTraits<TraitsType>::BaseParserType, - Parser<TraitsType> >::selected BaseParserType; - + Parser<TraitsType> >::selected BaseParserType; typedef PsrType ParserType; + // this should be overridden with generated treeparser (not implemented yet) + // BaseTreeParserType typedef typename TraitsSelector< typename UserTraits<TraitsType>::BaseTreeParserType, - TreeParser<TraitsType> >::selected BaseTreeParserType; - typedef TreePsrType TreeParserType; + TreeParser<TraitsType> >::selected BaseTreeParserType; + //typedef TreePsrType<Traits> TreeParserType; + typedef BaseTreeParserType TreeParserType; + // RewriteStreamType template<class SuperType> - class RewriteStreamType : public TraitsOneArgSelector< - typename UserTraits<TraitsType>::template RewriteStreamType<SuperType>, - RewriteRuleElementStream<TraitsType, SuperType>, - typename UserTraits<TraitsType>::template RewriteStreamType<SuperType>::BaseType - >::selected + class RewriteStreamType : public TraitsOneArgSelector< typename UserTraits<TraitsType>::template RewriteStreamType<SuperType>, + RewriteRuleElementStream<TraitsType, SuperType>, + typename UserTraits<TraitsType>::template RewriteStreamType<SuperType>::BaseType + >::selected { public: - typedef typename TraitsOneArgSelector< - typename UserTraits<TraitsType>::template RewriteStreamType<SuperType>, - RewriteRuleElementStream<TraitsType, SuperType>, - typename UserTraits<TraitsType>::template RewriteStreamType<SuperType>::BaseType - >::selected BaseType; + typedef typename TraitsOneArgSelector< typename UserTraits<TraitsType>::template RewriteStreamType<SuperType>, + RewriteRuleElementStream<TraitsType, SuperType>, + typename UserTraits<TraitsType>::template RewriteStreamType<SuperType>::BaseType + >::selected BaseType; typedef typename SuperType::StreamType StreamType; typedef typename BaseType::RecognizerType Recognizer_Type; @@ -294,7 +329,7 @@ typedef typename BaseType::ElementsType ElementsType; public: - RewriteStreamType(TreeAdaptorType* adaptor = NULL, Recognizer_Type* rec=NULL, ANTLR_UINT8* description = NULL) + RewriteStreamType(TreeAdaptorType* adaptor = NULL, Recognizer_Type* rec = NULL, ANTLR_UINT8* description = NULL) :BaseType(adaptor, rec, description) { } @@ -308,13 +343,15 @@ } }; + // RuleReturnValueType typedef typename TraitsSelector< typename UserTraits<TraitsType>::RuleReturnValueType, - typename BoolSelector< TraitsType::TOKENS_ACCESSED_FROM_OWNING_RULE, - RuleReturnValue_1<TraitsType>, RuleReturnValue<TraitsType> >::selected - >::selected RuleReturnValueType; + typename BoolSelector< TraitsType::TOKENS_ACCESSED_FROM_OWNING_RULE, + RuleReturnValue_1<TraitsType>, + RuleReturnValue<TraitsType> + >::selected + >::selected RuleReturnValueType; }; - ANTLR_END_NAMESPACE() #endif //_ANTLR3_TRAITS_HPP Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3treeparser.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3treeparser.hpp 2013-04-18 13:22:51 UTC (rev 4628) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3treeparser.hpp 2013-04-19 10:48:03 UTC (rev 4629) @@ -56,9 +56,9 @@ typedef typename ImplTraits::CommonTokenType CommonTokenType; private: - /** Pointer to the common tree node stream for the parser - */ - TreeNodeStreamType* m_ctnstream; + /** Pointer to the common tree node stream for the parser + */ + TreeNodeStreamType* m_ctnstream; public: TreeParser( ANTLR_UINT32 sizeHint, TreeNodeStreamType* ctnstream, @@ -71,21 +71,21 @@ //get_parser_istream exists only for parser, treeparser. So use it accordingly IntStreamType* get_parser_istream() const; - /** Set the input stream and reset the parser - */ - void setTreeNodeStream(TreeNodeStreamType* input); + /** Set the input stream and reset the parser + */ + void setTreeNodeStream(TreeNodeStreamType* input); + + /** Return a pointer to the input stream + */ + TreeNodeStreamType* getTreeNodeStream(); - /** Return a pointer to the input stream - */ - TreeNodeStreamType* getTreeNodeStream(); - TokenType* getMissingSymbol( IntStreamType* istream, - ExceptionBaseType* e, - ANTLR_UINT32 expectedTokenType, - BitsetListType* follow); - - /** Pointer to a function that knows how to free resources of an ANTLR3 tree parser. - */ + ExceptionBaseType* e, + ANTLR_UINT32 expectedTokenType, + BitsetListType* follow); + + /** Pointer to a function that knows how to free resources of an ANTLR3 tree parser. + */ ~TreeParser(); void fillExceptionData( ExceptionBaseType* ex ); Modified: branches/tora3/extlibs/parsing.cpp/SQLMini.g =================================================================== --- branches/tora3/extlibs/parsing.cpp/SQLMini.g 2013-04-18 13:22:51 UTC (rev 4628) +++ branches/tora3/extlibs/parsing.cpp/SQLMini.g 2013-04-19 10:48:03 UTC (rev 4629) @@ -65,7 +65,7 @@ ( fu1=for_update_clause )? // ( order_by_clause )? ( fu2=for_update_clause )? - ) //-> ^(T_SUBQUERY $fu1 $fu2) + ) -> ^(T_SUBQUERY $fu1 $fu2) | ( LPAREN subquery RPAREN // ( group_by_clause )? Modified: branches/tora3/extlibs/parsing.cpp/antlr-complete-3.5.1-SNAPSHOT.jar =================================================================== (Binary files differ) Modified: branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/AST.stg =================================================================== --- branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/AST.stg 2013-04-18 13:22:51 UTC (rev 4628) +++ branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/AST.stg 2013-04-19 10:48:03 UTC (rev 4629) @@ -74,19 +74,20 @@ ruleLabelDefs() ::= << <super.ruleLabelDefs()> <if(!ruleDescriptor.isSynPred)> -<[ruleDescriptor.tokenLabels,ruleDescriptor.wildcardTreeLabels, - ruleDescriptor.wildcardTreeListLabels]:{it | <ASTLabelType> <it.label.text>_tree=NULL;}; separator="\n"> -<ruleDescriptor.tokenListLabels:{it | <ASTLabelType> <it.label.text>_tree=NULL;}; separator="\n"> +<[ruleDescriptor.tokenLabels,ruleDescriptor.wildcardTreeLabels, ruleDescriptor.wildcardTreeListLabels]: +{it | <ASTLabelType> <it.label.text>_tree = NULL;}; separator="\n"> +<ruleDescriptor.tokenListLabels: +{it | <ASTLabelType> <it.label.text>_tree = NULL;}; separator="\n"> <if(ruleDescriptor.supportsLabelOptimization)> -<ruleDescriptor.allTokenRefsInRewrites - :{it | RewriteRule<rewriteElementType>Stream stream_<it>=new RewriteRule<rewriteElementType>Stream(adaptor,"token <it>");}; separator="\n"> -<ruleDescriptor.allRuleRefsInRewrites - :{it | RewriteRuleSubtreeStream stream_<it>=new RewriteRuleSubtreeStream(adaptor,"rule <it>");}; separator="\n"> +<ruleDescriptor.allTokenRefsInRewrites: +{it | RewriteRule<rewriteElementType>Stream\<ImplTraits> *stream_<it> = new RewriteRule<rewriteElementType>Stream\<ImplTraits>(this,"token <it>");}; separator="\n"> +<ruleDescriptor.allRuleRefsInRewrites: +{it | RewriteRuleSubtreeStream\<ImplTraits> *stream_<it> = new RewriteRuleSubtreeStream\<ImplTraits>(this,"rule <it>");}; separator="\n"> <else> <ruleDescriptor.allTokenRefsInAltsWithRewrites - :{it | RewriteRule<rewriteElementType>Stream stream_<it>=new RewriteRule<rewriteElementType>Stream(adaptor,"token <it>");}; separator="\n"> +:{it | RewriteRule<rewriteElementType>Stream\<ImplTraits> *stream_<it> = new RewriteRule<rewriteElementType>Stream\<ImplTraits>(this,"token <it>");}; separator="\n"> <ruleDescriptor.allRuleRefsInAltsWithRewrites - :{it | RewriteRuleSubtreeStream stream_<it>=new RewriteRuleSubtreeStream(adaptor,"rule <it>");}; separator="\n"> +:{it | RewriteRuleSubtreeStream\<ImplTraits> *stream_<it> = new RewriteRuleSubtreeStream\<ImplTraits>(this,"rule <it>");}; separator="\n"> <endif> <endif> >> @@ -211,27 +212,27 @@ rewriteCodeLabels() ::= << <referencedTokenLabels - :{it | RewriteRule<rewriteElementType>Stream stream_<it>=new RewriteRule<rewriteElementType>Stream(adaptor,"token <it>",<it>);}; + :{it | RewriteRule<rewriteElementType>Stream\<ImplTraits> *stream_<it>=new RewriteRule<rewriteElementType>Stream\<ImplTraits>(this,"token <it>",<it>);}; separator="\n" > <referencedTokenListLabels - :{it | RewriteRule<rewriteElementType>Stream stream_<it>=new RewriteRule<rewriteElementType>Stream(adaptor,"token <it>", list_<it>);}; + :{it | RewriteRule<rewriteElementType>Stream\<ImplTraits> *stream_<it>=new RewriteRule<rewriteElementType>Stream\<ImplTraits>(this,"token <it>", list_<it>);}; separator="\n" > <referencedWildcardLabels - :{it | RewriteRuleSubtreeStream stream_<it>=new RewriteRuleSubtreeStream(adaptor,"wildcard <it>",<it>);}; + :{it | RewriteRuleSubtreeStream\<ImplTraits> *stream_<it>=new RewriteRuleSubtreeStream\<ImplTraits>(this,"wildcard <it>",<it>);}; separator="\n" > <referencedWildcardListLabels - :{it | RewriteRuleSubtreeStream stream_<it>=new RewriteRuleSubtreeStream(adaptor,"wildcard <it>",list_<it>);}; + :{it | RewriteRuleSubtreeStream\<ImplTraits> *stream_<it>=new RewriteRuleSubtreeStream\<ImplTraits>(this,"wildcard <it>",list_<it>);}; separator="\n" > <referencedRuleLabels - :{it | RewriteRuleSubtreeStream stream_<it>=new RewriteRuleSubtreeStream(adaptor,"rule <it>",<it>!=NULL?<it>.getTree():NULL);}; + :{it | RewriteRuleSubtreeStream\<ImplTraits> *stream_<it>=new RewriteRuleSubtreeStream\<ImplTraits>(this,"rule <it>",<it>!=NULL?<it>.getTree():NULL);}; separator="\n" > <referencedRuleListLabels - :{it | RewriteRuleSubtreeStream stream_<it>=new RewriteRuleSubtreeStream(adaptor,"token <it>",list_<it>);}; + :{it | RewriteRuleSubtreeStream\<ImplTraits> *stream_<it>=new RewriteRuleSubtreeStream\<ImplTraits>(this,"token <it>",list_<it>);}; separator="\n" > >> Modified: branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/Cpp.stg =================================================================== --- branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/Cpp.stg 2013-04-18 13:22:51 UTC (rev 4628) +++ branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/Cpp.stg 2013-04-19 10:48:03 UTC (rev 4629) @@ -1039,7 +1039,7 @@ members={<actions.parser.members>} ) ::= << <beginNamespace(actions)> -<genericParser(inputStreamType="CommonTokenStreamType*", rewriteElementType="TOKEN", filterMode=false, ...)> +<genericParser(inputStreamType="CommonTokenStreamType*", rewriteElementType="Token", filterMode=false, ...)> <endNamespace(actions)> >> @@ -1062,7 +1062,7 @@ members={<actions.treeparser.members>} ) ::= << <beginNamespace(actions)> -<genericParser(inputStreamType="CommonTreeNodeStream*", rewriteElementType="NODE", ...)> +<genericParser(inputStreamType="CommonTreeNodeStream*", rewriteElementType="Node", ...)> <endNamespace(actions)> >> This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <ibr...@us...> - 2013-04-30 12:54:30
|
Revision: 4636 http://sourceforge.net/p/tora/code/4636 Author: ibre5041 Date: 2013-04-30 12:54:26 +0000 (Tue, 30 Apr 2013) Log Message: ----------- Modified Paths: -------------- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3treeparser.hpp branches/tora3/extlibs/parsing.cpp/UserMiniTraits.hpp Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.hpp 2013-04-30 12:51:38 UTC (rev 4635) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.hpp 2013-04-30 12:54:26 UTC (rev 4636) @@ -197,9 +197,7 @@ /// modeled as an element stream. /// template<class ImplTraits> -//class RewriteRuleSubtreeStream : public ImplTraits::template RewriteRuleElementStreamType< typename ImplTraits::TreeParserType> -//class RewriteRuleSubtreeStream : public RewriteRuleElementStream< ImplTraits> -class RewriteRuleSubtreeStream : public RewriteRuleElementStream< typename ImplTraits::TreeParserType, RewriteRuleSubtreeStream<ImplTraits> > +class RewriteRuleSubtreeStream : public ImplTraits::template RewriteStreamType< typename ImplTraits::TreeParserType> { public: typedef typename ImplTraits::AllocPolicyType AllocPolicyType; @@ -210,7 +208,7 @@ typedef TreeType TokenType; typedef typename ImplTraits::template RecognizerType< StreamType > RecognizerType; typedef typename AllocPolicyType::template VectorType< TokenType* > ElementsType; - typedef typename ImplTraits::template RewriteRuleElementStreamType< typename ImplTraits::TreeParserType> BaseType; + typedef typename ImplTraits::template RewriteStreamType< typename ImplTraits::TreeParserType> BaseType; public: RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, RecognizerType* rec, ANTLR_UINT8* description); Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3treeparser.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3treeparser.hpp 2013-04-30 12:51:38 UTC (rev 4635) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3treeparser.hpp 2013-04-30 12:54:26 UTC (rev 4636) @@ -48,7 +48,7 @@ typedef typename ImplTraits::TreeType TreeType; typedef TreeType TokenType; typedef typename ImplTraits::template ExceptionBaseType<TreeNodeStreamType> ExceptionBaseType; - typedef typename ImplTraits::template RecognizerType< TreeParser<ImplTraits> > RecognizerType; + typedef typename ImplTraits::template RecognizerType< typename ImplTraits::TreeNodeStreamType > RecognizerType; typedef typename RecognizerType::RecognizerSharedStateType RecognizerSharedStateType; typedef Empty TokenSourceType; typedef typename ImplTraits::BitsetListType BitsetListType; Modified: branches/tora3/extlibs/parsing.cpp/UserMiniTraits.hpp =================================================================== --- branches/tora3/extlibs/parsing.cpp/UserMiniTraits.hpp 2013-04-30 12:51:38 UTC (rev 4635) +++ branches/tora3/extlibs/parsing.cpp/UserMiniTraits.hpp 2013-04-30 12:54:26 UTC (rev 4636) @@ -25,8 +25,8 @@ public: }; -typedef antlr3::Traits<SQLMiniLexer, SQLMiniParser, UserTraits> SQLMiniLexerTraits; -typedef antlr3::Traits<SQLMiniLexer, SQLMiniParser, UserTraits> SQLMiniParserTraits; +typedef antlr3::Traits<SQLMiniLexer, SQLMiniParser, UserTraits> SQLMiniLexerTraits; +typedef SQLMiniLexerTraits SQLMiniParserTraits; }; This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <ibr...@us...> - 2013-05-05 22:04:25
|
Revision: 4637 http://sourceforge.net/p/tora/code/4637 Author: ibre5041 Date: 2013-05-05 22:04:22 +0000 (Sun, 05 May 2013) Log Message: ----------- Modified Paths: -------------- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3traits.hpp branches/tora3/extlibs/parsing.cpp/antlr-complete-3.5.1-SNAPSHOT.jar branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/AST.stg Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.hpp 2013-04-30 12:54:26 UTC (rev 4636) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.hpp 2013-05-05 22:04:22 UTC (rev 4637) @@ -86,10 +86,6 @@ /// TreeAdaptorType* m_adaptor; - // Pointer to the recognizer shared state to which this stream belongs - // - RecognizerType* m_rec; - /// Cursor 0..n-1. If singleElement!=NULL, cursor is 0 until you next(), /// which bumps it to 1 meaning no more elements. /// @@ -103,9 +99,9 @@ bool m_dirty; public: - RewriteRuleElementStream(TreeAdaptorType* adaptor, RecognizerType* rec, ANTLR_UINT8* description); - RewriteRuleElementStream(TreeAdaptorType* adaptor, RecognizerType* rec, ANTLR_UINT8* description, TokenType* oneElement); - RewriteRuleElementStream(TreeAdaptorType* adaptor, RecognizerType* rec, ANTLR_UINT8* description, const ElementsType& elements); + RewriteRuleElementStream(TreeAdaptorType* adaptor, ANTLR_UINT8* description); + RewriteRuleElementStream(TreeAdaptorType* adaptor, ANTLR_UINT8* description, TokenType* oneElement); + RewriteRuleElementStream(TreeAdaptorType* adaptor, ANTLR_UINT8* description, const ElementsType& elements); ~RewriteRuleElementStream(); @@ -163,7 +159,7 @@ StringType getDescription(); protected: - void init(TreeAdaptorType* adaptor, RecognizerType* rec, ANTLR_UINT8* description); + void init(TreeAdaptorType* adaptor, ANTLR_UINT8* description); }; /// This is an implementation of a token stream, which is basically an element @@ -184,9 +180,9 @@ typedef typename ImplTraits::template RewriteRuleElementStreamType< typename ImplTraits::ParserType> BaseType; public: - RewriteRuleTokenStream(TreeAdaptorType* adaptor, RecognizerType* rec, ANTLR_UINT8* description); - RewriteRuleTokenStream(TreeAdaptorType* adaptor, RecognizerType* rec, ANTLR_UINT8* description, TokenType* oneElement); - RewriteRuleTokenStream(TreeAdaptorType* adaptor, RecognizerType* rec, ANTLR_UINT8* description, const ElementsType& elements); + RewriteRuleTokenStream(TreeAdaptorType* adaptor, ANTLR_UINT8* description); + RewriteRuleTokenStream(TreeAdaptorType* adaptor, ANTLR_UINT8* description, TokenType* oneElement); + RewriteRuleTokenStream(TreeAdaptorType* adaptor, ANTLR_UINT8* description, const ElementsType& elements); TreeType* nextNode(); private: @@ -211,9 +207,9 @@ typedef typename ImplTraits::template RewriteStreamType< typename ImplTraits::TreeParserType> BaseType; public: - RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, RecognizerType* rec, ANTLR_UINT8* description); - RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, RecognizerType* rec, ANTLR_UINT8* description, TokenType* oneElement); - RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, RecognizerType* rec, ANTLR_UINT8* description, const ElementsType& elements); + RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, ANTLR_UINT8* description); + RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, ANTLR_UINT8* description, TokenType* oneElement); + RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, ANTLR_UINT8* description, const ElementsType& elements); TreeType* dup( TreeType* el ); @@ -239,9 +235,9 @@ typedef typename ImplTraits::template RewriteRuleElementStreamType< typename ImplTraits::TreeParserType> BaseType; public: - RewriteRuleNodeStream(TreeAdaptorType* adaptor, RecognizerType* rec, ANTLR_UINT8* description); - RewriteRuleNodeStream(TreeAdaptorType* adaptor, RecognizerType* rec, ANTLR_UINT8* description, TokenType* oneElement); - RewriteRuleNodeStream(TreeAdaptorType* adaptor, RecognizerType* rec, ANTLR_UINT8* description, const ElementsType& elements); + RewriteRuleNodeStream(TreeAdaptorType* adaptor, ANTLR_UINT8* description); + RewriteRuleNodeStream(TreeAdaptorType* adaptor, ANTLR_UINT8* description, TokenType* oneElement); + RewriteRuleNodeStream(TreeAdaptorType* adaptor, ANTLR_UINT8* description, const ElementsType& elements); TreeType* toTree(TreeType* element); Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.inl 2013-04-30 12:54:26 UTC (rev 4636) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.inl 2013-05-05 22:04:22 UTC (rev 4637) @@ -1,34 +1,35 @@ ANTLR_BEGIN_NAMESPACE() template<class ImplTraits, class SuperType> -RewriteRuleElementStream<ImplTraits, SuperType>::RewriteRuleElementStream(TreeAdaptorType* adaptor, - RecognizerType* rec, ANTLR_UINT8* description) +RewriteRuleElementStream<ImplTraits, SuperType>::RewriteRuleElementStream(TreeAdaptorType* adaptor, + ANTLR_UINT8* description) { - this->init(adaptor, rec, description); + this->init(adaptor, description); } template<class ImplTraits, class SuperType> -RewriteRuleElementStream<ImplTraits, SuperType>::RewriteRuleElementStream(TreeAdaptorType* adaptor, - RecognizerType* rec, ANTLR_UINT8* description, TokenType* oneElement) +RewriteRuleElementStream<ImplTraits, SuperType>::RewriteRuleElementStream(TreeAdaptorType* adaptor, + ANTLR_UINT8* description, + TokenType* oneElement) { - this->init(adaptor, rec, description); + this->init(adaptor, description); if( oneElement != NULL ) this->add( oneElement ); } template<class ImplTraits, class SuperType> -RewriteRuleElementStream<ImplTraits, SuperType>::RewriteRuleElementStream(TreeAdaptorType* adaptor, - RecognizerType* rec, ANTLR_UINT8* description, const ElementsType& elements) - :m_elements(elements) +RewriteRuleElementStream<ImplTraits, SuperType>::RewriteRuleElementStream(TreeAdaptorType* adaptor, + ANTLR_UINT8* description, + const ElementsType& elements) + : m_elements(elements) { - this->init(adaptor, rec, description); + this->init(adaptor, escription); } template<class ImplTraits, class SuperType> -void RewriteRuleElementStream<ImplTraits, SuperType>::init(TreeAdaptorType* adaptor, - RecognizerType* rec, ANTLR_UINT8* description) +void RewriteRuleElementStream<ImplTraits, SuperType>::init(TreeAdaptorType* adaptor, + ANTLR_UINT8* description) { - m_rec = rec; m_adaptor = adaptor; m_cursor = 0; m_dirty = false; @@ -36,65 +37,71 @@ } template<class ImplTraits> -RewriteRuleTokenStream<ImplTraits>::RewriteRuleTokenStream(TreeAdaptorType* adaptor, - RecognizerType* rec, ANTLR_UINT8* description) - :BaseType(adaptor, rec, description) +RewriteRuleTokenStream<ImplTraits>::RewriteRuleTokenStream(TreeAdaptorType* adaptor, + ANTLR_UINT8* description) + : BaseType(adaptor, description) { } template<class ImplTraits> -RewriteRuleTokenStream<ImplTraits>::RewriteRuleTokenStream(TreeAdaptorType* adaptor, RecognizerType* rec, - ANTLR_UINT8* description, TokenType* oneElement) - :BaseType(adaptor, rec, description, oneElement) +RewriteRuleTokenStream<ImplTraits>::RewriteRuleTokenStream(TreeAdaptorType* adaptor, + ANTLR_UINT8* description, + TokenType* oneElement) + : BaseType(adaptor, description, oneElement) { } template<class ImplTraits> -RewriteRuleTokenStream<ImplTraits>::RewriteRuleTokenStream(TreeAdaptorType* adaptor, - RecognizerType* rec, ANTLR_UINT8* description, const ElementsType& elements) - :BaseType(adaptor, rec, description, elements) +RewriteRuleTokenStream<ImplTraits>::RewriteRuleTokenStream(TreeAdaptorType* adaptor, + ANTLR_UINT8* description, + const ElementsType& elements) + : BaseType(adaptor, description, elements) { } template<class ImplTraits> -RewriteRuleSubtreeStream<ImplTraits>::RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, - RecognizerType* rec, ANTLR_UINT8* description) - :BaseType(adaptor, rec, description) +RewriteRuleSubtreeStream<ImplTraits>::RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, + ANTLR_UINT8* description) + : BaseType(adaptor, description) { } template<class ImplTraits> -RewriteRuleSubtreeStream<ImplTraits>::RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, RecognizerType* rec, - ANTLR_UINT8* description, TokenType* oneElement) - :BaseType(adaptor, rec, description, oneElement) +RewriteRuleSubtreeStream<ImplTraits>::RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, + ANTLR_UINT8* description, + TokenType* oneElement) + : BaseType(adaptor, description, oneElement) { } template<class ImplTraits> -RewriteRuleSubtreeStream<ImplTraits>::RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, - RecognizerType* rec, ANTLR_UINT8* description, const ElementsType& elements) - :BaseType(adaptor, rec, description, elements) +RewriteRuleSubtreeStream<ImplTraits>::RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, + ANTLR_UINT8* description, + const ElementsType& elements) + : BaseType(adaptor, description, elements) { } template<class ImplTraits> -RewriteRuleNodeStream<ImplTraits>::RewriteRuleNodeStream(TreeAdaptorType* adaptor, - RecognizerType* rec, ANTLR_UINT8* description) - :BaseType(adaptor, rec, description) +RewriteRuleNodeStream<ImplTraits>::RewriteRuleNodeStream(TreeAdaptorType* adaptor, + ANTLR_UINT8* description) + : BaseType(adaptor, description) { } template<class ImplTraits> -RewriteRuleNodeStream<ImplTraits>::RewriteRuleNodeStream(TreeAdaptorType* adaptor, RecognizerType* rec, - ANTLR_UINT8* description, TokenType* oneElement) - :BaseType(adaptor, rec, description, oneElement) +RewriteRuleNodeStream<ImplTraits>::RewriteRuleNodeStream(TreeAdaptorType* adaptor, + ANTLR_UINT8* description, + TokenType* oneElement) + : BaseType(adaptor, description, oneElement) { } template<class ImplTraits> -RewriteRuleNodeStream<ImplTraits>::RewriteRuleNodeStream(TreeAdaptorType* adaptor, - RecognizerType* rec, ANTLR_UINT8* description, const ElementsType& elements) - :BaseType(adaptor, rec, description, elements) +RewriteRuleNodeStream<ImplTraits>::RewriteRuleNodeStream(TreeAdaptorType* adaptor, + ANTLR_UINT8* description, + const ElementsType& elements) + : BaseType(adaptor, description, elements) { } Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3traits.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3traits.hpp 2013-04-30 12:54:26 UTC (rev 4636) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3traits.hpp 2013-05-05 22:04:22 UTC (rev 4637) @@ -336,16 +336,16 @@ typedef typename BaseType::ElementsType ElementsType; public: - RewriteStreamType(TreeAdaptorType* adaptor = NULL, Recognizer_Type* rec = NULL, ANTLR_UINT8* description = NULL) - :BaseType(adaptor, rec, description) + RewriteStreamType(TreeAdaptorType* adaptor = NULL, ANTLR_UINT8* description = NULL) + :BaseType(adaptor, description) { } - RewriteStreamType(TreeAdaptorType* adaptor, Recognizer_Type* rec, ANTLR_UINT8* description, TokenType* oneElement) - :BaseType(adaptor, rec, description, oneElement) + RewriteStreamType(TreeAdaptorType* adaptor, ANTLR_UINT8* description, TokenType* oneElement) + :BaseType(adaptor, description, oneElement) { } - RewriteStreamType(TreeAdaptorType* adaptor, Recognizer_Type* rec, ANTLR_UINT8* description, const ElementsType& elements) - :BaseType(adaptor, rec, description, elements) + RewriteStreamType(TreeAdaptorType* adaptor, ANTLR_UINT8* description, const ElementsType& elements) + :BaseType(adaptor, description, elements) { } }; Modified: branches/tora3/extlibs/parsing.cpp/antlr-complete-3.5.1-SNAPSHOT.jar =================================================================== (Binary files differ) Modified: branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/AST.stg =================================================================== --- branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/AST.stg 2013-04-30 12:54:26 UTC (rev 4636) +++ branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/AST.stg 2013-05-05 22:04:22 UTC (rev 4637) @@ -228,7 +228,7 @@ separator="\n" > <referencedRuleLabels - :{it | RewriteRuleSubtreeStream\<ImplTraits> *stream_<it>=new RewriteRuleSubtreeStream\<ImplTraits>(this,"rule <it>",<it>!=NULL?<it>.getTree():NULL);}; + :{it | RewriteRuleSubtreeStream\<ImplTraits> *stream_<it>=new RewriteRuleSubtreeStream\<ImplTraits>(this,"rule <it>",<it>.getTree());}; separator="\n" > <referencedRuleListLabels This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <ibr...@us...> - 2013-05-05 22:56:39
|
Revision: 4638 http://sourceforge.net/p/tora/code/4638 Author: ibre5041 Date: 2013-05-05 22:56:36 +0000 (Sun, 05 May 2013) Log Message: ----------- ANTLR_UINT8* -> const char* Modified Paths: -------------- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3traits.hpp branches/tora3/extlibs/parsing.cpp/antlr-complete-3.5.1-SNAPSHOT.jar branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/AST.stg Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.hpp 2013-05-05 22:04:22 UTC (rev 4637) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.hpp 2013-05-05 22:56:36 UTC (rev 4638) @@ -99,9 +99,9 @@ bool m_dirty; public: - RewriteRuleElementStream(TreeAdaptorType* adaptor, ANTLR_UINT8* description); - RewriteRuleElementStream(TreeAdaptorType* adaptor, ANTLR_UINT8* description, TokenType* oneElement); - RewriteRuleElementStream(TreeAdaptorType* adaptor, ANTLR_UINT8* description, const ElementsType& elements); + RewriteRuleElementStream(TreeAdaptorType* adaptor, const char* description); + RewriteRuleElementStream(TreeAdaptorType* adaptor, const char* description, TokenType* oneElement); + RewriteRuleElementStream(TreeAdaptorType* adaptor, const char* description, const ElementsType& elements); ~RewriteRuleElementStream(); @@ -159,7 +159,7 @@ StringType getDescription(); protected: - void init(TreeAdaptorType* adaptor, ANTLR_UINT8* description); + void init(TreeAdaptorType* adaptor, const char* description); }; /// This is an implementation of a token stream, which is basically an element @@ -180,9 +180,9 @@ typedef typename ImplTraits::template RewriteRuleElementStreamType< typename ImplTraits::ParserType> BaseType; public: - RewriteRuleTokenStream(TreeAdaptorType* adaptor, ANTLR_UINT8* description); - RewriteRuleTokenStream(TreeAdaptorType* adaptor, ANTLR_UINT8* description, TokenType* oneElement); - RewriteRuleTokenStream(TreeAdaptorType* adaptor, ANTLR_UINT8* description, const ElementsType& elements); + RewriteRuleTokenStream(TreeAdaptorType* adaptor, const char* description); + RewriteRuleTokenStream(TreeAdaptorType* adaptor, const char* description, TokenType* oneElement); + RewriteRuleTokenStream(TreeAdaptorType* adaptor, const char* description, const ElementsType& elements); TreeType* nextNode(); private: @@ -207,9 +207,9 @@ typedef typename ImplTraits::template RewriteStreamType< typename ImplTraits::TreeParserType> BaseType; public: - RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, ANTLR_UINT8* description); - RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, ANTLR_UINT8* description, TokenType* oneElement); - RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, ANTLR_UINT8* description, const ElementsType& elements); + RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, const char* description); + RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, const char* description, TokenType* oneElement); + RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, const char* description, const ElementsType& elements); TreeType* dup( TreeType* el ); @@ -235,9 +235,9 @@ typedef typename ImplTraits::template RewriteRuleElementStreamType< typename ImplTraits::TreeParserType> BaseType; public: - RewriteRuleNodeStream(TreeAdaptorType* adaptor, ANTLR_UINT8* description); - RewriteRuleNodeStream(TreeAdaptorType* adaptor, ANTLR_UINT8* description, TokenType* oneElement); - RewriteRuleNodeStream(TreeAdaptorType* adaptor, ANTLR_UINT8* description, const ElementsType& elements); + RewriteRuleNodeStream(TreeAdaptorType* adaptor, const char* description); + RewriteRuleNodeStream(TreeAdaptorType* adaptor, const char* description, TokenType* oneElement); + RewriteRuleNodeStream(TreeAdaptorType* adaptor, const char* description, const ElementsType& elements); TreeType* toTree(TreeType* element); Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.inl 2013-05-05 22:04:22 UTC (rev 4637) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.inl 2013-05-05 22:56:36 UTC (rev 4638) @@ -2,14 +2,14 @@ template<class ImplTraits, class SuperType> RewriteRuleElementStream<ImplTraits, SuperType>::RewriteRuleElementStream(TreeAdaptorType* adaptor, - ANTLR_UINT8* description) + const char* description) { this->init(adaptor, description); } template<class ImplTraits, class SuperType> RewriteRuleElementStream<ImplTraits, SuperType>::RewriteRuleElementStream(TreeAdaptorType* adaptor, - ANTLR_UINT8* description, + const char* description, TokenType* oneElement) { this->init(adaptor, description); @@ -19,7 +19,7 @@ template<class ImplTraits, class SuperType> RewriteRuleElementStream<ImplTraits, SuperType>::RewriteRuleElementStream(TreeAdaptorType* adaptor, - ANTLR_UINT8* description, + const char* description, const ElementsType& elements) : m_elements(elements) { @@ -28,7 +28,7 @@ template<class ImplTraits, class SuperType> void RewriteRuleElementStream<ImplTraits, SuperType>::init(TreeAdaptorType* adaptor, - ANTLR_UINT8* description) + const char* description) { m_adaptor = adaptor; m_cursor = 0; @@ -38,14 +38,14 @@ template<class ImplTraits> RewriteRuleTokenStream<ImplTraits>::RewriteRuleTokenStream(TreeAdaptorType* adaptor, - ANTLR_UINT8* description) + const char* description) : BaseType(adaptor, description) { } template<class ImplTraits> RewriteRuleTokenStream<ImplTraits>::RewriteRuleTokenStream(TreeAdaptorType* adaptor, - ANTLR_UINT8* description, + const char* description, TokenType* oneElement) : BaseType(adaptor, description, oneElement) { @@ -53,7 +53,7 @@ template<class ImplTraits> RewriteRuleTokenStream<ImplTraits>::RewriteRuleTokenStream(TreeAdaptorType* adaptor, - ANTLR_UINT8* description, + const char* description, const ElementsType& elements) : BaseType(adaptor, description, elements) { @@ -61,14 +61,14 @@ template<class ImplTraits> RewriteRuleSubtreeStream<ImplTraits>::RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, - ANTLR_UINT8* description) + const char* description) : BaseType(adaptor, description) { } template<class ImplTraits> RewriteRuleSubtreeStream<ImplTraits>::RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, - ANTLR_UINT8* description, + const char* description, TokenType* oneElement) : BaseType(adaptor, description, oneElement) { @@ -76,7 +76,7 @@ template<class ImplTraits> RewriteRuleSubtreeStream<ImplTraits>::RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, - ANTLR_UINT8* description, + const char* description, const ElementsType& elements) : BaseType(adaptor, description, elements) { @@ -84,14 +84,14 @@ template<class ImplTraits> RewriteRuleNodeStream<ImplTraits>::RewriteRuleNodeStream(TreeAdaptorType* adaptor, - ANTLR_UINT8* description) + const char* description) : BaseType(adaptor, description) { } template<class ImplTraits> RewriteRuleNodeStream<ImplTraits>::RewriteRuleNodeStream(TreeAdaptorType* adaptor, - ANTLR_UINT8* description, + const char* description, TokenType* oneElement) : BaseType(adaptor, description, oneElement) { @@ -99,7 +99,7 @@ template<class ImplTraits> RewriteRuleNodeStream<ImplTraits>::RewriteRuleNodeStream(TreeAdaptorType* adaptor, - ANTLR_UINT8* description, + const char* description, const ElementsType& elements) : BaseType(adaptor, description, elements) { Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3traits.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3traits.hpp 2013-05-05 22:04:22 UTC (rev 4637) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3traits.hpp 2013-05-05 22:56:36 UTC (rev 4638) @@ -336,15 +336,15 @@ typedef typename BaseType::ElementsType ElementsType; public: - RewriteStreamType(TreeAdaptorType* adaptor = NULL, ANTLR_UINT8* description = NULL) + RewriteStreamType(TreeAdaptorType* adaptor = NULL, const char* description = NULL) :BaseType(adaptor, description) { } - RewriteStreamType(TreeAdaptorType* adaptor, ANTLR_UINT8* description, TokenType* oneElement) + RewriteStreamType(TreeAdaptorType* adaptor, const char* description, TokenType* oneElement) :BaseType(adaptor, description, oneElement) { } - RewriteStreamType(TreeAdaptorType* adaptor, ANTLR_UINT8* description, const ElementsType& elements) + RewriteStreamType(TreeAdaptorType* adaptor, const char* description, const ElementsType& elements) :BaseType(adaptor, description, elements) { } Modified: branches/tora3/extlibs/parsing.cpp/antlr-complete-3.5.1-SNAPSHOT.jar =================================================================== (Binary files differ) Modified: branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/AST.stg =================================================================== --- branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/AST.stg 2013-05-05 22:04:22 UTC (rev 4637) +++ branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/AST.stg 2013-05-05 22:56:36 UTC (rev 4638) @@ -112,7 +112,7 @@ /** ID and track it for use in a rewrite rule */ tokenRefTrack(token,label,elementIndex,terminalOptions={}) ::= << <tokenRefBang(...)> <! Track implies no auto AST construction!> -<if(backtracking)>if ( <actions.(actionScope).synpredgate> ) <endif>stream_<token>.add(<label>);<\n> +<if(backtracking)>if ( <actions.(actionScope).synpredgate> ) <endif>stream_<token>->add(<label>);<\n> >> /** ids+=ID and track it for use in a rewrite rule; adds to ids *and* @@ -126,7 +126,7 @@ /** ^(ID ...) track for rewrite */ tokenRefRuleRootTrack(token,label,elementIndex,terminalOptions={}) ::= << <tokenRefBang(...)> -<if(backtracking)>if ( <actions.(actionScope).synpredgate> ) <endif>stream_<token>.add(<label>);<\n> +<if(backtracking)>if ( <actions.(actionScope).synpredgate> ) <endif>stream_<token>->add(<label>);<\n> >> /** Match ^(label+=TOKEN ...) track for rewrite */ @@ -138,7 +138,7 @@ /** rule when output=AST and tracking for rewrite */ ruleRefTrack(rule,label,elementIndex,args,scope) ::= << <super.ruleRef(...)> -<if(backtracking)>if ( <actions.(actionScope).synpredgate> ) <endif>stream_<rule.name>.add(<label>.getTree()); +<if(backtracking)>if ( <actions.(actionScope).synpredgate> ) <endif>stream_<rule.name>->add(<label>.getTree()); >> /** x+=rule when output=AST and tracking for rewrite */ @@ -150,7 +150,7 @@ /** ^(rule ...) rewrite */ ruleRefRuleRootTrack(rule,label,elementIndex,args,scope) ::= << <ruleRefRuleRoot(...)> -<if(backtracking)>if ( <actions.(actionScope).synpredgate> ) <endif>stream_<rule>.add(<label>.getTree()); +<if(backtracking)>if ( <actions.(actionScope).synpredgate> ) <endif>stream_<rule>->add(<label>.getTree()); >> /** ^(x+=rule ...) rewrite */ @@ -363,7 +363,7 @@ prevRuleRootRef() ::= "retval" rewriteRuleRef(rule) ::= << -TreeAdaptorType::addChild(root_<treeLevel>, stream_<rule>.nextTree()); +TreeAdaptorType::addChild(root_<treeLevel>, stream_<rule>->nextTree()); >> rewriteRuleRefRoot(rule) ::= << @@ -380,12 +380,12 @@ /** Gen $ruleLabel ... where defined via ruleLabel=rule */ rewriteRuleLabelRef(label) ::= << -TreeAdaptorType::addChild(root_<treeLevel>, stream_<label>.nextTree()); +TreeAdaptorType::addChild(root_<treeLevel>, stream_<label>->nextTree()); >> /** Gen $ruleLabel ... where defined via ruleLabel+=rule */ rewriteRuleListLabelRef(label) ::= << -TreeAdaptorType::addChild(root_<treeLevel>, stream_<label>.nextTree()); +TreeAdaptorType::addChild(root_<treeLevel>, stream_<label>->nextTree()); >> /** Gen ^($ruleLabel ...) where ruleLabel=rule */ @@ -399,7 +399,7 @@ >> rewriteWildcardLabelRef(label) ::= << -TreeAdaptorType::addChild(root_<treeLevel>, stream_<label>.nextTree()); +TreeAdaptorType::addChild(root_<treeLevel>, stream_<label>->nextTree()); >> @@ -408,7 +408,7 @@ <! new MethodNode(IDLabel, args) !> new <terminalOptions.node>(<tokenType><if(args)>, <args; separator=", "><endif>) <else> -(<ASTLabelType>)TreeAdaptorType::create(<tokenType>, <args; separator=", "><if(!args)>"<tokenType>"<endif>) +(<ASTLabelType>)TreeAdaptorType::createTypeText(<tokenType>, <args; separator=", "><if(!args)>"<tokenType>"<endif>) <endif> %> This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <ibr...@us...> - 2013-05-15 12:49:27
|
Revision: 4643 http://sourceforge.net/p/tora/code/4643 Author: ibre5041 Date: 2013-05-15 12:49:24 +0000 (Wed, 15 May 2013) Log Message: ----------- - const removed from many places - simply AST tree containers use Token* or Tree* - RewriteRuleNodeStream commented out ATM - rule return datatype assignment fix Modified Paths: -------------- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3parser.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3parser.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3tokenstream.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3tokenstream.inl branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/AST.stg branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/Cpp.stg Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.hpp 2013-05-15 10:32:11 UTC (rev 4642) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.hpp 2013-05-15 12:49:24 UTC (rev 4643) @@ -98,7 +98,7 @@ /// rule. Rule would recover by resynchronizing to the set of /// symbols that can follow rule ref. /// - const UnitType* match(ANTLR_UINT32 ttype, BitsetListType* follow); + UnitType* match(ANTLR_UINT32 ttype, BitsetListType* follow); /// Consumes the next token, whatever it is, and resets the recognizer state /// so that it is not in error. @@ -379,12 +379,12 @@ /// sorted in the recognizer exception stack in the C version. To 'throw' it we set the /// error flag and rules cascade back when this is set. /// - const UnitType* recoverFromMismatchedToken( ANTLR_UINT32 ttype, BitsetListType* follow); + UnitType* recoverFromMismatchedToken( ANTLR_UINT32 ttype, BitsetListType* follow); /** Function that recovers from a mismatched set in the token stream, in a similar manner * to (*recoverFromMismatchedToken) */ - const UnitType* recoverFromMismatchedSet(BitsetListType* follow); + UnitType* recoverFromMismatchedSet(BitsetListType* follow); /** common routine to handle single token insertion for recovery functions. */ @@ -449,10 +449,10 @@ /// This is ignored for lexers and the lexer implementation of this /// function should return NULL. /// - const UnitType* getCurrentInputSymbol(IntStreamType* istream); - const UnitType* getCurrentInputSymbol(IntStreamType* istream, ClassForwarder<LexerType>); - const UnitType* getCurrentInputSymbol(IntStreamType* istream, ClassForwarder<ParserType>); - const UnitType* getCurrentInputSymbol(IntStreamType* istream, ClassForwarder<TreeParserType>); + UnitType* getCurrentInputSymbol(IntStreamType* istream); + UnitType* getCurrentInputSymbol(IntStreamType* istream, ClassForwarder<LexerType>); + UnitType* getCurrentInputSymbol(IntStreamType* istream, ClassForwarder<ParserType>); + UnitType* getCurrentInputSymbol(IntStreamType* istream, ClassForwarder<TreeParserType>); /// Conjure up a missing token during error recovery. /// Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.inl 2013-05-15 10:32:11 UTC (rev 4642) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.inl 2013-05-15 12:49:24 UTC (rev 4643) @@ -52,7 +52,7 @@ } template< class ImplTraits, class StreamType > -const typename BaseRecognizer<ImplTraits, StreamType>::UnitType* +typename BaseRecognizer<ImplTraits, StreamType>::UnitType* BaseRecognizer<ImplTraits, StreamType>::match(ANTLR_UINT32 ttype, BitsetListType* follow) { SuperType* super = static_cast<SuperType*>(this); @@ -60,7 +60,7 @@ // Pick up the current input token/node for assignment to labels // - const UnitType* matchedSymbol = this->getCurrentInputSymbol(is); + UnitType* matchedSymbol = this->getCurrentInputSymbol(is); if (is->_LA(1) == ttype) { @@ -414,12 +414,12 @@ } template< class ImplTraits, class StreamType > -const typename BaseRecognizer<ImplTraits, StreamType>::UnitType* +typename BaseRecognizer<ImplTraits, StreamType>::UnitType* BaseRecognizer<ImplTraits, StreamType>::recoverFromMismatchedToken( ANTLR_UINT32 ttype, BitsetListType* follow) { SuperType* super = static_cast<SuperType*>(this); IntStreamType* is = super->get_parser_istream(); - const UnitType* matchedSymbol; + UnitType* matchedSymbol; // If the next token after the one we are looking at in the input stream // is what we are looking for then we remove the one we have discovered @@ -505,12 +505,12 @@ } template< class ImplTraits, class StreamType > -const typename BaseRecognizer<ImplTraits, StreamType>::UnitType* +typename BaseRecognizer<ImplTraits, StreamType>::UnitType* BaseRecognizer<ImplTraits, StreamType>::recoverFromMismatchedSet(BitsetListType* follow) { SuperType* super = static_cast<SuperType*>(this); IntStreamType* is = super->get_parser_istream(); - const UnitType* matchedSymbol; + UnitType* matchedSymbol; if (this->mismatchIsMissingToken(is, follow) == true) { @@ -754,21 +754,21 @@ } template< class ImplTraits, class StreamType > -const typename BaseRecognizer<ImplTraits, StreamType>::UnitType* +typename BaseRecognizer<ImplTraits, StreamType>::UnitType* BaseRecognizer<ImplTraits, StreamType>::getCurrentInputSymbol( IntStreamType* istream ) { return this->getCurrentInputSymbol( istream, ClassForwarder<SuperType>() ); } template< class ImplTraits, class StreamType > -const typename BaseRecognizer<ImplTraits, StreamType>::UnitType* +typename BaseRecognizer<ImplTraits, StreamType>::UnitType* BaseRecognizer<ImplTraits, StreamType>::getCurrentInputSymbol(IntStreamType* istream, ClassForwarder<LexerType>) { return NULL; } template< class ImplTraits, class StreamType > -const typename BaseRecognizer<ImplTraits, StreamType>::UnitType* +typename BaseRecognizer<ImplTraits, StreamType>::UnitType* BaseRecognizer<ImplTraits, StreamType>::getCurrentInputSymbol(IntStreamType* istream, ClassForwarder<ParserType>) { typedef typename ImplTraits::TokenStreamType TokenStreamType; @@ -777,7 +777,7 @@ } template< class ImplTraits, class StreamType > -const typename BaseRecognizer<ImplTraits, StreamType>::UnitType* +typename BaseRecognizer<ImplTraits, StreamType>::UnitType* BaseRecognizer<ImplTraits, StreamType>::getCurrentInputSymbol(IntStreamType* istream, ClassForwarder<TreeParserType>) { typedef typename ImplTraits::TreeNodeStreamType TreeNodeStreamType; Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.hpp 2013-05-15 10:32:11 UTC (rev 4642) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.hpp 2013-05-15 12:49:24 UTC (rev 4643) @@ -70,7 +70,7 @@ /// A single token, this is the payload for the tree /// - const CommonTokenType* m_token; + CommonTokenType* m_token; /// Points to the node that has this node as a child. /// If this is NULL, then this is the root node. @@ -84,11 +84,11 @@ public: CommonTree(); - CommonTree( const CommonTokenType* token ); - CommonTree( const CommonTree* token ); - CommonTree( const CommonTree& ctree ); + CommonTree( CommonTokenType* token ); + CommonTree( CommonTree* token ); + CommonTree( CommonTree& ctree ); - const CommonTokenType* getToken() const; + CommonTokenType* getToken() const; void setToken(CommonTokenType*); ChildrenType& getChildren(); @@ -118,7 +118,7 @@ /// children to set their child index; could be slow. /// void replaceChildren(ANTLR_INT32 startChildIndex, ANTLR_INT32 stopChildIndex, TreeType* t); - CommonTree* dupNode() const; + CommonTree* dupNode(); TreeType* dupTree(); ANTLR_UINT32 getCharPositionInLine(); TreeType* getChild(ANTLR_UINT32 i); Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.inl 2013-05-15 10:32:11 UTC (rev 4642) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.inl 2013-05-15 12:49:24 UTC (rev 4643) @@ -12,7 +12,7 @@ } template<class ImplTraits> -CommonTree<ImplTraits>::CommonTree( const CommonTree& ctree ) +CommonTree<ImplTraits>::CommonTree( CommonTree& ctree ) :m_children( ctree.m_children) { m_savedIndex = ctree.m_savedIndex; @@ -24,7 +24,7 @@ } template<class ImplTraits> -CommonTree<ImplTraits>::CommonTree( const CommonTokenType* token ) +CommonTree<ImplTraits>::CommonTree( CommonTokenType* token ) { m_savedIndex = 0; m_startIndex = 0; @@ -35,7 +35,7 @@ } template<class ImplTraits> -CommonTree<ImplTraits>::CommonTree( const CommonTree* tree ) +CommonTree<ImplTraits>::CommonTree( CommonTree* tree ) { m_savedIndex = 0; m_startIndex = 0; @@ -46,7 +46,7 @@ } template<class ImplTraits> -const typename CommonTree<ImplTraits>::CommonTokenType* CommonTree<ImplTraits>::getToken() const +typename CommonTree<ImplTraits>::CommonTokenType* CommonTree<ImplTraits>::getToken() const { return m_token; } @@ -280,7 +280,7 @@ } template<class ImplTraits> -CommonTree<ImplTraits>* CommonTree<ImplTraits>::dupNode() const +CommonTree<ImplTraits>* CommonTree<ImplTraits>::dupNode() { // The node we are duplicating is in fact the common tree (that's why we are here) // so we use the super pointer to duplicate. Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.hpp 2013-05-15 10:32:11 UTC (rev 4642) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.hpp 2013-05-15 12:49:24 UTC (rev 4643) @@ -67,7 +67,7 @@ TreeType* becomeRootToken(CommonTokenType* newRoot, TreeType* oldRoot); - TreeType* create(const CommonTokenType* payload); + TreeType* create( CommonTokenType* payload); TreeType* createTypeToken( ANTLR_UINT32 tokenType, CommonTokenType* fromToken); TreeType* createTypeTokenText ( ANTLR_UINT32 tokenType, CommonTokenType* fromToken, const char* text); TreeType* createTypeText ( ANTLR_UINT32 tokenType, const char* text); Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.inl 2013-05-15 10:32:11 UTC (rev 4642) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.inl 2013-05-15 12:49:24 UTC (rev 4643) @@ -171,13 +171,13 @@ } template<class ImplTraits> -typename CommonTreeAdaptor<ImplTraits>::TreeType* CommonTreeAdaptor<ImplTraits>::becomeRootToken(CommonTokenType* newRoot, TreeType* oldRoot) +typename CommonTreeAdaptor<ImplTraits>::TreeType* CommonTreeAdaptor<ImplTraits>::becomeRootToken( CommonTokenType* newRoot, TreeType* oldRoot) { return this->becomeRoot(this->create(newRoot), oldRoot); } template<class ImplTraits> -typename CommonTreeAdaptor<ImplTraits>::TreeType* CommonTreeAdaptor<ImplTraits>::create(const CommonTokenType* payload) +typename CommonTreeAdaptor<ImplTraits>::TreeType* CommonTreeAdaptor<ImplTraits>::create( CommonTokenType* payload) { return new TreeType(payload); } Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3parser.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3parser.hpp 2013-05-15 10:32:11 UTC (rev 4642) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3parser.hpp 2013-05-15 12:49:24 UTC (rev 4643) @@ -121,7 +121,7 @@ ANTLR_MARKER index() const; bool hasException() const; ExceptionBaseType* getException() const; - const CommonTokenType* matchToken( ANTLR_UINT32 ttype, BitsetListType* follow ); + CommonTokenType* matchToken( ANTLR_UINT32 ttype, BitsetListType* follow ); void matchAnyToken(); const FollowingType& get_follow_stack() const; void followPush( const BitsetListType& follow ); Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3parser.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3parser.inl 2013-05-15 10:32:11 UTC (rev 4642) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3parser.inl 2013-05-15 12:49:24 UTC (rev 4643) @@ -320,7 +320,7 @@ } template< class ImplTraits> -ANTLR_INLINE const typename Parser<ImplTraits>::CommonTokenType* Parser<ImplTraits>::matchToken( ANTLR_UINT32 ttype, BitsetListType* follow ) +ANTLR_INLINE typename Parser<ImplTraits>::CommonTokenType* Parser<ImplTraits>::matchToken( ANTLR_UINT32 ttype, BitsetListType* follow ) { return this->get_rec()->match( ttype, follow ); } Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.hpp 2013-05-15 10:32:11 UTC (rev 4642) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.hpp 2013-05-15 12:49:24 UTC (rev 4643) @@ -169,7 +169,7 @@ /// template<class ImplTraits> //class RewriteRuleTokenStream : public ImplTraits::template RewriteRuleElementStreamType< typename ImplTraits::ParserType> -class RewriteRuleTokenStream : public ImplTraits::template RewriteRuleElementStreamType< typename ImplTraits::CommonTokenType > +class RewriteRuleTokenStream : public ImplTraits::template RewriteStreamType< typename ImplTraits::CommonTokenType > { public: typedef typename ImplTraits::AllocPolicyType AllocPolicyType; @@ -180,7 +180,7 @@ typedef typename ImplTraits::TreeType TreeType; typedef typename AllocPolicyType::template VectorType< TokenType* > ElementsType; typedef typename ImplTraits::template RecognizerType< StreamType > RecognizerType; - typedef typename ImplTraits::template RewriteRuleElementStreamType< typename ImplTraits::CommonTokenType > BaseType; + typedef typename ImplTraits::template RewriteStreamType< typename ImplTraits::CommonTokenType > BaseType; public: RewriteRuleTokenStream(TreeAdaptorType* adaptor, const char* description); @@ -237,12 +237,16 @@ * dup { throw } * toTree(Object e) { return adaptor.dupNode } * See: RewriteRuleElementStream::dup, RewriteRuleElementStream::dupImpl + * + * There should 3 types of specializations for RewriteRuleElementStreamType (which is not defined yet) + * ATM: RewriteRuleElementStreamType is replaced with ImplTraits::template RewriteStreamType + * /// This is an implementation of a node stream, which is basically an element /// stream that deals with tree nodes only. /// template<class ImplTraits> -//class RewriteRuleNodeStream : public ImplTraits::template RewriteRuleElementStreamType< typename ImplTraits::TreeParserType> -class RewriteRuleNodeStream : public ImplTraits::template RewriteRuleElementStreamType< typename ImplTraits::TreeType > +//class RewriteRuleNodeStream : public ImplTraits::template RewriteStreamType< typename ImplTraits::TreeParserType> +class RewriteRuleNodeStream : public ImplTraits::template RewriteStreamType< typename ImplTraits::TreeType > { public: typedef typename ImplTraits::AllocPolicyType AllocPolicyType; Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.inl 2013-05-15 10:32:11 UTC (rev 4642) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.inl 2013-05-15 12:49:24 UTC (rev 4643) @@ -46,7 +46,7 @@ for (i = 1; i<= m_elements.size(); i++) { ElementType *tree = m_elements.at(i-1); - if ( (tree != NULL) && tree->isNilNode() ) + //if ( (tree != NULL) && tree->isNilNode() ) { // Had to remove this for now, check is not comprehensive enough // tree->reuse(tree); @@ -59,7 +59,7 @@ if (m_singleElement != NULL) { ElementType *tree = m_singleElement; - if (tree->isNilNode()) + //if (tree->isNilNode()) { // Had to remove this for now, check is not comprehensive enough // tree->reuse(tree); Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3tokenstream.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3tokenstream.hpp 2013-05-15 10:32:11 UTC (rev 4642) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3tokenstream.hpp 2013-05-15 12:49:24 UTC (rev 4643) @@ -174,7 +174,7 @@ * Return null for LT(0) and any index that results in an absolute address * that is negative. */ - const TokenType* _LT(ANTLR_INT32 k); + TokenType* _LT(ANTLR_INT32 k); /** 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. @@ -339,10 +339,10 @@ * I believe DebugTokenStream can easily be altered to not use * this method, removing the dependency. */ - const TokenType* get(ANTLR_MARKER i); - const TokenType* getToken(ANTLR_MARKER i); - const TokenType* getToken( ANTLR_MARKER tok_idx, BoolForwarder<true> tokens_accessed_from_owning_rule ); - const TokenType* getToken( ANTLR_MARKER tok_idx, BoolForwarder<false> tokens_accessed_from_owning_rule ); + TokenType* get(ANTLR_MARKER i); + TokenType* getToken(ANTLR_MARKER i); + TokenType* getToken( ANTLR_MARKER tok_idx, BoolForwarder<true> tokens_accessed_from_owning_rule ); + TokenType* getToken( ANTLR_MARKER tok_idx, BoolForwarder<false> tokens_accessed_from_owning_rule ); /** Signal to discard off channel tokens from here on in. */ @@ -379,7 +379,7 @@ */ void reset(); - const TokenType* LB(ANTLR_INT32 k); + TokenType* LB(ANTLR_INT32 k); void fillBufferExt(); Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3tokenstream.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3tokenstream.inl 2013-05-15 10:32:11 UTC (rev 4642) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3tokenstream.inl 2013-05-15 12:49:24 UTC (rev 4643) @@ -387,7 +387,7 @@ } template<class ImplTraits> -const typename TokenStream<ImplTraits>::TokenType* TokenStream<ImplTraits>::_LT(ANTLR_INT32 k) +typename TokenStream<ImplTraits>::TokenType* TokenStream<ImplTraits>::_LT(ANTLR_INT32 k) { ANTLR_INT32 i; ANTLR_INT32 n; @@ -457,7 +457,7 @@ } template<class ImplTraits> -const typename CommonTokenStream<ImplTraits>::TokenType* CommonTokenStream<ImplTraits>::LB(ANTLR_INT32 k) +typename CommonTokenStream<ImplTraits>::TokenType* CommonTokenStream<ImplTraits>::LB(ANTLR_INT32 k) { ANTLR_INT32 i; ANTLR_INT32 n; @@ -501,21 +501,21 @@ } template<class ImplTraits> -const typename CommonTokenStream<ImplTraits>::TokenType* CommonTokenStream<ImplTraits>::getToken(ANTLR_MARKER i) +typename CommonTokenStream<ImplTraits>::TokenType* CommonTokenStream<ImplTraits>::getToken(ANTLR_MARKER i) { return this->get(i); } template<class ImplTraits> -const typename CommonTokenStream<ImplTraits>::TokenType* CommonTokenStream<ImplTraits>::get(ANTLR_MARKER i) +typename CommonTokenStream<ImplTraits>::TokenType* CommonTokenStream<ImplTraits>::get(ANTLR_MARKER i) { return this->getToken( static_cast<ANTLR_MARKER>(i), BoolForwarder<ImplTraits::TOKENS_ACCESSED_FROM_OWNING_RULE>() ); } template<class ImplTraits> -const typename CommonTokenStream<ImplTraits>::TokenType* CommonTokenStream<ImplTraits>::getToken( ANTLR_MARKER tok_idx, +typename CommonTokenStream<ImplTraits>::TokenType* CommonTokenStream<ImplTraits>::getToken( ANTLR_MARKER tok_idx, BoolForwarder<true> /*tokens_accessed_from_owning_rule*/ ) { typename TokensType::iterator iter = m_tokens.find(tok_idx); @@ -529,7 +529,7 @@ } template<class ImplTraits> -const typename CommonTokenStream<ImplTraits>::TokenType* CommonTokenStream<ImplTraits>::getToken( ANTLR_MARKER tok_idx, BoolForwarder<false> /*tokens_accessed_from_owning_rule*/ ) +typename CommonTokenStream<ImplTraits>::TokenType* CommonTokenStream<ImplTraits>::getToken( ANTLR_MARKER tok_idx, BoolForwarder<false> /*tokens_accessed_from_owning_rule*/ ) { TokenType& tok = m_tokens.at( static_cast<ANTLR_UINT32>(tok_idx) ); return &tok; Modified: branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/AST.stg =================================================================== --- branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/AST.stg 2013-05-15 10:32:11 UTC (rev 4642) +++ branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/AST.stg 2013-05-15 12:49:24 UTC (rev 4643) @@ -59,12 +59,16 @@ @returnScope.ruleReturnMembers() ::= << <super.ASTLabelType()> tree; <super.ASTLabelType()> getTree() { return tree; } -void init () -{ - tree = NULL; -} >> +ruleReturnMembersInit(value, prefix) ::= <% +<if(!prefix)> +tree = <value>; +<else> +tree = <prefix>.tree; +<endif> +%> + /** Add a variable to track rule's return AST */ ruleDeclarations() ::= << <super.ruleDeclarations()> Modified: branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/Cpp.stg =================================================================== --- branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/Cpp.stg 2013-05-15 10:32:11 UTC (rev 4642) +++ branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/Cpp.stg 2013-05-15 12:49:24 UTC (rev 4643) @@ -1035,7 +1035,7 @@ bitsets, ASTLabelType, superClass="Parser", - labelType="const CommonTokenType*", + labelType="ImplTraits::CommonTokenType*", members={<actions.parser.members>} ) ::= << <beginNamespace(actions)> @@ -2383,20 +2383,22 @@ <@ruleReturnMembers()> <ruleDescriptor.returnScope.attributes:{it |<it.type> <it.name>;}; separator="\n"> <if(!TREE_PARSER)> - <ruleDescriptor:returnStructName()>() { init(); } - <ruleDescriptor:returnStructName()>( BaseParserType* parser ) : BaseType(parser) { init(); } - <ruleDescriptor:returnStructName()>( const <ruleDescriptor:returnStructName()>& n ) - : BaseType(n) + <ruleDescriptor:returnStructName()>() : BaseType() { <ruleReturnMembersInit("NULL")> } + <ruleDescriptor:returnStructName()>( BaseParserType* parser ) : BaseType(parser) { <ruleReturnMembersInit("NULL")> } + <ruleDescriptor:returnStructName()>( const <ruleDescriptor:returnStructName()>& n ) : BaseType(n) <if(ruleDescriptor.returnScope.attributes)> , <ruleDescriptor.returnScope.attributes:{it | <it.name>(n.<it.name>) }; separator=","> <endif> - { init(); } + { + <ruleReturnMembersInit("n","n")> + } <ruleDescriptor:returnStructName()>& operator=( const <ruleDescriptor:returnStructName()>& n ) { BaseType::operator=( n ); <ruleDescriptor.returnScope.attributes:{it | <it.name> = n.<it.name>; }; separator="\n"> + <ruleReturnMembersInit("n","n")> return *this; } <else> This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <ibr...@us...> - 2013-05-15 20:25:05
|
Revision: 4644 http://sourceforge.net/p/tora/code/4644 Author: ibre5041 Date: 2013-05-15 20:25:01 +0000 (Wed, 15 May 2013) Log Message: ----------- 1st "functional" AST generation Modified Paths: -------------- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.inl branches/tora3/extlibs/parsing.cpp/SQLMini.g branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/AST.stg branches/tora3/extlibs/parsing.cpp/s0.cpp Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.inl 2013-05-15 12:49:24 UTC (rev 4643) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.inl 2013-05-15 20:25:01 UTC (rev 4644) @@ -510,7 +510,7 @@ string.append(this->toString()); string.append(" "); } - if ( m_children != NULL) + if ( !m_children.empty()) { n = m_children.size(); Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.inl 2013-05-15 12:49:24 UTC (rev 4643) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.inl 2013-05-15 20:25:01 UTC (rev 4644) @@ -301,6 +301,13 @@ } template<class ImplTraits> +typename RewriteRuleTokenStream<ImplTraits>::TreeType* +RewriteRuleTokenStream<ImplTraits>::nextNodeToken() +{ + return BaseType::m_adaptor->create(this->_next()); +} + +template<class ImplTraits> RewriteRuleSubtreeStream<ImplTraits>::RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, const char* description) : BaseType(adaptor, description) @@ -354,13 +361,6 @@ } template<class ImplTraits> -typename RewriteRuleTokenStream<ImplTraits>::TreeType* -RewriteRuleTokenStream<ImplTraits>::nextNodeToken() -{ - return BaseType::m_adaptor->create(this->_next()); -} - -template<class ImplTraits> RewriteRuleNodeStream<ImplTraits>::RewriteRuleNodeStream(TreeAdaptorType* adaptor, const char* description) : BaseType(adaptor, description) Modified: branches/tora3/extlibs/parsing.cpp/SQLMini.g =================================================================== --- branches/tora3/extlibs/parsing.cpp/SQLMini.g 2013-05-15 12:49:24 UTC (rev 4643) +++ branches/tora3/extlibs/parsing.cpp/SQLMini.g 2013-05-15 20:25:01 UTC (rev 4644) @@ -50,7 +50,7 @@ start_rule : ( - for_update_clause + subquery ) (SEMI|EOF) ; @@ -74,7 +74,7 @@ ( fu1=for_update_clause )? // ( order_by_clause )? ( fu2=for_update_clause )? - ) //-> ^(T_SUBQUERY subquery $fu1 $fu2) + ) -> ^(T_SUBQUERY subquery $fu1 $fu2) ; identifier[int identifierClass, int usageType] : i=ID //{ $i->user1 = identifierClass; $i->user2 = usageType; } @@ -94,7 +94,7 @@ ================================================================================ */ for_update_clause : r_for r_update ( r_of for_update_clause_part_first for_update_clause_part_next* )? (r_nowait | k_wait NUMBER | k_skip k_locked)? - //-> ^(T_FOR_UPDATE_CLAUSE r_for r_update r_of? for_update_clause_part_first? for_update_clause_part_next* r_nowait? k_wait? NUMBER? k_skip? k_locked?) + -> ^(T_FOR_UPDATE_CLAUSE r_for r_update r_of? for_update_clause_part_first? for_update_clause_part_next* r_nowait? k_wait? NUMBER? k_skip? k_locked?) ; for_update_clause_part_first : (schema_name DOT)? (table_name DOT)? column_name Modified: branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/AST.stg =================================================================== --- branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/AST.stg 2013-05-15 12:49:24 UTC (rev 4643) +++ branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/AST.stg 2013-05-15 20:25:01 UTC (rev 4644) @@ -251,10 +251,10 @@ description) ::= << // <fileName>:<description> -if ( <referencedElementsDeep:{el | stream_<el>.hasNext()}; separator="||"> ) { +if ( <referencedElementsDeep:{el | stream_<el>->hasNext()}; separator="||"> ) { <alt> } -<referencedElementsDeep:{el | stream_<el>.reset();<\n>}> +<referencedElementsDeep:{el | stream_<el>->reset();<\n>}> >> rewriteClosureBlock( @@ -264,10 +264,10 @@ description) ::= << // <fileName>:<description> -while ( <referencedElements:{el | stream_<el>.hasNext()}; separator="||"> ) { +while ( <referencedElements:{el | stream_<el>->hasNext()}; separator="||"> ) { <alt> } -<referencedElements:{el | stream_<el>.reset();<\n>}> +<referencedElements:{el | stream_<el>->reset();<\n>}> >> rewritePositiveClosureBlock( @@ -276,13 +276,13 @@ referencedElements, // elements in immediately block; no nested blocks description) ::= << -if ( !(<referencedElements:{el | stream_<el>.hasNext()}; separator="||">) ) { +if ( !(<referencedElements:{el | stream_<el>->hasNext()}; separator="||">) ) { throw new RewriteEarlyExitException(); } -while ( <referencedElements:{el | stream_<el>.hasNext()}; separator="||"> ) { +while ( <referencedElements:{el | stream_<el>->hasNext()}; separator="||"> ) { <alt> } -<referencedElements:{el | stream_<el>.reset();<\n>}> +<referencedElements:{el | stream_<el>->reset();<\n>}> >> rewriteAlt(a) ::= << @@ -325,17 +325,17 @@ /** Gen $label ... where defined via label=ID */ rewriteTokenLabelRef(label,elementIndex) ::= << -TreeAdaptorType::addChild(root_<treeLevel>, stream_<label>.nextNode()); +TreeAdaptorType::addChild(root_<treeLevel>, stream_<label>->nextNode()); >> /** Gen $label ... where defined via label+=ID */ rewriteTokenListLabelRef(label,elementIndex) ::= << -TreeAdaptorType::addChild(root_<treeLevel>, stream_<label>.nextNode()); +TreeAdaptorType::addChild(root_<treeLevel>, stream_<label>->nextNode()); >> /** Gen ^($label ...) */ rewriteTokenLabelRefRoot(label,elementIndex) ::= << -root_<treeLevel> = (<ASTLabelType>)TreeAdaptorType::becomeRoot(stream_<label>.nextNode(), root_<treeLevel>); +root_<treeLevel> = (<ASTLabelType>)TreeAdaptorType::becomeRoot(stream_<label>->nextNode(), root_<treeLevel>); >> /** Gen ^($label ...) where label+=... */ @@ -371,7 +371,7 @@ >> rewriteRuleRefRoot(rule) ::= << -root_<treeLevel> = (<ASTLabelType>)TreeAdaptorType::becomeRoot(stream_<rule>.nextNode(), root_<treeLevel>); +root_<treeLevel> = (<ASTLabelType>)TreeAdaptorType::becomeRoot(stream_<rule>->nextNode(), root_<treeLevel>); >> rewriteNodeAction(action) ::= << @@ -394,12 +394,12 @@ /** Gen ^($ruleLabel ...) where ruleLabel=rule */ rewriteRuleLabelRefRoot(label) ::= << -root_<treeLevel> = (<ASTLabelType>)TreeAdaptorType::becomeRoot(stream_<label>.nextNode(), root_<treeLevel>); +root_<treeLevel> = (<ASTLabelType>)TreeAdaptorType::becomeRoot(stream_<label>->nextNode(), root_<treeLevel>); >> /** Gen ^($ruleLabel ...) where ruleLabel+=rule */ rewriteRuleListLabelRefRoot(label) ::= << -root_<treeLevel> = (<ASTLabelType>)TreeAdaptorType::becomeRoot(stream_<label>.nextNode(), root_<treeLevel>); +root_<treeLevel> = (<ASTLabelType>)TreeAdaptorType::becomeRoot(stream_<label>->nextNode(), root_<treeLevel>); >> rewriteWildcardLabelRef(label) ::= << @@ -423,7 +423,7 @@ <if(args)> <! must create new node from old !> TreeAdaptorType.create(<token>, <args; separator=", ">) <else> -stream_<token>.nextNode() +stream_<token>->nextNode() <endif> <endif> %> Modified: branches/tora3/extlibs/parsing.cpp/s0.cpp =================================================================== --- branches/tora3/extlibs/parsing.cpp/s0.cpp 2013-05-15 12:49:24 UTC (rev 4643) +++ branches/tora3/extlibs/parsing.cpp/s0.cpp 2013-05-15 20:25:01 UTC (rev 4644) @@ -170,7 +170,8 @@ // Finally, now that we have our lexer constructed, we can create the parser // psr = new SQLMiniParser(tstream); // javaParserNew is generated by ANTLR3 - psr->start_rule(); + SQLMiniParser::start_rule_return r = psr->start_rule(); + std::cout << r.getTree()->toStringTree() << std::endl; // Note that this means only that the methods are always called via the object // pointer and the first argument to any method, is a pointer to the structure itself. This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <ibr...@us...> - 2013-05-16 15:29:39
|
Revision: 4645 http://sourceforge.net/p/tora/code/4645 Author: ibre5041 Date: 2013-05-16 15:29:36 +0000 (Thu, 16 May 2013) Log Message: ----------- Cpp.stg/AST.stg cleanup, CommonTree reflects Java API Modified Paths: -------------- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3defs.hpp branches/tora3/extlibs/parsing.cpp/Makefile branches/tora3/extlibs/parsing.cpp/MySQLGuiLexer.g branches/tora3/extlibs/parsing.cpp/OraclePLSQL.g branches/tora3/extlibs/parsing.cpp/UserMiniTraits.hpp branches/tora3/extlibs/parsing.cpp/antlr-complete-3.5.1-SNAPSHOT.jar branches/tora3/extlibs/parsing.cpp/input/simple01.sql branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/AST.stg branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/Cpp.stg branches/tora3/extlibs/parsing.cpp/s0.cpp Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.hpp 2013-05-15 20:25:01 UTC (rev 4644) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.hpp 2013-05-16 15:29:36 UTC (rev 4645) @@ -45,55 +45,22 @@ typedef typename ImplTraits::StringType StringType; typedef typename ImplTraits::CommonTokenType CommonTokenType; typedef typename ImplTraits::TreeType TreeType; - typedef CommonTree TokenType; + //typedef CommonTree TokenType; typedef typename AllocPolicyType::template VectorType<TreeType*> ChildrenType; typedef typename AllocPolicyType::template ListType<TreeType*> ChildListType; -private: - /// 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. - /// - ChildrenType m_children; - - /// This is used to store the current child index position while descending - /// and ascending trees as the tree walk progresses. - /// - ANTLR_MARKER m_savedIndex; - - /// Start token index that encases this tree - /// - ANTLR_MARKER m_startIndex; - - /// End token that encases this tree - /// - ANTLR_MARKER m_stopIndex; - - /// A single token, this is the payload for the tree - /// - CommonTokenType* m_token; - - /// Points to the node that has this node as a child. - /// If this is NULL, then this is the root node. - /// - CommonTree* m_parent; - - /// What index is this particular node in the child list it - /// belongs to? - /// - ANTLR_INT32 m_childIndex; - public: CommonTree(); CommonTree( CommonTokenType* token ); CommonTree( CommonTree* token ); CommonTree( CommonTree& ctree ); + ~CommonTree(); CommonTokenType* getToken() const; void setToken(CommonTokenType*); ChildrenType& getChildren(); const ChildrenType& getChildren() const; - ChildrenType* get_children_p(); ANTLR_INT32 getChildIndex() const; TreeType* getParent() const; @@ -110,7 +77,7 @@ /// Add all elements of the supplied list as children of this node /// void addChildren(const ChildListType& kids); - void createChildrenList(); + TreeType* deleteChild(ANTLR_UINT32 i); /// Delete children from start to stop and replace with t even if t is /// a list (nil-root tree). Num of children can increase or decrease. @@ -132,10 +99,38 @@ void setChild(ANTLR_UINT32 i, TreeType* child); StringType toStringTree(); StringType toString(); - void freshenPACIndexesAll(); - void freshenPACIndexes(ANTLR_UINT32 offset); - void reuse(); - ~CommonTree(); + void freshenParentAndChildIndexes(); + void freshenParentAndChildIndexes(ANTLR_UINT32 offset); + void freshenParentAndChildIndexesDeeply(); + void freshenParentAndChildIndexesDeeply(ANTLR_UINT32 offset); + +private: + /// Start token index that encases this tree + /// + ANTLR_MARKER m_startIndex; + + /// End token that encases this tree + /// + ANTLR_MARKER m_stopIndex; + + /// What index is this particular node in the child list it + /// belongs to? + /// + ANTLR_INT32 m_childIndex; + + /// 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. + /// + ChildrenType m_children; + + /// A single token, this is the payload for the tree + /// + CommonTokenType* m_token; + + /// Points to the node that has this node as a child. + /// If this is NULL, then this is the root node. + /// + CommonTree* m_parent; }; ANTLR_END_NAMESPACE() Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.inl 2013-05-15 20:25:01 UTC (rev 4644) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.inl 2013-05-16 15:29:36 UTC (rev 4645) @@ -3,46 +3,42 @@ template<class ImplTraits> CommonTree<ImplTraits>::CommonTree() { - m_savedIndex = 0; - m_startIndex = 0; - m_stopIndex = 0; + m_startIndex = -1; + m_stopIndex = -1; + m_childIndex = -1; m_token = NULL; m_parent = NULL; - m_childIndex = 0; } template<class ImplTraits> CommonTree<ImplTraits>::CommonTree( CommonTree& ctree ) :m_children( ctree.m_children) { - m_savedIndex = ctree.m_savedIndex; m_startIndex = ctree.m_startIndex; m_stopIndex = ctree.m_stopIndex; + m_childIndex = ctree.m_childIndex; m_token = ctree.m_token; m_parent = ctree.m_parent; - m_childIndex = ctree.m_childIndex; } template<class ImplTraits> CommonTree<ImplTraits>::CommonTree( CommonTokenType* token ) { - m_savedIndex = 0; - m_startIndex = 0; - m_stopIndex = 0; + m_startIndex = -1; + m_stopIndex = -1; + m_childIndex = -1; m_token = token; m_parent = NULL; - m_childIndex = 0; } template<class ImplTraits> CommonTree<ImplTraits>::CommonTree( CommonTree* tree ) { - m_savedIndex = 0; - m_startIndex = 0; - m_stopIndex = 0; + m_startIndex = -1; + m_stopIndex = -1; + m_childIndex = -1; m_token = tree->getToken(); m_parent = NULL; - m_childIndex = 0; } template<class ImplTraits> @@ -70,29 +66,19 @@ } template<class ImplTraits> -typename CommonTree<ImplTraits>::ChildrenType* CommonTree<ImplTraits>::get_children_p() -{ - return &m_children; -} - -template<class ImplTraits> void CommonTree<ImplTraits>::addChild(TreeType* child) { - ANTLR_UINT32 n; - ANTLR_UINT32 i; - if (child == NULL) return; ChildrenType& child_children = child->getChildren(); - ChildrenType& tree_children = this->getChildren(); + //ChildrenType& tree_children = this->getChildren(); if (child->isNilNode() == true) { - if ( !child_children.empty() && child_children == tree_children ) + if ( !child_children.empty() && child_children == m_children ) { // TODO: Change to exception rather than ANTLR3_FPRINTF? - // fprintf(stderr, "ANTLR3: An attempt was made to add a child list to itself!\n"); return; } @@ -101,55 +87,42 @@ // if ( !child_children.empty() ) { - if (tree_children.empty()) + if (!m_children.empty()) { + // Need to copy the children + ANTLR_UINT32 n = child_children.size(); + for (ANTLR_UINT32 i = 0; i < n; i++) + { + TreeType* entry = child_children.at(i); + // ANTLR3 lists can be sparse, unlike Array Lists (TODO: really?) + if (entry != NULL) + m_children.push_back(entry); + entry->setParent(this); + entry->setChildIndex(m_children.size()-1); + } + } else { // We are build ing the tree structure here, so we need not // worry about duplication of pointers as the tree node // factory will only clean up each node once. So we just // copy in the child's children pointer as the child is // a nil node (has not root itself). // - tree_children.swap( child_children ); - this->freshenPACIndexesAll(); + m_children.swap( child_children ); + this->freshenParentAndChildIndexes(); } - else - { - // Need to copy the children - // - n = child_children.size(); - - for (i = 0; i < n; i++) - { - TreeType* entry; - entry = child_children[i]; - - // ANTLR3 lists can be sparse, unlike Array Lists - // - if (entry != NULL) - { - tree_children.push_back(entry); - } - } - } } } else { // Tree we are adding is not a Nil and might have children to copy - // - if (tree_children.empty()) - { - // No children in the tree we are adding to, so create a new list on - // the fly to hold them. - // - this->createChildrenList(); - } - tree_children.push_back( child ); + m_children.push_back( child ); + child->setParent(this); + child->setChildIndex(m_children.size()-1); } } template<class ImplTraits> -void CommonTree<ImplTraits>::addChildren(const ChildListType& kids) +void CommonTree<ImplTraits>::addChildren(const ChildListType& kids) { for( typename ChildListType::const_iterator iter = kids.begin(); iter != kids.end(); ++iter ) @@ -158,19 +131,14 @@ } } -//dummy one, as vector is always there template<class ImplTraits> -void CommonTree<ImplTraits>::createChildrenList() -{ -} - -template<class ImplTraits> typename CommonTree<ImplTraits>::TreeType* CommonTree<ImplTraits>::deleteChild(ANTLR_UINT32 i) { if( m_children.empty() ) return NULL; - - return m_children.erase( m_children.begin() + i); + TreeType* killed = m_children.erase( m_children.begin() + i); + this->freshenParentAndChildIndexes(i); + return killed; } template<class ImplTraits> @@ -321,33 +289,23 @@ template<class ImplTraits> ANTLR_UINT32 CommonTree<ImplTraits>::getCharPositionInLine() { - CommonTokenType* token; - token = m_token; - - if (token == NULL || (token->getCharPositionInLine() == -1) ) + if(m_token == NULL || (m_token->getCharPositionInLine() == -1) ) { - if (this->getChildCount() > 0) - { - TreeType* child; - - child = this->getChild(0); - - return child->getCharPositionInLine(); - } + if(this->getChildCount() > 0) + return this->getChild(0)->getCharPositionInLine(); return 0; } - return token->getCharPositionInLine(); + return m_token->getCharPositionInLine(); } template<class ImplTraits> typename CommonTree<ImplTraits>::TreeType* CommonTree<ImplTraits>::getChild(ANTLR_UINT32 i) { - if ( m_children.empty() - || i >= m_children.size() ) + if ( m_children.empty() || i >= m_children.size() ) { return NULL; } - return m_children[i]; + return m_children.at(i); } @@ -384,6 +342,8 @@ template<class ImplTraits> ANTLR_MARKER CommonTree<ImplTraits>::getStartIndex() const { + if( m_startIndex==-1 && m_token!=NULL) + return m_token->getTokenIndex(); return m_startIndex; } @@ -396,6 +356,8 @@ template<class ImplTraits> ANTLR_MARKER CommonTree<ImplTraits>::getStopIndex() const { + if( m_stopIndex==-1 && m_token!=NULL) + return m_token->getTokenIndex(); return m_stopIndex; } @@ -408,14 +370,10 @@ template<class ImplTraits> ANTLR_UINT32 CommonTree<ImplTraits>::getType() { - if (this == NULL) - { - return 0; - } + if (m_token == NULL) + return CommonTokenType::TOKEN_INVALID; else - { return m_token->getType(); - } } template<class ImplTraits> @@ -443,21 +401,13 @@ template<class ImplTraits> ANTLR_UINT32 CommonTree<ImplTraits>::getLine() { - TreeType* cTree = this; - CommonTokenType* token; - token = cTree->get_token(); - - if (token == NULL || token->getLine() == 0) + if(m_token == NULL || m_token->getLine() == 0) { if ( this->getChildCount() > 0) - { - TreeType* child; - child = this->getChild(0); - return child->getLine(); - } + return this->getChild(0)->getLine(); return 0; } - return token->getLine(); + return m_token->getLine(); } template<class ImplTraits> @@ -467,121 +417,117 @@ } template<class ImplTraits> -bool CommonTree<ImplTraits>::isNilNode() +bool CommonTree<ImplTraits>::isNilNode() { // This is a Nil tree if it has no payload (Token in our case) - // if(m_token == NULL) - { return true; - } else - { return false; - } } template<class ImplTraits> -void CommonTree<ImplTraits>::setChild(ANTLR_UINT32 i, TreeType* child) +void CommonTree<ImplTraits>::setChild(ANTLR_UINT32 i, TreeType* child) { - if( m_children.size() >= i ) + if( child==NULL) + return; + + if( child->isNilNode()) + { + // TODO: throw IllegalArgumentException + return; + } + + if( m_children.size() <= i ) m_children.resize(i+1); + m_children[i] = child; + child->setParent(this); + child->setChildIndex(i); } template<class ImplTraits> typename CommonTree<ImplTraits>::StringType CommonTree<ImplTraits>::toStringTree() { - StringType string; - ANTLR_UINT32 i; - ANTLR_UINT32 n; - TreeType* t; + StringType retval; if( m_children.empty() ) - { return this->toString(); - } /* Need a new string with nothing at all in it. */ - if (this->isNilNode() == false) + if(this->isNilNode() == false) { - string.append("("); - string.append(this->toString()); - string.append(" "); + retval.append("("); + retval.append(this->toString()); + retval.append(" "); } if ( !m_children.empty()) { - n = m_children.size(); - - for (i = 0; i < n; i++) + ANTLR_UINT32 n = m_children.size(); + for (ANTLR_UINT32 i = 0; i < n; i++) { - t = m_children[i]; - + TreeType *t = m_children.at(i); if (i > 0) { - string.append(" "); + retval.append(" "); } - string.append(t->toStringTree()); + retval.append(t->toStringTree()); } } if (this->isNilNode() == false) { - string.append(")"); + retval.append(")"); } - - return string; + return retval; } template<class ImplTraits> typename CommonTree<ImplTraits>::StringType CommonTree<ImplTraits>::toString() { - if (this->isNilNode() ) - { - StringType nilNode; - - nilNode = "nil"; - - return nilNode; - } - + if( this->isNilNode()) + return StringType("nil"); return m_token->getText(); } template<class ImplTraits> -void CommonTree<ImplTraits>::freshenPACIndexesAll() +void CommonTree<ImplTraits>::freshenParentAndChildIndexes() { - this->freshenPACIndexes(0); + this->freshenParentAndChildIndexes(0); } template<class ImplTraits> -void CommonTree<ImplTraits>::freshenPACIndexes(ANTLR_UINT32 offset) +void CommonTree<ImplTraits>::freshenParentAndChildIndexes(ANTLR_UINT32 offset) { - ANTLR_UINT32 count; - ANTLR_UINT32 c; - - count = this->getChildCount(); // How many children do we have - + ANTLR_UINT32 count = this->getChildCount(); // Loop from the supplied index and set the indexes and parent - // - for (c = offset; c < count; c++) + for (ANTLR_UINT32 c = offset; c < count; c++) { - TreeType* child; - - child = this->getChild(c); - + TreeType* child = this->getChild(c); child->setChildIndex(c); child->setParent(this); } } template<class ImplTraits> -void CommonTree<ImplTraits>::reuse() +void CommonTree<ImplTraits>::freshenParentAndChildIndexesDeeply() { - delete this; //memory re-use should be taken by the library user + this->freshenParentAndChildIndexes(0); } template<class ImplTraits> +void CommonTree<ImplTraits>::freshenParentAndChildIndexesDeeply(ANTLR_UINT32 offset) +{ + ANTLR_UINT32 count = this->getChildCount(); + for (ANTLR_UINT32 c = offset; c < count; c++) { + TreeType* child = getChild(c); + child->setChildIndex(c); + child->setParent(this); + child->freshenParentAndChildIndexesDeeply(); + } +} + +template<class ImplTraits> CommonTree<ImplTraits>::~CommonTree() { } Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.inl 2013-05-15 20:25:01 UTC (rev 4644) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.inl 2013-05-16 15:29:36 UTC (rev 4645) @@ -140,8 +140,7 @@ newRootTree = newRootTree->getChild(0); // Reclaim the old nilNode() - // - saveRoot->reuse(); + delete saveRoot; } /* Add old root into new root. addChild takes care of the case where oldRoot @@ -163,7 +162,7 @@ // don't know necessarilly know how to do this for the real node, we just ask the tree itself // to do it. // - oldRootTree->reuse(); + delete oldRootTree; } /* Always returns new root structure */ @@ -670,7 +669,7 @@ // been abandoned and would be lost in the node factory. However // nodes can be flagged as resuable to prevent this terrible waste // - saveRoot->reuse(); + delete saveRoot; } } return root; Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3defs.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3defs.hpp 2013-05-15 20:25:01 UTC (rev 4644) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3defs.hpp 2013-05-16 15:29:36 UTC (rev 4645) @@ -98,8 +98,6 @@ #define ANTLR_BEGIN_NAMESPACE() namespace antlr3 { #define ANTLR_END_NAMESPACE() } -#define ANTLR_USE_64BIT - /* Common definitions come first */ #include <antlr3errors.hpp> Modified: branches/tora3/extlibs/parsing.cpp/Makefile =================================================================== --- branches/tora3/extlibs/parsing.cpp/Makefile 2013-05-15 20:25:01 UTC (rev 4644) +++ branches/tora3/extlibs/parsing.cpp/Makefile 2013-05-16 15:29:36 UTC (rev 4645) @@ -6,7 +6,7 @@ SOURCES = $(wildcard *.cpp) PSOURCES = $(wildcard PLSQLParser*.cpp) PLSQLLexer.cpp POBJS = $(PSOURCES:.cpp=.o) -GRAMMAROPTIONS=-report -Xconversiontimeout 1500000 -Xmultithreaded -Xwatchconversion +GRAMMAROPTIONS= -report -Xconversiontimeout 1500000 -Xmultithreaded -Xwatchconversion ANTLR = antlr-complete-3.5.1-SNAPSHOT.jar .SUFFIXES: @@ -18,7 +18,7 @@ TOBJS= utils.o -all: t0 m0 p0 s0 +all: t0 m0 p0 s0 s1 $(ANTLR): org/antlr/codegen/templates/Cpp/Cpp.stg \ org/antlr/codegen/templates/Cpp/AST.stg \ @@ -49,8 +49,11 @@ s0: s0.cpp SQLMini.tokens $(TOBJS) Makefile UserMiniTraits.hpp g++ $(CFLAGS) -DUSESTL $(INCLUDES) $(TOBJS) s0.cpp SQLMiniLexer.cpp SQLMiniParser.cpp $(LIBS) -o $@ +s1: s1.cpp S.tokens $(TOBJS) Makefile UserMiniTraits.hpp + g++ $(CFLAGS) -DUSESTL $(INCLUDES) $(TOBJS) s1.cpp SLexer.cpp SParser.cpp $(LIBS) -o $@ + clean: - rm -f *.o *GuiLexer*.[ch]pp PLSQLLexer*.[ch]pp PLSQL*[ch]pp t0 t1 t2 t3 t4 m0 *.tokens SQLMini*.[ch]pp + rm -f *.o *GuiLexer*.[ch]pp PLSQLLexer*.[ch]pp PLSQL*[ch]pp t0 t1 t2 t3 t4 m0 s0 s1 *.tokens SQLMini*.[ch]pp %.u: %.g @echo "Bulding dependencies for "$< Modified: branches/tora3/extlibs/parsing.cpp/MySQLGuiLexer.g =================================================================== --- branches/tora3/extlibs/parsing.cpp/MySQLGuiLexer.g 2013-05-15 20:25:01 UTC (rev 4644) +++ branches/tora3/extlibs/parsing.cpp/MySQLGuiLexer.g 2013-05-16 15:29:36 UTC (rev 4645) @@ -1104,7 +1104,7 @@ fragment USER_VAR_SUBFIX4: ( 'A'..'Z' | 'a'..'z' | '_' | '$' | '0'..'9' | DOT )+ ; // basic const data definition --------------------------------------------------------------- -STRING_LITERAL: TEXT_STRING | USER_VAR_SUBFIX2 | USER_VAR_SUBFIX3 | USER_VAR_SUBFIX4; +STRING_LITERAL: TEXT_STRING /*| USER_VAR_SUBFIX2 | USER_VAR_SUBFIX3*/ | USER_VAR_SUBFIX4; // GUI RULES COMMENT_ML_PART Modified: branches/tora3/extlibs/parsing.cpp/OraclePLSQL.g =================================================================== --- branches/tora3/extlibs/parsing.cpp/OraclePLSQL.g 2013-05-15 20:25:01 UTC (rev 4644) +++ branches/tora3/extlibs/parsing.cpp/OraclePLSQL.g 2013-05-16 15:29:36 UTC (rev 4645) @@ -23,7 +23,7 @@ language=Cpp; backtrack=true; memoize=true; - //output=AST; + output=AST; //TokenLabelType=CommonTokenTypeCTT; } Modified: branches/tora3/extlibs/parsing.cpp/UserMiniTraits.hpp =================================================================== --- branches/tora3/extlibs/parsing.cpp/UserMiniTraits.hpp 2013-05-15 20:25:01 UTC (rev 4644) +++ branches/tora3/extlibs/parsing.cpp/UserMiniTraits.hpp 2013-05-16 15:29:36 UTC (rev 4645) @@ -15,6 +15,8 @@ namespace Antlr3Mini { class SQLMiniLexer; class SQLMiniParser; + class SLexer; + class SParser; }; namespace Antlr3Mini { @@ -28,6 +30,9 @@ typedef antlr3::Traits<SQLMiniLexer, SQLMiniParser, UserTraits> SQLMiniLexerTraits; typedef SQLMiniLexerTraits SQLMiniParserTraits; +typedef antlr3::Traits<SLexer, SParser, UserTraits> SLexerTraits; +typedef antlr3::Traits<SLexer, SParser, UserTraits> SParserTraits; + }; #endif Modified: branches/tora3/extlibs/parsing.cpp/antlr-complete-3.5.1-SNAPSHOT.jar =================================================================== (Binary files differ) Modified: branches/tora3/extlibs/parsing.cpp/input/simple01.sql =================================================================== --- branches/tora3/extlibs/parsing.cpp/input/simple01.sql 2013-05-15 20:25:01 UTC (rev 4644) +++ branches/tora3/extlibs/parsing.cpp/input/simple01.sql 2013-05-16 15:29:36 UTC (rev 4645) @@ -1,5 +1,7 @@ -#1234 +for update of xyz.a123.g5556 +/*#1234*/ --fdskfjsdfk +/* -1 - 1 1.5 + .5 @@ -20,3 +22,5 @@ , n'nchar literal' from dual select 1..10 from dd "gdgdgd" 'gfgdgd' fdfsfs ; +*/ + Modified: branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/AST.stg =================================================================== --- branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/AST.stg 2013-05-15 20:25:01 UTC (rev 4644) +++ branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/AST.stg 2013-05-16 15:29:36 UTC (rev 4645) @@ -61,14 +61,27 @@ <super.ASTLabelType()> getTree() { return tree; } >> -ruleReturnMembersInit(value, prefix) ::= <% -<if(!prefix)> -tree = <value>; -<else> -tree = <prefix>.tree; -<endif> +...@re...leReturnMembersInit() ::= << +tree = NULL; +>> + +...@re...leReturnMembersCopy() ::= <% +tree = other.tree; const_cast\< <ruleDescriptor:returnStructName()>& >(other).tree = NULL; %> +...@re...leReturnMembersDelete() ::= << +//if(tree != NULL) +// delete tree; +>> + +//ruleReturnMembersInit(value, prefix) ::= <% +//<if(!prefix)> +//tree = <value>; +//<else> +//tree = <prefix>.tree; +//<endif> +//%> + /** Add a variable to track rule's return AST */ ruleDeclarations() ::= << <super.ruleDeclarations()> Modified: branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/Cpp.stg =================================================================== --- branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/Cpp.stg 2013-05-15 20:25:01 UTC (rev 4644) +++ branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/Cpp.stg 2013-05-16 15:29:36 UTC (rev 4645) @@ -546,7 +546,7 @@ <endif> %> -headerReturnScope(ruleDescriptor) ::= "<returnScope(...)>" +headerReturnScope(ruleDescriptor) ::= "<returnScope(scope=ruleDescriptor.returnScope)>" headerReturnType(ruleDescriptor) ::= <% <if(LEXER)> @@ -1271,15 +1271,13 @@ ruleInitializations() ::= << /* Initialize rule variables */ +<if(ruleDescriptor.returnScope)> <if(ruleDescriptor.hasMultipleReturnValues)> -<ruleDescriptor.returnScope.attributes:{ a | -<if(a.initValue)>retval.<a.name> = <a.initValue>;<endif> -}> +<ruleDescriptor.returnScope.attributes:{ a | <if(a.initValue)>retval.<a.name> = <a.initValue>;<endif> }> <else> -<ruleDescriptor.returnScope.attributes:{ a | -<if(a.initValue)><a.name> = <a.initValue>;<endif> -}> +<ruleDescriptor.returnScope.attributes:{ a | <if(a.initValue)><a.name> = <a.initValue>;<endif> }> <endif> +<endif> <if(memoize)> <ruleDescriptor.name>_StartIndex = this->index();<\n> <endif> @@ -2092,35 +2090,26 @@ <endif> } - <if(dfa.specialStateSTs)> - ANTLR_UINT32 LA(ANTLR_INT32 i) - { - return m_ctx->LA(i); - } + <if(dfa.specialStateSTs)> + ANTLR_UINT32 LA(ANTLR_INT32 i) + { + return m_ctx->LA(i); + } - <if(PARSER)> - template\<typename PredType> - bool msynpred( PredType pred ) - { - return m_ctx->msynpred(pred); - } + <if(PARSER)> + const CtxType::CommonTokenType* LT(ANTLR_INT32 k) + { + return m_ctx->LT(k); + } + <endif> + <if(synpreds)> + template\<typename PredType> + bool msynpred( PredType pred ) + { + return m_ctx->msynpred(pred); + } + <endif> - const CtxType::CommonTokenType* LT(ANTLR_INT32 k) - { - return m_ctx->LT(k); - } - <endif> - - <if(LEXER)> - <if(synpreds)> - template\<typename PredType> - bool msynpred( PredType pred ) - { - return m_ctx->msynpred(pred); - } - <endif> - <endif> - ANTLR_INT32 specialStateTransition(CtxType * ctx, RecognizerType* recognizer, IntStreamType* is, ANTLR_INT32 s) { ANTLR_INT32 _s; @@ -2374,55 +2363,59 @@ { public: typedef <name>ImplTraits::RuleReturnValueType BaseType; -<else> -struct <ruleDescriptor.grammar.recognizerName>_<ruleDescriptor:returnStructName()> -{ - <name>ImplTraits::<recognizer.ASTLabelType> start; - <name>ImplTraits::<recognizer.ASTLabelType> stop; -<endif> - <@ruleReturnMembers()> - <ruleDescriptor.returnScope.attributes:{it |<it.type> <it.name>;}; separator="\n"> -<if(!TREE_PARSER)> - <ruleDescriptor:returnStructName()>() : BaseType() { <ruleReturnMembersInit("NULL")> } - <ruleDescriptor:returnStructName()>( BaseParserType* parser ) : BaseType(parser) { <ruleReturnMembersInit("NULL")> } - <ruleDescriptor:returnStructName()>( const <ruleDescriptor:returnStructName()>& n ) : BaseType(n) - <if(ruleDescriptor.returnScope.attributes)> - , <ruleDescriptor.returnScope.attributes:{it | <it.name>(n.<it.name>) }; separator=","> + <ruleDescriptor:returnStructName()>() : BaseType() { init(); } + <ruleDescriptor:returnStructName()>( BaseParserType* parser ) : BaseType(parser) { init(); } + <ruleDescriptor:returnStructName()>( const <ruleDescriptor:returnStructName()>& other ) : BaseType(other) + <if(scope)> + , <scope.attributes:{it | <it.name>(other.<it.name>) }; separator=","> <endif> { - <ruleReturnMembersInit("n","n")> + copy(other); } - + ~<ruleDescriptor:returnStructName()>() + { + <@ruleReturnMembersDelete()> + } + <ruleDescriptor:returnStructName()>& - operator=( const <ruleDescriptor:returnStructName()>& n ) + operator=( const <ruleDescriptor:returnStructName()>& other ) { - BaseType::operator=( n ); - <ruleDescriptor.returnScope.attributes:{it | <it.name> = n.<it.name>; }; separator="\n"> - <ruleReturnMembersInit("n","n")> - return *this; + BaseType::operator=( other ); + <if(ruleDescriptor.returnScope)> + <scope.attributes:{it | <it.name> = other.<it.name>; }; separator="\n"> + <endif> + copy(other); + return *this; } + <@ruleReturnMembers()> + void init() { <@ruleReturnMembersInit()> } + void copy( const <ruleDescriptor:returnStructName()>& other) { <@ruleReturnMembersCopy()> } <else> - <ruleDescriptor.grammar.recognizerName>_<ruleDescriptor:returnStructName()>( const <ruleDescriptor.grammar.recognizerName>_<ruleDescriptor:returnStructName()>& n ) - <if(ruleDescriptor.returnScope.attributes)> - <ruleDescriptor.returnScope.attributes:{it | <it.name>(n.<it.name>) }; separator=","> +struct <ruleDescriptor:returnStructName()> +{ +public: + <name>ImplTraits::<recognizer.ASTLabelType> start; + <name>ImplTraits::<recognizer.ASTLabelType> stop; + <ruleDescriptor:returnStructName()>( const <ruleDescriptor:returnStructName()>& other ) + <if(scope.attributes)> + <scope.attributes:{it | <it.name>(other.<it.name>) }; separator=","> <endif> { - start = n.start; - stop = n.stop; + start = other.start; + stop = other.stop; } - <ruleDescriptor.grammar.recognizerName>_<ruleDescriptor:returnStructName()>& - operator=( const <ruleDescriptor.grammar.recognizerName>_<ruleDescriptor:returnStructName()>& n ) + <ruleDescriptor:returnStructName()>& + operator=( const <ruleDescriptor:returnStructName()>& other ) { - start = n.start; - stop = n.stop; + start = other.start; + stop = other.stop; - <ruleDescriptor.returnScope.attributes:{it | <it.name> = n.<it.name>; }; separator="\n"> - return *this; + <scope.attributes:{it | <it.name> = other.<it.name>; }; separator="\n"> + return *this; } - <endif> - + <if(scope)><scope.attributes:{it |<it.type> <it.name>;}; separator="\n"><endif> }; <endif> Modified: branches/tora3/extlibs/parsing.cpp/s0.cpp =================================================================== --- branches/tora3/extlibs/parsing.cpp/s0.cpp 2013-05-15 20:25:01 UTC (rev 4644) +++ branches/tora3/extlibs/parsing.cpp/s0.cpp 2013-05-16 15:29:36 UTC (rev 4645) @@ -139,7 +139,7 @@ (ANTLR_UINT8*)fName); input->setUcaseLA(true); - + // Our input stream is now open and all set to go, so we can create a new instance of our // lexer and set the lexer input to our input stream: // (file | memory | ?) --> inputstream -> lexer --> tokenstream --> parser ( --> treeparser )? This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <ibr...@us...> - 2013-05-17 09:01:18
|
Revision: 4647 http://sourceforge.net/p/tora/code/4647 Author: ibre5041 Date: 2013-05-17 09:01:14 +0000 (Fri, 17 May 2013) Log Message: ----------- CommonTreeAdaptor API reflects Java API Modified Paths: -------------- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.inl branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/AST.stg Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.hpp 2013-05-17 08:15:34 UTC (rev 4646) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.hpp 2013-05-17 09:01:14 UTC (rev 4647) @@ -67,11 +67,14 @@ TreeType* becomeRootToken(CommonTokenType* newRoot, TreeType* oldRoot); - TreeType* create( CommonTokenType* payload); - TreeType* createTypeToken( ANTLR_UINT32 tokenType, CommonTokenType* fromToken); - TreeType* createTypeTokenText ( ANTLR_UINT32 tokenType, CommonTokenType* fromToken, const char* text); - TreeType* createTypeText ( ANTLR_UINT32 tokenType, const char* text); + TreeType* create( CommonTokenType* payload); + TreeType* create( ANTLR_UINT32 tokenType, CommonTokenType* fromToken); + TreeType* create( ANTLR_UINT32 tokenType, CommonTokenType* fromToken, const char* text); + TreeType* create( ANTLR_UINT32 tokenType, const char* text); + CommonTokenType* createToken( ANTLR_UINT32 tokenType, const char* text); + CommonTokenType* createToken( CommonTokenType* fromToken); + TreeType* dupNode( TreeType* treeNode); ANTLR_UINT32 getType( TreeType* t); StringType getText( TreeType* t); @@ -85,13 +88,11 @@ ANTLR_UINT32 getChildCount( TreeType*); ANTLR_UINT64 getUniqueID( TreeType*); - CommonTokenType* createToken( ANTLR_UINT32 tokenType, const char* text); - CommonTokenType* createTokenFromToken( CommonTokenType* fromToken); CommonTokenType* getToken( TreeType* t); void setTokenBoundaries( TreeType* t, const CommonTokenType* startToken, const CommonTokenType* stopToken); - ANTLR_MARKER getTokenStartIndex( TreeType* t); - ANTLR_MARKER getTokenStopIndex( TreeType* t); + ANTLR_MARKER getStartIndex( TreeType* t); + ANTLR_MARKER getStopIndex( TreeType* t); /// Produce a DOT (see graphviz freeware suite) from a base tree /// Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.inl 2013-05-17 08:15:34 UTC (rev 4646) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.inl 2013-05-17 09:01:14 UTC (rev 4647) @@ -56,7 +56,7 @@ } template<class ImplTraits> -void CommonTreeAdaptor<ImplTraits>::addChildToken( TreeType* t, CommonTokenType* child) +void CommonTreeAdaptor<ImplTraits>::addChildToken( TreeType* t, CommonTokenType* child) { if (t != NULL && child != NULL) { @@ -65,7 +65,7 @@ } template<class ImplTraits> -void CommonTreeAdaptor<ImplTraits>::setParent( TreeType* child, TreeType* parent) +void CommonTreeAdaptor<ImplTraits>::setParent( TreeType* child, TreeType* parent) { child->setParent(parent); } @@ -74,6 +74,8 @@ typename CommonTreeAdaptor<ImplTraits>::TreeType* CommonTreeAdaptor<ImplTraits>::getParent( TreeType* child) { + if ( child==NULL ) + return NULL; return child->getParent(); } @@ -88,7 +90,7 @@ // need to track and free the memory allocated to it, so for now, we just // want something in the tree that isn't a NULL pointer. // - return this->createTypeText( CommonTokenType::TOKEN_INVALID, "Tree Error Node"); + return this->create( CommonTokenType::TOKEN_INVALID, "Tree Error Node"); } @@ -170,71 +172,57 @@ } template<class ImplTraits> -typename CommonTreeAdaptor<ImplTraits>::TreeType* CommonTreeAdaptor<ImplTraits>::becomeRootToken( CommonTokenType* newRoot, TreeType* oldRoot) +typename CommonTreeAdaptor<ImplTraits>::TreeType* +CommonTreeAdaptor<ImplTraits>::becomeRootToken( CommonTokenType* newRoot, TreeType* oldRoot) { return this->becomeRoot(this->create(newRoot), oldRoot); } template<class ImplTraits> -typename CommonTreeAdaptor<ImplTraits>::TreeType* CommonTreeAdaptor<ImplTraits>::create( CommonTokenType* payload) +typename CommonTreeAdaptor<ImplTraits>::TreeType* +CommonTreeAdaptor<ImplTraits>::create( CommonTokenType* payload) { return new TreeType(payload); } template<class ImplTraits> -typename CommonTreeAdaptor<ImplTraits>::TreeType* CommonTreeAdaptor<ImplTraits>::createTypeToken( ANTLR_UINT32 tokenType, - CommonTokenType* fromToken) +typename CommonTreeAdaptor<ImplTraits>::TreeType* +CommonTreeAdaptor<ImplTraits>::create( ANTLR_UINT32 tokenType, CommonTokenType* fromToken) { - /* Create the new token - */ - fromToken = this->createTokenFromToken(fromToken); - - /* Set the type of the new token to that supplied - */ + /* Create the new token */ + fromToken = this->createToken(fromToken); + /* Set the type of the new token to that supplied */ fromToken->setType(tokenType); - - /* Return a new node based upon this token - */ - return this->create(fromToken); - + /* Return a new node based upon this token */ + return this->create(fromToken); } template<class ImplTraits> -typename CommonTreeAdaptor<ImplTraits>::TreeType* CommonTreeAdaptor<ImplTraits>::createTypeTokenText( ANTLR_UINT32 tokenType, CommonTokenType* fromToken, const char* text) +typename CommonTreeAdaptor<ImplTraits>::TreeType* +CommonTreeAdaptor<ImplTraits>::create( ANTLR_UINT32 tokenType, CommonTokenType* fromToken, const char* text) { - /* Create the new token - */ - fromToken = this->createTokenFromToken(fromToken); - - /* Set the type of the new token to that supplied - */ + if (fromToken == NULL) + return create(tokenType, text); + /* Create the new token */ + fromToken = this->createToken(fromToken); + /* Set the type of the new token to that supplied */ fromToken->setType(tokenType); - - /* Set the text of the token accordingly - */ + /* Set the text of the token accordingly */ fromToken->setText(text); - - /* Return a new node based upon this token - */ + /* Return a new node based upon this token */ return this->create(fromToken); } template<class ImplTraits> -typename CommonTreeAdaptor<ImplTraits>::TreeType* CommonTreeAdaptor<ImplTraits>::createTypeText( ANTLR_UINT32 tokenType, const char* text) +typename CommonTreeAdaptor<ImplTraits>::TreeType* +CommonTreeAdaptor<ImplTraits>::create( ANTLR_UINT32 tokenType, const char* text) { - CommonTokenType* fromToken; - - /* Create the new token - */ - fromToken = this->createToken(tokenType, text); - - /* Return a new node based upon this token - */ + CommonTokenType* fromToken = this->createToken(tokenType, text); return this->create(fromToken); } template<class ImplTraits> -typename CommonTreeAdaptor<ImplTraits>::TreeType* CommonTreeAdaptor<ImplTraits>::dupNode( TreeType* treeNode) +typename CommonTreeAdaptor<ImplTraits>::TreeType* CommonTreeAdaptor<ImplTraits>::dupNode( TreeType* treeNode) { return (treeNode == NULL) ? NULL : treeNode->dupNode(); } @@ -242,6 +230,8 @@ template<class ImplTraits> ANTLR_UINT32 CommonTreeAdaptor<ImplTraits>::getType( TreeType* t) { + if ( t==NULL) + return CommonTokenType::TOKEN_INVALID; return t->getType(); } @@ -254,6 +244,8 @@ template<class ImplTraits> typename CommonTreeAdaptor<ImplTraits>::TreeType* CommonTreeAdaptor<ImplTraits>::getChild( TreeType* t, ANTLR_UINT32 i) { + if ( t==NULL ) + return NULL; return t->getChild(i); } @@ -272,18 +264,23 @@ template<class ImplTraits> void CommonTreeAdaptor<ImplTraits>::setChildIndex( TreeType* t, ANTLR_INT32 i) { - t->setChildIndex(i); + if( t!= NULL) + t->setChildIndex(i); } template<class ImplTraits> ANTLR_INT32 CommonTreeAdaptor<ImplTraits>::getChildIndex( TreeType * t) { + if ( t==NULL ) + return 0; return t->getChildIndex(); } template<class ImplTraits> ANTLR_UINT32 CommonTreeAdaptor<ImplTraits>::getChildCount( TreeType* t) { + if ( t==NULL ) + return 0; return t->getChildCount(); } @@ -310,27 +307,9 @@ template<class ImplTraits> typename CommonTreeAdaptor<ImplTraits>::CommonTokenType* - CommonTreeAdaptor<ImplTraits>::createTokenFromToken( CommonTokenType* fromToken) + CommonTreeAdaptor<ImplTraits>::createToken( CommonTokenType* fromToken) { - CommonTokenType* newToken; - - newToken = new CommonTokenType; - - if (newToken != NULL) - { - // Create the text using our own string factory to avoid complicating - // commontoken. - // - StringType text = fromToken->getText(); - newToken->set_tokText( text ); - newToken->setLine( fromToken->getLine() ); - newToken->setTokenIndex( fromToken->getTokenIndex() ); - newToken->setCharPositionInLine( fromToken->getCharPositionInLine() ); - newToken->setChannel( fromToken->getChannel() ); - newToken->setType( fromToken->getType() ); - } - - return newToken; + return new CommonTokenType(fromToken); } template<class ImplTraits> @@ -343,50 +322,36 @@ template<class ImplTraits> void CommonTreeAdaptor<ImplTraits>::setTokenBoundaries( TreeType* t, const CommonTokenType* startToken, const CommonTokenType* stopToken) { - ANTLR_MARKER start; - ANTLR_MARKER stop; + ANTLR_MARKER start = 0; + ANTLR_MARKER stop = 0; - TreeType* ct; - if (t == NULL) - { return; - } if ( startToken != NULL) - { start = startToken->getTokenIndex(); - } - else - { - start = 0; - } if ( stopToken != NULL) - { stop = stopToken->getTokenIndex(); - } - else - { - stop = 0; - } - ct = t; - - ct->setStartIndex(start); - ct->setStopIndex(stop); + t->setStartIndex(start); + t->setStopIndex(stop); } template<class ImplTraits> -ANTLR_MARKER CommonTreeAdaptor<ImplTraits>::getTokenStartIndex( TreeType* t) +ANTLR_MARKER CommonTreeAdaptor<ImplTraits>::getStartIndex( TreeType* t) { - return t->get_tokenStartIndex(); + if ( t==NULL ) + return -1; + return t->getStartIndex(); } template<class ImplTraits> -ANTLR_MARKER CommonTreeAdaptor<ImplTraits>::getTokenStopIndex( TreeType* t) +ANTLR_MARKER CommonTreeAdaptor<ImplTraits>::getStopIndex( TreeType* t) { - return t->get_tokenStopIndex(); + if ( t==NULL ) + return -1; + return t->getStopIndex(); } template<class ImplTraits> @@ -646,13 +611,8 @@ template<class ImplTraits> typename CommonTreeAdaptor<ImplTraits>::TreeType* CommonTreeAdaptor<ImplTraits>::rulePostProcessing( TreeType* root) { - TreeType* saveRoot; + TreeType* saveRoot = root; - // Keep track of the root we are given. If it is a nilNode, then we - // can reuse it rather than orphaning it! - // - saveRoot = root; - if (root != NULL && root->isNilNode()) { if (root->getChildCount() == 0) Modified: branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/AST.stg =================================================================== --- branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/AST.stg 2013-05-17 08:15:34 UTC (rev 4646) +++ branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/AST.stg 2013-05-17 09:01:14 UTC (rev 4647) @@ -118,7 +118,7 @@ <if(autoAST)> <if(outerAlt)> <if(!rewriteMode && !ruleDescriptor.isSynPred)> -root_0 = (<ASTLabelType>)TreeAdaptorType::nilNode();<\n> +root_0 = TreeAdaptorType::nilNode();<\n> <endif> <endif> <endif> @@ -202,12 +202,12 @@ <endif> <prevRuleRootRef()>.tree = root_0; <rewriteCodeLabels()> -root_0 = (<ASTLabelType>)TreeAdaptorType::nilNode(); +root_0 = TreeAdaptorType::nilNode(); <alts:rewriteAlt(); separator="else "> <! if tree parser and rewrite=true !> <if(TREE_PARSER)> <if(rewriteMode)> -<prevRuleRootRef()>.tree = (<ASTLabelType>)TreeAdaptorType::rulePostProcessing(root_0); +<prevRuleRootRef()>.tree = TreeAdaptorType::rulePostProcessing(root_0); input.replaceChildren(TreeAdaptorType::getParent(retval.start), TreeAdaptorType::getChildIndex(retval.start), TreeAdaptorType::getChildIndex(_last), @@ -317,7 +317,7 @@ rewriteTree(root,children,description,enclosingTreeLevel,treeLevel) ::= << // <fileName>:<description> { -<ASTLabelType> root_<treeLevel> = (<ASTLabelType>)TreeAdaptorType::nilNode(); +<ASTLabelType> root_<treeLevel> = TreeAdaptorType::nilNode(); <root:rewriteElement()> <children:rewriteElement()> TreeAdaptorType::addChild(root_<enclosingTreeLevel>, root_<treeLevel>); @@ -348,7 +348,7 @@ /** Gen ^($label ...) */ rewriteTokenLabelRefRoot(label,elementIndex) ::= << -root_<treeLevel> = (<ASTLabelType>)TreeAdaptorType::becomeRoot(stream_<label>->nextNode(), root_<treeLevel>); +root_<treeLevel> = TreeAdaptorType::becomeRoot(stream_<label>->nextNode(), root_<treeLevel>); >> /** Gen ^($label ...) where label+=... */ @@ -356,7 +356,7 @@ /** Gen ^(ID ...) or ^(ID[args] ...) */ rewriteTokenRefRoot(token,elementIndex,args,terminalOptions={}) ::= << -root_<treeLevel> = (<ASTLabelType>)TreeAdaptorType::becomeRoot(<createRewriteNodeFromElement(...)>, root_<treeLevel>); +root_<treeLevel> = TreeAdaptorType::becomeRoot(<createRewriteNodeFromElement(...)>, root_<treeLevel>); >> rewriteImaginaryTokenRef(args,token,elementIndex,terminalOptions={}) ::= << @@ -364,7 +364,7 @@ >> rewriteImaginaryTokenRefRoot(args,token,elementIndex,terminalOptions={}) ::= << -root_<treeLevel> = (<ASTLabelType>)TreeAdaptorType::becomeRoot(<createImaginaryNode(token,args,terminalOptions)>, root_<treeLevel>); +root_<treeLevel> = TreeAdaptorType::becomeRoot(<createImaginaryNode(token,args,terminalOptions)>, root_<treeLevel>); >> /** plain -> {foo} action */ @@ -384,7 +384,7 @@ >> rewriteRuleRefRoot(rule) ::= << -root_<treeLevel> = (<ASTLabelType>)TreeAdaptorType::becomeRoot(stream_<rule>->nextNode(), root_<treeLevel>); +root_<treeLevel> = TreeAdaptorType::becomeRoot(stream_<rule>->nextNode(), root_<treeLevel>); >> rewriteNodeAction(action) ::= << @@ -392,7 +392,7 @@ >> rewriteNodeActionRoot(action) ::= << -root_<treeLevel> = (<ASTLabelType>)TreeAdaptorType::becomeRoot(<action>, root_<treeLevel>); +root_<treeLevel> = TreeAdaptorType::becomeRoot(<action>, root_<treeLevel>); >> /** Gen $ruleLabel ... where defined via ruleLabel=rule */ @@ -407,12 +407,12 @@ /** Gen ^($ruleLabel ...) where ruleLabel=rule */ rewriteRuleLabelRefRoot(label) ::= << -root_<treeLevel> = (<ASTLabelType>)TreeAdaptorType::becomeRoot(stream_<label>->nextNode(), root_<treeLevel>); +root_<treeLevel> = TreeAdaptorType::becomeRoot(stream_<label>->nextNode(), root_<treeLevel>); >> /** Gen ^($ruleLabel ...) where ruleLabel+=rule */ rewriteRuleListLabelRefRoot(label) ::= << -root_<treeLevel> = (<ASTLabelType>)TreeAdaptorType::becomeRoot(stream_<label>->nextNode(), root_<treeLevel>); +root_<treeLevel> = TreeAdaptorType::becomeRoot(stream_<label>->nextNode(), root_<treeLevel>); >> rewriteWildcardLabelRef(label) ::= << @@ -425,7 +425,7 @@ <! new MethodNode(IDLabel, args) !> new <terminalOptions.node>(<tokenType><if(args)>, <args; separator=", "><endif>) <else> -(<ASTLabelType>)TreeAdaptorType::createTypeText(<tokenType>, <args; separator=", "><if(!args)>"<tokenType>"<endif>) +TreeAdaptorType::create(<tokenType>, <args; separator=", "><if(!args)>"<tokenType>"<endif>) <endif> %> This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <ibr...@us...> - 2013-05-17 11:22:00
|
Revision: 4648 http://sourceforge.net/p/tora/code/4648 Author: ibre5041 Date: 2013-05-17 11:21:56 +0000 (Fri, 17 May 2013) Log Message: ----------- Modified Paths: -------------- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.inl branches/tora3/extlibs/parsing.cpp/Makefile branches/tora3/extlibs/parsing.cpp/UserGuiTraits.hpp branches/tora3/extlibs/parsing.cpp/UserMiniTraits.hpp branches/tora3/extlibs/parsing.cpp/antlr-complete-3.5.1-SNAPSHOT.jar branches/tora3/extlibs/parsing.cpp/input/simple01.sql branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/Cpp.stg branches/tora3/extlibs/parsing.cpp/utils.cpp Added Paths: ----------- branches/tora3/extlibs/parsing.cpp/S1.g branches/tora3/extlibs/parsing.cpp/S2.g branches/tora3/extlibs/parsing.cpp/s1.cpp branches/tora3/extlibs/parsing.cpp/s2.cpp Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.inl 2013-05-17 09:01:14 UTC (rev 4647) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.inl 2013-05-17 11:21:56 UTC (rev 4648) @@ -144,106 +144,84 @@ template<class ImplTraits> void CommonTree<ImplTraits>::replaceChildren(ANTLR_INT32 startChildIndex, ANTLR_INT32 stopChildIndex, TreeType* newTree) { - ANTLR_INT32 replacingHowMany; // How many nodes will go away - ANTLR_INT32 replacingWithHowMany; // How many nodes will replace them + ANTLR_INT32 numNewChildren; // Tracking variable ANTLR_INT32 delta; // Difference in new vs existing count - ANTLR_INT32 i; - ANTLR_INT32 j; - if ( m_children.empty() ) { fprintf(stderr, "replaceChildren call: Indexes are invalid; no children in list for %s", this->getText().c_str() ); + // TODO throw here return; } + // How many nodes will go away + ANTLR_INT32 replacingHowMany = stopChildIndex - startChildIndex + 1; + ANTLR_INT32 replacingWithHowMany; // How many nodes will replace them // Either use the existing list of children in the supplied nil node, or build a vector of the // tree we were given if it is not a nil node, then we treat both situations exactly the same // - ChildrenType newChildren_temp; - ChildrenType* newChildren; // Iterator for whatever we are going to add in + ChildrenType newChildren; + ChildrenType &newChildrenRef(newChildren); if (newTree->isNilNode()) { - newChildren = newTree->get_children_p(); + newChildrenRef = newTree->getChildren(); + } else { + newChildrenRef.push_back(newTree); } - else - { - newChildren = &newChildren_temp; - newChildren->push_back(newTree); - } // Initialize - // - replacingHowMany = stopChildIndex - startChildIndex + 1; - replacingWithHowMany = newChildren->size(); + replacingWithHowMany = newChildrenRef.size(); + numNewChildren = newChildrenRef.size(); delta = replacingHowMany - replacingWithHowMany; - numNewChildren = newChildren->size(); // If it is the same number of nodes, then do a direct replacement // if (delta == 0) { - TreeType* child; - - // Same number of nodes - // - j = 0; - for (i = startChildIndex; i <= stopChildIndex; i++) + ANTLR_INT32 j = 0; + for (ANTLR_INT32 i = startChildIndex; i <= stopChildIndex; i++) { - child = newChildren->at(j); - ChildrenType& parent_children = this->getChildren(); - parent_children[i] = child; + TreeType *child = newChildrenRef.at(j); + m_children[i] = child; child->setParent(this); child->setChildIndex(i); + j++; } } else if (delta > 0) { - ANTLR_UINT32 indexToDelete; - // Less nodes than there were before // reuse what we have then delete the rest - // - ChildrenType& parent_children = this->getChildren(); - for (j = 0; j < numNewChildren; j++) + for (ANTLR_UINT32 j = 0; j < numNewChildren; j++) { - parent_children[ startChildIndex + j ] = newChildren->at(j); + m_children[ startChildIndex + j ] = newChildrenRef.at(j); } - // We just delete the same index position until done - // - indexToDelete = startChildIndex + numNewChildren; - - for (j = indexToDelete; j <= stopChildIndex; j++) + ANTLR_UINT32 indexToDelete = startChildIndex + numNewChildren; + for (ANTLR_UINT32 j = indexToDelete; j <= stopChildIndex; j++) { - parent_children.erase( parent_children.begin() + indexToDelete); + m_children.erase( m_children.begin() + indexToDelete); } - - this->freshenPACIndexes(startChildIndex); + this->freshenParentAndChildIndexes(startChildIndex); } else { - ChildrenType& parent_children = this->getChildren(); - ANTLR_UINT32 numToInsert; - // More nodes than there were before // Use what we can, then start adding - // - for (j = 0; j < replacingHowMany; j++) + for (ANTLR_UINT32 j = 0; j < replacingHowMany; j++) { - parent_children[ startChildIndex + j ] = newChildren->at(j); + m_children[ startChildIndex + j ] = newChildrenRef.at(j); } - numToInsert = replacingWithHowMany - replacingHowMany; - - for (j = replacingHowMany; j < replacingWithHowMany; j++) + ANTLR_UINT32 numToInsert = replacingWithHowMany - replacingHowMany; + for (ANTLR_UINT32 j = replacingHowMany; j < replacingWithHowMany; j++) { - parent_children.push_back( newChildren->at(j) ); + m_children.push_back( newChildrenRef.at(j) ); } - this->freshenPACIndexes(startChildIndex); + this->freshenParentAndChildIndexes(startChildIndex); } } Modified: branches/tora3/extlibs/parsing.cpp/Makefile =================================================================== --- branches/tora3/extlibs/parsing.cpp/Makefile 2013-05-17 09:01:14 UTC (rev 4647) +++ branches/tora3/extlibs/parsing.cpp/Makefile 2013-05-17 11:21:56 UTC (rev 4648) @@ -18,7 +18,7 @@ TOBJS= utils.o -all: t0 m0 p0 s0 s1 +all: t0 t1 t2 t4 m0 p0 s0 s1 s2 $(ANTLR): org/antlr/codegen/templates/Cpp/Cpp.stg \ org/antlr/codegen/templates/Cpp/AST.stg \ @@ -49,11 +49,14 @@ s0: s0.cpp SQLMini.tokens $(TOBJS) Makefile UserMiniTraits.hpp g++ $(CFLAGS) -DUSESTL $(INCLUDES) $(TOBJS) s0.cpp SQLMiniLexer.cpp SQLMiniParser.cpp $(LIBS) -o $@ -s1: s1.cpp S.tokens $(TOBJS) Makefile UserMiniTraits.hpp - g++ $(CFLAGS) -DUSESTL $(INCLUDES) $(TOBJS) s1.cpp SLexer.cpp SParser.cpp $(LIBS) -o $@ +s1: s1.cpp S1.tokens $(TOBJS) Makefile UserMiniTraits.hpp + g++ $(CFLAGS) -DUSESTL $(INCLUDES) $(TOBJS) s1.cpp S1Lexer.cpp S1Parser.cpp $(LIBS) -o $@ +s2: s2.cpp S2.tokens $(TOBJS) Makefile UserMiniTraits.hpp + g++ $(CFLAGS) -DUSESTL $(INCLUDES) $(TOBJS) s2.cpp S2Lexer.cpp S2Parser.cpp $(LIBS) -o $@ + clean: - rm -f *.o *GuiLexer*.[ch]pp PLSQLLexer*.[ch]pp PLSQL*[ch]pp t0 t1 t2 t3 t4 m0 s0 s1 *.tokens SQLMini*.[ch]pp + rm -f *.o *Lexer*.[ch]pp *Parser.[ch]pp t0 t1 t2 t3 t4 m0 s0 s1 s2 *.tokens %.u: %.g @echo "Bulding dependencies for "$< Added: branches/tora3/extlibs/parsing.cpp/S1.g =================================================================== --- branches/tora3/extlibs/parsing.cpp/S1.g (rev 0) +++ branches/tora3/extlibs/parsing.cpp/S1.g 2013-05-17 11:21:56 UTC (rev 4648) @@ -0,0 +1,69 @@ +grammar S1; + +options { + language=Cpp; + //backtrack=true; + //memoize=true; + output=AST; +} + +tokens { + BLOCK = 'block'; +} + +@lexer::includes +{ +#include "UserMiniTraits.hpp" +} +@lexer::namespace +{ Antlr3Mini } + +@parser::includes { +#include "UserMiniTraits.hpp" +#include "S1Lexer.hpp" +} +@parser::namespace +{ Antlr3Mini } + +start_rule : if_statement; + +if_statement + : /*ifSt=*/IF LEFT_PAREN /*cond=*/expression RIGHT_PAREN if_then if_else? + //-> ^(IF_ST[$ifSt] $cond if_then if_else?) + ; +if_then + : th=LEFT_BRACE /*thexpr=*/script? RIGHT_BRACE //-> ^(BLOCK[$th] $thexpr?) + | /*cs=*/script //-> ^(BLOCK $cs) + ; + +if_else + : el=ELSE LEFT_BRACE elexpr=script? RIGHT_BRACE //-> ^(BLOCK[$el] $elexpr?) + | el=ELSE /*cs=*/script//-> ^(BLOCK[$el] $cs) + ; + +script + : COMMAND SEMI + ; + +expression + : EXPRESSION + ; + +COMMAND: 'COMMAND'; + +EXPRESSION: 'EXPRESSION'; + +SEMI: ';'; + +ELSE: 'ELSE'; + +IF: 'IF'; + +LEFT_PAREN: '('; + +RIGHT_PAREN: ')'; + +LEFT_BRACE: '{'; + +RIGHT_BRACE: '}'; + Property changes on: branches/tora3/extlibs/parsing.cpp/S1.g ___________________________________________________________________ Added: svn:executable ## -0,0 +1 ## +* \ No newline at end of property Added: branches/tora3/extlibs/parsing.cpp/S2.g =================================================================== --- branches/tora3/extlibs/parsing.cpp/S2.g (rev 0) +++ branches/tora3/extlibs/parsing.cpp/S2.g 2013-05-17 11:21:56 UTC (rev 4648) @@ -0,0 +1,86 @@ +grammar S2; + +options { + language=Cpp; + //backtrack=true; + //memoize=true; + output=AST; +} + +tokens { + BLOCK = 'block'; +} + +scope GlobalOne { + std::string globalFoo; +} + +@lexer::includes +{ +#include "UserMiniTraits.hpp" +} +@lexer::namespace +{ Antlr3Mini } + +@parser::includes { +#include "UserMiniTraits.hpp" +#include "S2Lexer.hpp" +#include <string> +} +@parser::namespace +{ Antlr3Mini } + + +start_rule +scope { + std::string localFoo; +} +scope GlobalOne; +@init { +} +: if_statement; + +if_statement + : ifSt=IF LEFT_PAREN /*cond=*/expression RIGHT_PAREN if_then if_else? + //-> ^(IF_ST[$ifSt] $cond if_then if_else?) + { + $GlobalOne::globalFoo.append(".").append($ifSt->getText()); + $start_rule::localFoo.append(".").append($ifSt->getText()); + } + ; +if_then + : th=LEFT_BRACE /*thexpr=*/script? RIGHT_BRACE //-> ^(BLOCK[$th] $thexpr?) + | /*cs=*/script //-> ^(BLOCK $cs) + ; + +if_else + : el=ELSE LEFT_BRACE elexpr=script? RIGHT_BRACE //-> ^(BLOCK[$el] $elexpr?) + | el=ELSE /*cs=*/script//-> ^(BLOCK[$el] $cs) + ; + +script + : COMMAND SEMI + ; + +expression + : EXPRESSION + ; + +COMMAND: 'COMMAND'; + +EXPRESSION: 'EXPRESSION'; + +SEMI: ';'; + +ELSE: 'ELSE'; + +IF: 'IF'; + +LEFT_PAREN: '('; + +RIGHT_PAREN: ')'; + +LEFT_BRACE: '{'; + +RIGHT_BRACE: '}'; + Property changes on: branches/tora3/extlibs/parsing.cpp/S2.g ___________________________________________________________________ Added: svn:executable ## -0,0 +1 ## +* \ No newline at end of property Modified: branches/tora3/extlibs/parsing.cpp/UserGuiTraits.hpp =================================================================== --- branches/tora3/extlibs/parsing.cpp/UserGuiTraits.hpp 2013-05-17 09:01:14 UTC (rev 4647) +++ branches/tora3/extlibs/parsing.cpp/UserGuiTraits.hpp 2013-05-17 11:21:56 UTC (rev 4648) @@ -88,6 +88,7 @@ typedef antlr3::Traits<OraclePLSQLLexer, OraclePLSQLParser, UserTraits> OraclePLSQLLexerTraits; typedef antlr3::Traits<OraclePLSQLLexer, OraclePLSQLParser, UserTraits> OraclePLSQLParserTraits; + }; namespace Antlr3Impl Modified: branches/tora3/extlibs/parsing.cpp/UserMiniTraits.hpp =================================================================== --- branches/tora3/extlibs/parsing.cpp/UserMiniTraits.hpp 2013-05-17 09:01:14 UTC (rev 4647) +++ branches/tora3/extlibs/parsing.cpp/UserMiniTraits.hpp 2013-05-17 11:21:56 UTC (rev 4648) @@ -15,8 +15,13 @@ namespace Antlr3Mini { class SQLMiniLexer; class SQLMiniParser; - class SLexer; - class SParser; + + class S1Lexer; + class S1Parser; + + class S2Lexer; + class S2Parser; + }; namespace Antlr3Mini { @@ -30,9 +35,12 @@ typedef antlr3::Traits<SQLMiniLexer, SQLMiniParser, UserTraits> SQLMiniLexerTraits; typedef SQLMiniLexerTraits SQLMiniParserTraits; -typedef antlr3::Traits<SLexer, SParser, UserTraits> SLexerTraits; -typedef antlr3::Traits<SLexer, SParser, UserTraits> SParserTraits; +typedef antlr3::Traits<S1Lexer, S1Parser, UserTraits> S1LexerTraits; +typedef antlr3::Traits<S1Lexer, S1Parser, UserTraits> S1ParserTraits; +typedef antlr3::Traits<S2Lexer, S2Parser, UserTraits> S2LexerTraits; +typedef antlr3::Traits<S2Lexer, S2Parser, UserTraits> S2ParserTraits; + }; #endif Modified: branches/tora3/extlibs/parsing.cpp/antlr-complete-3.5.1-SNAPSHOT.jar =================================================================== (Binary files differ) Modified: branches/tora3/extlibs/parsing.cpp/input/simple01.sql =================================================================== --- branches/tora3/extlibs/parsing.cpp/input/simple01.sql 2013-05-17 09:01:14 UTC (rev 4647) +++ branches/tora3/extlibs/parsing.cpp/input/simple01.sql 2013-05-17 11:21:56 UTC (rev 4648) @@ -1,4 +1,4 @@ -for update of xyz.a123.g5556 +for update of xyz.a123.g5556 for update of abc.b789.h8888 /*#1234*/ --fdskfjsdfk /* Modified: branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/Cpp.stg =================================================================== --- branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/Cpp.stg 2013-05-17 09:01:14 UTC (rev 4647) +++ branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/Cpp.stg 2013-05-17 11:21:56 UTC (rev 4648) @@ -358,7 +358,6 @@ typedef <name>Traits <name>ImplTraits; <rules:{r | <if(r.ruleDescriptor.isSynPred)> struct <r.ruleDescriptor.name> {\}; <endif>}; separator="\n"> -<rules:{r | <if(r.ruleDescriptor.ruleScope)><headerReturnScope(ruleDescriptor=r.ruleDescriptor,...)><endif>}> class <name>Tokens { Added: branches/tora3/extlibs/parsing.cpp/s1.cpp =================================================================== --- branches/tora3/extlibs/parsing.cpp/s1.cpp (rev 0) +++ branches/tora3/extlibs/parsing.cpp/s1.cpp 2013-05-17 11:21:56 UTC (rev 4648) @@ -0,0 +1,202 @@ +// Example of a grammar for parsing Java sources, +// Adapted from Java equivalent example, by Terence Parr +// Author: Jim Idle - April 2007 +// Permission is granted to use this example code in any way you want, so long as +// all the original authors are cited. +// + +// set ts=4,sw=4 +// Tab size is 4 chars, indent is 4 chars + +// Notes: Although all the examples provided are configured to be built +// by Visual Studio 2005, based on the custom build rules +// provided in $(ANTLRSRC)/code/antlr/main/runtime/C/vs2005/rulefiles/antlr3.rules +// there is no reason that this MUST be the case. Provided that you know how +// to run the antlr tool, then just compile the resulting .c files and this +// file together, using say gcc or whatever: gcc *.c -I. -o XXX +// The C code is generic and will compile and run on all platforms (please +// report any warnings or errors to the antlr-interest newsgroup (see www.antlr.org) +// so that they may be corrected for any platofrm that I have not specifically tested. +// +// The project settings such as addinotal library paths and include paths have been set +// relative to the place where this source code sits on the ANTLR perforce system. You +// may well need to change the settings to locate the includes and the lib files. UNIX +// people need -L path/to/antlr/libs -lantlr3c (release mode) or -lantlr3cd (debug) +// +// Jim Idle (jimi cut-this at idle ws) +// + +// You may adopt your own practices by all means, but in general it is best +// to create a single include for your project, that will include the ANTLR3 C +// runtime header files, the generated header files (all of which are safe to include +// multiple times) and your own project related header files. Use <> to include and +// -I on the compile line (which vs2005 now handles, where vs2003 did not). +// + +#include "utils.hpp" +#include "UserMiniTraits.hpp" +#include "S1Lexer.hpp" +#include "S1Parser.hpp" + +#include <sys/types.h> + +#include <iostream> +#include <sstream> +#include <fstream> + +using namespace Antlr3Mini; +using namespace std; + +// The lexer is of course generated by ANTLR, and so the lexer type is not upper case. +// The lexer is supplied with a pANTLR3_INPUT_STREAM from whence it consumes its +// input and generates a token stream as output. +// +static S1Lexer* lxr; + +// Main entry point for this example +// +int +main (int argc, char *argv[]) +{ + // Create the input stream based upon the argument supplied to us on the command line + // for this example, the input will always default to ./input if there is no explicit + // argument, otherwise we are expecting potentially a whole list of 'em. + // + if (argc < 2 || argv[1] == NULL) + { + Utils::processDir("./input"); // Note in VS2005 debug, working directory must be configured + } + else + { + int i; + + for (i = 1; i < argc; i++) + { + Utils::processDir(argv[i]); + } + } + + printf("finished parsing OK\n"); // Finnish parking is pretty good - I think it is all the snow + + return 0; +} + +void parseFile(const char* fName, int fd) +{ + // Now we declare the ANTLR related local variables we need. + // Note that unless you are convinced you will never need thread safe + // versions for your project, then you should always create such things + // as instance variables for each invocation. + // ------------------- + + // The ANTLR3 character input stream, which abstracts the input source such that + // it is easy to privide inpput from different sources such as files, or + // memory strings. + // + // For an ASCII/latin-1 memory string use: + // input = antlr3NewAsciiStringInPlaceStream (stringtouse, (ANTLR3_UINT64) length, NULL); + // + // For a UCS2 (16 bit) memory string use: + // input = antlr3NewUCS2StringInPlaceStream (stringtouse, (ANTLR3_UINT64) length, NULL); + // + // For input from a file, see code below + // + // Note that this is essentially a pointer to a structure containing pointers to functions. + // You can create your own input stream type (copy one of the existing ones) and override any + // individual function by installing your own pointer after you have created the standard + // version. + // + S1LexerTraits::InputStreamType* input; + + + // The token stream is produced by the ANTLR3 generated lexer. Again it is a structure based + // API/Object, which you can customise and override methods of as you wish. a Token stream is + // supplied to the generated parser, and you can write your own token stream and pass this in + // if you wish. + // + S1LexerTraits::TokenStreamType* tstream; + + // The C parser is also generated by ANTLR and accepts a token stream as explained + // above. The token stream can be any source in fact, so long as it implements the + // ANTLR3_TOKEN_SOURCE interface. In this case the parser does not return anything + // but it can of course specify any kind of return type from the rule you invoke + // when calling it. + // + S1Parser* psr; + + // Create the input stream using the supplied file name + // (Use antlr3AsciiFileStreamNew for UCS2/16bit input). + // + ///byIvan input = new PLSQLTraits::InputStreamType(fName, ANTLR_ENC_8BIT); +#if defined __linux + string data = Utils::slurp(fd); +#else + string data = Utils::slurp(fName); +#endif + input = new S1LexerTraits::InputStreamType((const ANTLR_UINT8 *)data.c_str(), + ANTLR_ENC_8BIT, + data.length(), //strlen(data.c_str()), + (ANTLR_UINT8*)fName); + + input->setUcaseLA(true); + + // Our input stream is now open and all set to go, so we can create a new instance of our + // lexer and set the lexer input to our input stream: + // (file | memory | ?) --> inputstream -> lexer --> tokenstream --> parser ( --> treeparser )? + // + if (lxr == NULL) + { + lxr = new S1Lexer(input); // javaLexerNew is generated by ANTLR + } + else + { + lxr->setCharStream(input); + } + + // Our lexer is in place, so we can create the token stream from it + // NB: Nothing happens yet other than the file has been read. We are just + // connecting all these things together and they will be invoked when we + // call the parser rule. ANTLR3_SIZE_HINT can be left at the default usually + // unless you have a very large token stream/input. Each generated lexer + // provides a token source interface, which is the second argument to the + // token stream creator. + // Note tha even if you implement your own token structure, it will always + // contain a standard common token within it and this is the pointer that + // you pass around to everything else. A common token as a pointer within + // it that should point to your own outer token structure. + // + tstream = new S1LexerTraits::TokenStreamType(ANTLR_SIZE_HINT, lxr->getTokSource()); + + // Finally, now that we have our lexer constructed, we can create the parser + // + psr = new S1Parser(tstream); // javaParserNew is generated by ANTLR3 + + // Note that this means only that the methods are always called via the object + // pointer and the first argument to any method, is a pointer to the structure itself. + // It also has the side advantage, if you are using an IDE such as VS2005 that can do it + // that when you type ->, you will see a list of tall the methods the object supports. + // + putc('L', stdout); fflush(stdout); + { + ANTLR_INT32 T = 0; + while (T != S1Lexer::EOF_TOKEN) + { + T = tstream->_LA(1); + S1LexerTraits::CommonTokenType const* token = tstream->_LT(1); + ANTLR_UINT8 const *name = lxr->getTokenName(T); + + printf("%d %s\t\"%s\"\n", + T, + name, + tstream->_LT(1)->getText().c_str() + ); + tstream->consume(); + } + } + + tstream->_LT(1); // Don't do this mormally, just causes lexer to run for timings here + + delete tstream; + delete lxr; lxr = NULL; + delete input; +} Property changes on: branches/tora3/extlibs/parsing.cpp/s1.cpp ___________________________________________________________________ Added: svn:executable ## -0,0 +1 ## +* \ No newline at end of property Added: branches/tora3/extlibs/parsing.cpp/s2.cpp =================================================================== --- branches/tora3/extlibs/parsing.cpp/s2.cpp (rev 0) +++ branches/tora3/extlibs/parsing.cpp/s2.cpp 2013-05-17 11:21:56 UTC (rev 4648) @@ -0,0 +1,202 @@ +// Example of a grammar for parsing Java sources, +// Adapted from Java equivalent example, by Terence Parr +// Author: Jim Idle - April 2007 +// Permission is granted to use this example code in any way you want, so long as +// all the original authors are cited. +// + +// set ts=4,sw=4 +// Tab size is 4 chars, indent is 4 chars + +// Notes: Although all the examples provided are configured to be built +// by Visual Studio 2005, based on the custom build rules +// provided in $(ANTLRSRC)/code/antlr/main/runtime/C/vs2005/rulefiles/antlr3.rules +// there is no reason that this MUST be the case. Provided that you know how +// to run the antlr tool, then just compile the resulting .c files and this +// file together, using say gcc or whatever: gcc *.c -I. -o XXX +// The C code is generic and will compile and run on all platforms (please +// report any warnings or errors to the antlr-interest newsgroup (see www.antlr.org) +// so that they may be corrected for any platofrm that I have not specifically tested. +// +// The project settings such as addinotal library paths and include paths have been set +// relative to the place where this source code sits on the ANTLR perforce system. You +// may well need to change the settings to locate the includes and the lib files. UNIX +// people need -L path/to/antlr/libs -lantlr3c (release mode) or -lantlr3cd (debug) +// +// Jim Idle (jimi cut-this at idle ws) +// + +// You may adopt your own practices by all means, but in general it is best +// to create a single include for your project, that will include the ANTLR3 C +// runtime header files, the generated header files (all of which are safe to include +// multiple times) and your own project related header files. Use <> to include and +// -I on the compile line (which vs2005 now handles, where vs2003 did not). +// + +#include "utils.hpp" +#include "UserMiniTraits.hpp" +#include "S2Lexer.hpp" +#include "S2Parser.hpp" + +#include <sys/types.h> + +#include <iostream> +#include <sstream> +#include <fstream> + +using namespace Antlr3Mini; +using namespace std; + +// The lexer is of course generated by ANTLR, and so the lexer type is not upper case. +// The lexer is supplied with a pANTLR3_INPUT_STREAM from whence it consumes its +// input and generates a token stream as output. +// +static S2Lexer* lxr; + +// Main entry point for this example +// +int +main (int argc, char *argv[]) +{ + // Create the input stream based upon the argument supplied to us on the command line + // for this example, the input will always default to ./input if there is no explicit + // argument, otherwise we are expecting potentially a whole list of 'em. + // + if (argc < 2 || argv[1] == NULL) + { + Utils::processDir("./input"); // Note in VS2005 debug, working directory must be configured + } + else + { + int i; + + for (i = 1; i < argc; i++) + { + Utils::processDir(argv[i]); + } + } + + printf("finished parsing OK\n"); // Finnish parking is pretty good - I think it is all the snow + + return 0; +} + +void parseFile(const char* fName, int fd) +{ + // Now we declare the ANTLR related local variables we need. + // Note that unless you are convinced you will never need thread safe + // versions for your project, then you should always create such things + // as instance variables for each invocation. + // ------------------- + + // The ANTLR3 character input stream, which abstracts the input source such that + // it is easy to privide inpput from different sources such as files, or + // memory strings. + // + // For an ASCII/latin-1 memory string use: + // input = antlr3NewAsciiStringInPlaceStream (stringtouse, (ANTLR3_UINT64) length, NULL); + // + // For a UCS2 (16 bit) memory string use: + // input = antlr3NewUCS2StringInPlaceStream (stringtouse, (ANTLR3_UINT64) length, NULL); + // + // For input from a file, see code below + // + // Note that this is essentially a pointer to a structure containing pointers to functions. + // You can create your own input stream type (copy one of the existing ones) and override any + // individual function by installing your own pointer after you have created the standard + // version. + // + S2LexerTraits::InputStreamType* input; + + + // The token stream is produced by the ANTLR3 generated lexer. Again it is a structure based + // API/Object, which you can customise and override methods of as you wish. a Token stream is + // supplied to the generated parser, and you can write your own token stream and pass this in + // if you wish. + // + S2LexerTraits::TokenStreamType* tstream; + + // The C parser is also generated by ANTLR and accepts a token stream as explained + // above. The token stream can be any source in fact, so long as it implements the + // ANTLR3_TOKEN_SOURCE interface. In this case the parser does not return anything + // but it can of course specify any kind of return type from the rule you invoke + // when calling it. + // + S2Parser* psr; + + // Create the input stream using the supplied file name + // (Use antlr3AsciiFileStreamNew for UCS2/16bit input). + // + ///byIvan input = new PLSQLTraits::InputStreamType(fName, ANTLR_ENC_8BIT); +#if defined __linux + string data = Utils::slurp(fd); +#else + string data = Utils::slurp(fName); +#endif + input = new S2LexerTraits::InputStreamType((const ANTLR_UINT8 *)data.c_str(), + ANTLR_ENC_8BIT, + data.length(), //strlen(data.c_str()), + (ANTLR_UINT8*)fName); + + input->setUcaseLA(true); + + // Our input stream is now open and all set to go, so we can create a new instance of our + // lexer and set the lexer input to our input stream: + // (file | memory | ?) --> inputstream -> lexer --> tokenstream --> parser ( --> treeparser )? + // + if (lxr == NULL) + { + lxr = new S2Lexer(input); // javaLexerNew is generated by ANTLR + } + else + { + lxr->setCharStream(input); + } + + // Our lexer is in place, so we can create the token stream from it + // NB: Nothing happens yet other than the file has been read. We are just + // connecting all these things together and they will be invoked when we + // call the parser rule. ANTLR3_SIZE_HINT can be left at the default usually + // unless you have a very large token stream/input. Each generated lexer + // provides a token source interface, which is the second argument to the + // token stream creator. + // Note tha even if you implement your own token structure, it will always + // contain a standard common token within it and this is the pointer that + // you pass around to everything else. A common token as a pointer within + // it that should point to your own outer token structure. + // + tstream = new S2LexerTraits::TokenStreamType(ANTLR_SIZE_HINT, lxr->getTokSource()); + + // Finally, now that we have our lexer constructed, we can create the parser + // + psr = new S2Parser(tstream); // javaParserNew is generated by ANTLR3 + + // Note that this means only that the methods are always called via the object + // pointer and the first argument to any method, is a pointer to the structure itself. + // It also has the side advantage, if you are using an IDE such as VS2005 that can do it + // that when you type ->, you will see a list of tall the methods the object supports. + // + putc('L', stdout); fflush(stdout); + { + ANTLR_INT32 T = 0; + while (T != S2Lexer::EOF_TOKEN) + { + T = tstream->_LA(1); + S2LexerTraits::CommonTokenType const* token = tstream->_LT(1); + ANTLR_UINT8 const *name = lxr->getTokenName(T); + + printf("%d %s\t\"%s\"\n", + T, + name, + tstream->_LT(1)->getText().c_str() + ); + tstream->consume(); + } + } + + tstream->_LT(1); // Don't do this mormally, just causes lexer to run for timings here + + delete tstream; + delete lxr; lxr = NULL; + delete input; +} Property changes on: branches/tora3/extlibs/parsing.cpp/s2.cpp ___________________________________________________________________ Added: svn:executable ## -0,0 +1 ## +* \ No newline at end of property Modified: branches/tora3/extlibs/parsing.cpp/utils.cpp =================================================================== --- branches/tora3/extlibs/parsing.cpp/utils.cpp 2013-05-17 09:01:14 UTC (rev 4647) +++ branches/tora3/extlibs/parsing.cpp/utils.cpp 2013-05-17 11:21:56 UTC (rev 4648) @@ -5,6 +5,16 @@ # include <sys/mman.h> # define DIRDELIM '/' # include <dirent.h> +#elif __MINGW32__ +# include <iostream> +# include <fstream> +# include <sstream> +#elif __CYGWIN__ +# include <iostream> +# include <fstream> +# include <sstream> +# include <dirent.h> +# define DIRDELIM '\\' #elif _MSC_VER # define _CRT_SECURE_NO_WARNINGS 1 # include <iostream> @@ -85,7 +95,7 @@ fstat( fd, &sb); if( isDirectory(directory, sb)) { -#if defined __linux +#if defined __linux || defined __CYGWIN__ DIR *Hdir = fdopendir(fd); #else DIR *Hdir = opendir(directory); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <ibr...@us...> - 2013-06-19 21:12:38
|
Revision: 4652 http://sourceforge.net/p/tora/code/4652 Author: ibre5041 Date: 2013-06-19 21:12:29 +0000 (Wed, 19 Jun 2013) Log Message: ----------- parsing fixes Modified Paths: -------------- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3bitset.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3bitset.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3collections.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3collections.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontoken.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontoken.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3cyclicdfa.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3exception.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3exception.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3filestream.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3input.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3input.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3intstream.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3intstream.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3lexer.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3lexer.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3parser.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3parser.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3recognizersharedstate.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3recognizersharedstate.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3tokenstream.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3tokenstream.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3treeparser.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3treeparser.inl branches/tora3/extlibs/parsing.cpp/OraclePLSQL.g branches/tora3/extlibs/parsing.cpp/OracleSQL.g branches/tora3/extlibs/parsing.cpp/PLSQLGuiLexer.g branches/tora3/extlibs/parsing.cpp/PLSQLLexer.g branches/tora3/extlibs/parsing.cpp/SQLMini.g branches/tora3/extlibs/parsing.cpp/antlr-complete-3.5.1-SNAPSHOT.jar branches/tora3/extlibs/parsing.cpp/m0.cpp branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/Cpp.stg branches/tora3/extlibs/parsing.cpp/p0.cpp branches/tora3/extlibs/parsing.cpp/s0.cpp branches/tora3/extlibs/parsing.cpp/s1.cpp branches/tora3/extlibs/parsing.cpp/s2.cpp branches/tora3/extlibs/parsing.cpp/s3.cpp branches/tora3/extlibs/parsing.cpp/t0.cpp Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.hpp 2013-05-20 15:34:35 UTC (rev 4651) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.hpp 2013-06-19 21:12:29 UTC (rev 4652) @@ -83,11 +83,11 @@ public: BaseRecognizer(ANTLR_UINT32 sizeHint, RecognizerSharedStateType* state); - SuperType* getSuper(); - RecognizerSharedStateType* getState() const; - DebugEventListenerType* getDebugger() const; - void setState( RecognizerSharedStateType* state ); - void setDebugger( DebugEventListenerType* debugger ); + SuperType* get_super(); + RecognizerSharedStateType* get_state() const; + DebugEventListenerType* get_debugger() const; + void set_state( RecognizerSharedStateType* state ); + void set_debugger( DebugEventListenerType* debugger ); /// Match current input symbol against ttype. Upon error, do one token /// insertion or deletion if possible. @@ -98,7 +98,7 @@ /// rule. Rule would recover by resynchronizing to the set of /// symbols that can follow rule ref. /// - UnitType* match(ANTLR_UINT32 ttype, BitsetListType* follow); + const UnitType* match(ANTLR_UINT32 ttype, BitsetListType* follow); /// Consumes the next token, whatever it is, and resets the recognizer state /// so that it is not in error. @@ -379,12 +379,12 @@ /// sorted in the recognizer exception stack in the C version. To 'throw' it we set the /// error flag and rules cascade back when this is set. /// - UnitType* recoverFromMismatchedToken( ANTLR_UINT32 ttype, BitsetListType* follow); + const UnitType* recoverFromMismatchedToken( ANTLR_UINT32 ttype, BitsetListType* follow); /** Function that recovers from a mismatched set in the token stream, in a similar manner * to (*recoverFromMismatchedToken) */ - UnitType* recoverFromMismatchedSet(BitsetListType* follow); + const UnitType* recoverFromMismatchedSet(BitsetListType* follow); /** common routine to handle single token insertion for recovery functions. */ @@ -449,10 +449,10 @@ /// This is ignored for lexers and the lexer implementation of this /// function should return NULL. /// - UnitType* getCurrentInputSymbol(IntStreamType* istream); - UnitType* getCurrentInputSymbol(IntStreamType* istream, ClassForwarder<LexerType>); - UnitType* getCurrentInputSymbol(IntStreamType* istream, ClassForwarder<ParserType>); - UnitType* getCurrentInputSymbol(IntStreamType* istream, ClassForwarder<TreeParserType>); + const UnitType* getCurrentInputSymbol(IntStreamType* istream); + const UnitType* getCurrentInputSymbol(IntStreamType* istream, ClassForwarder<LexerType>); + const UnitType* getCurrentInputSymbol(IntStreamType* istream, ClassForwarder<ParserType>); + const UnitType* getCurrentInputSymbol(IntStreamType* istream, ClassForwarder<TreeParserType>); /// Conjure up a missing token during error recovery. /// Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.inl 2013-05-20 15:34:35 UTC (rev 4651) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3baserecognizer.inl 2013-06-19 21:12:29 UTC (rev 4652) @@ -12,7 +12,7 @@ if (state == NULL) { m_state = new RecognizerSharedStateType(); - m_state->setSizeHint( sizeHint ); + m_state->set_sizeHint( sizeHint ); } else { @@ -25,61 +25,61 @@ } template< class ImplTraits, class StreamType > -ANTLR_INLINE typename BaseRecognizer<ImplTraits, StreamType>::SuperType* BaseRecognizer<ImplTraits, StreamType>::getSuper() +ANTLR_INLINE typename BaseRecognizer<ImplTraits, StreamType>::SuperType* BaseRecognizer<ImplTraits, StreamType>::get_super() { return static_cast<SuperType*>(this); } template< class ImplTraits, class StreamType > -ANTLR_INLINE typename BaseRecognizer<ImplTraits, StreamType>::RecognizerSharedStateType* BaseRecognizer<ImplTraits, StreamType>::getState() const +ANTLR_INLINE typename BaseRecognizer<ImplTraits, StreamType>::RecognizerSharedStateType* BaseRecognizer<ImplTraits, StreamType>::get_state() const { return m_state; } template< class ImplTraits, class StreamType > -ANTLR_INLINE typename BaseRecognizer<ImplTraits, StreamType>::DebugEventListenerType* BaseRecognizer<ImplTraits, StreamType>::getDebugger() const +ANTLR_INLINE typename BaseRecognizer<ImplTraits, StreamType>::DebugEventListenerType* BaseRecognizer<ImplTraits, StreamType>::get_debugger() const { return m_debugger; } template< class ImplTraits, class StreamType > -ANTLR_INLINE void BaseRecognizer<ImplTraits, StreamType>::setState( RecognizerSharedStateType* state ) +ANTLR_INLINE void BaseRecognizer<ImplTraits, StreamType>::set_state( RecognizerSharedStateType* state ) { m_state = state; } template< class ImplTraits, class StreamType > -ANTLR_INLINE void BaseRecognizer<ImplTraits, StreamType>::setDebugger( DebugEventListenerType* debugger ) +ANTLR_INLINE void BaseRecognizer<ImplTraits, StreamType>::set_debugger( DebugEventListenerType* debugger ) { m_debugger = debugger; } template< class ImplTraits, class StreamType > -typename BaseRecognizer<ImplTraits, StreamType>::UnitType* +const typename BaseRecognizer<ImplTraits, StreamType>::UnitType* BaseRecognizer<ImplTraits, StreamType>::match(ANTLR_UINT32 ttype, BitsetListType* follow) { SuperType* super = static_cast<SuperType*>(this); - IntStreamType* is = super->getIstream(); + IntStreamType* is = super->get_istream(); // Pick up the current input token/node for assignment to labels // - UnitType* matchedSymbol = this->getCurrentInputSymbol(is); + const UnitType* matchedSymbol = this->getCurrentInputSymbol(is); if (is->_LA(1) == ttype) { // The token was the one we were told to expect // is->consume(); // Consume that token from the stream - m_state->setErrorRecovery(false); // Not in error recovery now (if we were) - m_state->setFailed(false); // The match was a success + m_state->set_errorRecovery(false); // Not in error recovery now (if we were) + m_state->set_failed(false); // The match was a success return matchedSymbol; // We are done } // We did not find the expected token type, if we are backtracking then // we just set the failed flag and return. // - if ( m_state->getBacktracking() > 0) + if ( m_state->get_backtracking() > 0) { // Backtracking is going on // - m_state->setFailed(true); + m_state->set_failed(true); return matchedSymbol; } @@ -87,7 +87,7 @@ // going on, so we mismatch, which creates an exception in the recognizer exception // stack. // - matchedSymbol = this->recoverFromMismatchedToken(ttype, follow); + matchedSymbol = this->recoverFromMismatchedToken(ttype, follow); return matchedSymbol; } @@ -96,11 +96,11 @@ void BaseRecognizer<ImplTraits, StreamType>::matchAny() { SuperType* super = static_cast<SuperType*>(this); - IntStreamType* is = super->getIstream(); + IntStreamType* is = super->get_istream(); is->consume(); - m_state->setErrorRecovery(false); - m_state->setFailed(false); + m_state->set_errorRecovery(false); + m_state->set_failed(false); return; } @@ -111,8 +111,8 @@ if (nextt == ttype) { - if(m_state->getException() != NULL) - m_state->getException()->setExpecting(nextt); + if(m_state->get_exception() != NULL) + m_state->get_exception()->set_expecting(nextt); return true; // This token is unknown, but the next one is the one we wanted } else @@ -198,7 +198,7 @@ template< class ImplTraits, class StreamType > void BaseRecognizer<ImplTraits, StreamType>::mismatch(ANTLR_UINT32 ttype, BitsetListType* follow) { - this->getSuper()->mismatch( ttype, follow ); + this->get_super()->mismatch( ttype, follow ); } template< class ImplTraits, class StreamType > @@ -214,7 +214,7 @@ // m_state->inc_errorCount(); - this->displayRecognitionError(m_state->getTokenNames()); + this->displayRecognitionError(m_state->get_tokenNames()); } template< class ImplTraits, class StreamType > @@ -225,10 +225,10 @@ // if ( m_debugger != NULL) { - m_debugger->recognitionException( m_state->getException() ); + m_debugger->recognitionException( m_state->get_exception() ); } - if ( m_state->getErrorRecovery() == true) + if ( m_state->get_errorRecovery() == true) { // Already in error recovery so don't display another error while doing so // @@ -237,7 +237,7 @@ // Signal we are in error recovery now // - m_state->setErrorRecovery(true); + m_state->set_errorRecovery(true); // Indicate this recognizer had an error while processing. // @@ -245,7 +245,7 @@ // Call the error display routine // - this->displayRecognitionError( m_state->getTokenNames() ); + this->displayRecognitionError( m_state->get_tokenNames() ); } template< class ImplTraits, class StreamType > @@ -253,7 +253,7 @@ { // Retrieve some info for easy reading. // - ExceptionBaseType* ex = m_state->getException(); + ExceptionBaseType* ex = m_state->get_exception(); StringType ttext; // See if there is a 'filename' we can use @@ -265,7 +265,7 @@ template< class ImplTraits, class StreamType > ANTLR_UINT32 BaseRecognizer<ImplTraits, StreamType>::getNumberOfSyntaxErrors() { - return m_state->getErrorCount(); + return m_state->get_errorCount(); } template< class ImplTraits, class StreamType > @@ -275,7 +275,7 @@ IntStreamType* is = super->get_parser_istream(); // Are we about to repeat the same error? // - if ( m_state->getLastErrorIndex() == is->index()) + if ( m_state->get_lastErrorIndex() == is->index()) { // The last error was at the same token index point. This must be a case // where LT(1) is in the recovery token set so nothing is @@ -287,7 +287,7 @@ // Record error index position // - m_state->setLastErrorIndex( is->index() ); + m_state->set_lastErrorIndex( is->index() ); // Work out the follows set for error recovery // @@ -311,8 +311,8 @@ // Reset the inError flag so we don't re-report the exception // - m_state->setError(false); - m_state->setFailed(false); + m_state->set_error(false); + m_state->set_failed(false); } template< class ImplTraits, class StreamType > @@ -371,14 +371,14 @@ ANTLR_UINT32 top; ANTLR_UINT32 i; - top = static_cast<ANTLR_UINT32>( m_state->getFollowing().size() ); + top = static_cast<ANTLR_UINT32>( m_state->get_following().size() ); followSet = new BitsetType(0); localFollowSet = NULL; for (i = top; i>0; i--) { - localFollowSet = m_state->getFollowing().at(i-1).bitsetLoad(); + localFollowSet = m_state->get_following().at(i-1).bitsetLoad(); if (localFollowSet != NULL) { @@ -414,12 +414,12 @@ } template< class ImplTraits, class StreamType > -typename BaseRecognizer<ImplTraits, StreamType>::UnitType* +const typename BaseRecognizer<ImplTraits, StreamType>::UnitType* BaseRecognizer<ImplTraits, StreamType>::recoverFromMismatchedToken( ANTLR_UINT32 ttype, BitsetListType* follow) { SuperType* super = static_cast<SuperType*>(this); IntStreamType* is = super->get_parser_istream(); - UnitType* matchedSymbol; + const UnitType* matchedSymbol; // If the next token after the one we are looking at in the input stream // is what we are looking for then we remove the one we have discovered @@ -465,7 +465,7 @@ // is->consume(); - m_state->setError(false); // Exception is not outstanding any more + m_state->set_error(false); // Exception is not outstanding any more return matchedSymbol; } @@ -479,16 +479,16 @@ // We can fake the missing token and proceed // new ANTLR_Exception<ImplTraits, MISSING_TOKEN_EXCEPTION, StreamType>(this, ""); - matchedSymbol = this->getMissingSymbol( is, m_state->getException(), ttype, follow); - m_state->getException()->setToken( matchedSymbol ); - m_state->getException()->setExpecting(ttype); + matchedSymbol = this->getMissingSymbol( is, m_state->get_exception(), ttype, follow); + m_state->get_exception()->set_token( matchedSymbol ); + m_state->get_exception()->set_expecting(ttype); // Print out the error after we insert so that ANTLRWorks sees the // token in the exception. // this->reportError(); - m_state->setError(false); // Exception is not outstanding any more + m_state->set_error(false); // Exception is not outstanding any more return matchedSymbol; } @@ -500,40 +500,40 @@ // Neither deleting nor inserting tokens allows recovery // must just report the exception. // - m_state->setError(true); + m_state->set_error(true); return NULL; } template< class ImplTraits, class StreamType > -typename BaseRecognizer<ImplTraits, StreamType>::UnitType* +const typename BaseRecognizer<ImplTraits, StreamType>::UnitType* BaseRecognizer<ImplTraits, StreamType>::recoverFromMismatchedSet(BitsetListType* follow) { SuperType* super = static_cast<SuperType*>(this); IntStreamType* is = super->get_parser_istream(); - UnitType* matchedSymbol; + const UnitType* matchedSymbol; if (this->mismatchIsMissingToken(is, follow) == true) { // We can fake the missing token and proceed // new ANTLR_Exception<ImplTraits, MISSING_TOKEN_EXCEPTION, StreamType>(this); - matchedSymbol = this->getMissingSymbol(is, m_state->getException(), follow); - m_state->getException()->set_token(matchedSymbol); + matchedSymbol = this->getMissingSymbol(is, m_state->get_exception(), follow); + m_state->get_exception()->set_token(matchedSymbol); // Print out the error after we insert so that ANTLRWorks sees the // token in the exception. // this->reportError(); - m_state->setError(false); // Exception is not outstanding any more + m_state->set_error(false); // Exception is not outstanding any more return matchedSymbol; } // TODO - Single token deletion like in recoverFromMismatchedToken() // - m_state->setError(true); - m_state->setFailed(true); + m_state->set_error(true); + m_state->set_failed(true); return NULL; } @@ -588,8 +588,8 @@ { delete follow; } - m_state->setError(false); - m_state->setFailed(false); + m_state->set_error(false); + m_state->set_failed(false); return true; /* Success in recovery */ } @@ -658,7 +658,7 @@ /* See if we have a list in the ruleMemos for this rule, and if not, then create one * as we will need it eventually if we are being asked for the memo here. */ - entry = m_state->getRuleMemo()->get(ruleIndex); + entry = m_state->get_ruleMemo()->get(ruleIndex); if (entry == NULL) { @@ -669,14 +669,14 @@ * no idea of the size, but you should remember that this will cause the leftmost * bit match algorithm to run to 63 bits, which will be the whole time spent in the trie ;-) */ - m_state->getRuleMemo()->add( ruleIndex, new RuleListType(63) ); + m_state->get_ruleMemo()->add( ruleIndex, new RuleListType(63) ); /* We cannot have a stopIndex in a trie we have just created of course */ return MEMO_RULE_UNKNOWN; } - RuleListType* ruleList = entry->getData(); + RuleListType* ruleList = entry->get_data(); /* See if there is a stop index associated with the supplied start index. */ @@ -685,7 +685,7 @@ SubEntryType* sub_entry = ruleList->get(ruleParseStart); if (sub_entry != NULL) { - stopIndex = sub_entry->getData(); + stopIndex = sub_entry->get_data(); } if (stopIndex == 0) @@ -700,7 +700,7 @@ bool BaseRecognizer<ImplTraits, StreamType>::alreadyParsedRule(ANTLR_MARKER ruleIndex) { SuperType* super = static_cast<SuperType*>(this); - IntStreamType* is = super->getIstream(); + IntStreamType* is = super->get_istream(); /* See if we have a memo marker for this. */ @@ -713,7 +713,7 @@ if (stopIndex == MEMO_RULE_FAILED) { - m_state->setFailed(true); + m_state->set_failed(true); } else { @@ -735,15 +735,15 @@ EntryType* entry; ANTLR_MARKER stopIndex; SuperType* super = static_cast<SuperType*>(this); - IntStreamType* is = super->getIstream(); + IntStreamType* is = super->get_istream(); - stopIndex = (m_state->getFailed() == true) ? MEMO_RULE_FAILED : is->index() - 1; + stopIndex = (m_state->get_failed() == true) ? MEMO_RULE_FAILED : is->index() - 1; - entry = m_state->getRuleMemo()->get(ruleIndex); + entry = m_state->get_ruleMemo()->get(ruleIndex); if (entry != NULL) { - RuleListType* ruleList = entry->getData(); + RuleListType* ruleList = entry->get_data(); /* If we don't already have this entry, append it. The memoize trie does not * accept duplicates so it won't add it if already there and we just ignore the @@ -754,21 +754,21 @@ } template< class ImplTraits, class StreamType > -typename BaseRecognizer<ImplTraits, StreamType>::UnitType* +const typename BaseRecognizer<ImplTraits, StreamType>::UnitType* BaseRecognizer<ImplTraits, StreamType>::getCurrentInputSymbol( IntStreamType* istream ) { return this->getCurrentInputSymbol( istream, ClassForwarder<SuperType>() ); } template< class ImplTraits, class StreamType > -typename BaseRecognizer<ImplTraits, StreamType>::UnitType* +const typename BaseRecognizer<ImplTraits, StreamType>::UnitType* BaseRecognizer<ImplTraits, StreamType>::getCurrentInputSymbol(IntStreamType* istream, ClassForwarder<LexerType>) { return NULL; } template< class ImplTraits, class StreamType > -typename BaseRecognizer<ImplTraits, StreamType>::UnitType* +const typename BaseRecognizer<ImplTraits, StreamType>::UnitType* BaseRecognizer<ImplTraits, StreamType>::getCurrentInputSymbol(IntStreamType* istream, ClassForwarder<ParserType>) { typedef typename ImplTraits::TokenStreamType TokenStreamType; @@ -777,7 +777,7 @@ } template< class ImplTraits, class StreamType > -typename BaseRecognizer<ImplTraits, StreamType>::UnitType* +const typename BaseRecognizer<ImplTraits, StreamType>::UnitType* BaseRecognizer<ImplTraits, StreamType>::getCurrentInputSymbol(IntStreamType* istream, ClassForwarder<TreeParserType>) { typedef typename ImplTraits::TreeNodeStreamType TreeNodeStreamType; @@ -792,7 +792,7 @@ ANTLR_UINT32 expectedTokenType, BitsetListType* follow) { - return this->getSuper()->getMissingSymbol( istream, e, expectedTokenType, follow ); + return this->get_super()->getMissingSymbol( istream, e, expectedTokenType, follow ); } @@ -802,7 +802,7 @@ { ANTLR_MARKER start; SuperType* super = static_cast<SuperType*>(this); - IntStreamType* is = super->getIstream(); + IntStreamType* is = super->get_istream(); /* Begin backtracking so we can get back to where we started after trying out * the syntactic predicate. @@ -812,25 +812,25 @@ /* Try the syntactical predicate */ - this->getSuper()->synpred( pred ); + this->get_super()->synpred( pred ); /* Reset */ is->rewind(start); m_state->dec_backtracking(); - if ( m_state->getFailed() == true) + if ( m_state->get_failed() == true) { /* Predicate failed */ - m_state->setFailed(false); + m_state->set_failed(false); return false; } else { /* Predicate was successful */ - m_state->setFailed(false); + m_state->set_failed(false); return true; } } @@ -838,7 +838,7 @@ template< class ImplTraits, class StreamType > void BaseRecognizer<ImplTraits, StreamType>::exConstruct() { - this->getSuper()->exConstruct(); + this->get_super()->exConstruct(); } template< class ImplTraits, class StreamType > @@ -852,32 +852,32 @@ void BaseRecognizer<ImplTraits, StreamType>::reset( ClassForwarder<CompType> ) { typedef typename RecognizerSharedStateType::RuleMemoType RuleMemoType; - m_state->getFollowing().clear(); + m_state->get_following().clear(); // Reset the state flags // - m_state->setErrorRecovery(false); - m_state->setLastErrorIndex(-1); - m_state->setFailed(false); - m_state->setErrorCount(0); - m_state->setBacktracking(0); + m_state->set_errorRecovery(false); + m_state->set_lastErrorIndex(-1); + m_state->set_failed(false); + m_state->set_errorCount(0); + m_state->set_backtracking(0); - if (m_state->getRuleMemo() != NULL) + if (m_state->get_ruleMemo() != NULL) { - delete m_state->getRuleMemo(); - m_state->setRuleMemo( new RuleMemoType(15) ); /* 16 bit depth is enough for 32768 rules! */ + delete m_state->get_ruleMemo(); + m_state->set_ruleMemo( new RuleMemoType(15) ); /* 16 bit depth is enough for 32768 rules! */ } } template< class ImplTraits, class StreamType > void BaseRecognizer<ImplTraits, StreamType>::reset( ClassForwarder<LexerType> ) { - m_state->setTokenPresent( false ); - m_state->setType( ImplTraits::CommonTokenType::TOKEN_INVALID ); - m_state->setChannel( TOKEN_DEFAULT_CHANNEL ); - m_state->setTokenStartCharIndex( -1 ); - m_state->setTokenStartCharPositionInLine(-1); - m_state->setTokenStartLine( -1 ); + m_state->set_token_present( false ); + m_state->set_type( ImplTraits::CommonTokenType::TOKEN_INVALID ); + m_state->set_channel( TOKEN_DEFAULT_CHANNEL ); + m_state->set_tokenStartCharIndex( -1 ); + m_state->set_tokenStartCharPositionInLine(-1); + m_state->set_tokenStartLine( -1 ); m_state->set_text(""); } @@ -890,16 +890,16 @@ { // Free any rule memoization we set up // - if (m_state->getRuleMemo() != NULL) + if (m_state->get_ruleMemo() != NULL) { - delete m_state->getRuleMemo(); - m_state->setRuleMemo(NULL); + delete m_state->get_ruleMemo(); + m_state->set_ruleMemo(NULL); } // Free any exception space we have left around // - ExceptionBaseType* thisE = m_state->getException(); + ExceptionBaseType* thisE = m_state->get_exception(); if (thisE != NULL) { delete thisE; Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3bitset.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3bitset.hpp 2013-05-20 15:34:35 UTC (rev 4651) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3bitset.hpp 2013-06-19 21:12:29 UTC (rev 4652) @@ -88,10 +88,10 @@ BitsetList(); BitsetList( ANTLR_BITWORD* bits, ANTLR_UINT32 length ); - ANTLR_BITWORD* getBits() const; - ANTLR_UINT32 getLength() const; - void setBits( ANTLR_BITWORD* bits ); - void setLength( ANTLR_UINT32 length ); + ANTLR_BITWORD* get_bits() const; + ANTLR_UINT32 get_length() const; + void set_bits( ANTLR_BITWORD* bits ); + void set_length( ANTLR_UINT32 length ); /// /// \brief @@ -139,7 +139,7 @@ Bitset* clone() const; Bitset* bor(Bitset* bitset2); - BitsetListType& getBlist(); + BitsetListType& get_blist(); void borInPlace(Bitset* bitset2); ANTLR_UINT32 size() const; void add(ANTLR_INT32 bit); Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3bitset.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3bitset.inl 2013-05-20 15:34:35 UTC (rev 4651) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3bitset.inl 2013-06-19 21:12:29 UTC (rev 4652) @@ -15,25 +15,25 @@ } template <class ImplTraits> -ANTLR_INLINE ANTLR_BITWORD* BitsetList<ImplTraits>::getBits() const +ANTLR_INLINE ANTLR_BITWORD* BitsetList<ImplTraits>::get_bits() const { return m_bits; } template <class ImplTraits> -ANTLR_INLINE ANTLR_UINT32 BitsetList<ImplTraits>::getLength() const +ANTLR_INLINE ANTLR_UINT32 BitsetList<ImplTraits>::get_length() const { return m_length; } template <class ImplTraits> -ANTLR_INLINE void BitsetList<ImplTraits>::setBits( ANTLR_BITWORD* bits ) +ANTLR_INLINE void BitsetList<ImplTraits>::set_bits( ANTLR_BITWORD* bits ) { m_bits = bits; } template <class ImplTraits> -ANTLR_INLINE void BitsetList<ImplTraits>::setLength( ANTLR_UINT32 length ) +ANTLR_INLINE void BitsetList<ImplTraits>::set_length( ANTLR_UINT32 length ) { m_length = length; } @@ -58,10 +58,10 @@ ANTLR_UINT32 count=0; while (count < m_length) { - if( bitset->getBlist().getLength() <= count) + if( bitset->get_blist().get_length() <= count) bitset->grow(count+1); - typename ImplTraits::BitsetListType& blist = bitset->getBlist(); + typename ImplTraits::BitsetListType& blist = bitset->get_blist(); blist.m_bits[count] = *(m_bits+count); count++; } @@ -86,7 +86,7 @@ // Allocate memory for the bitset structure itself // bitset = new Bitset<ImplTraits>(numElements); - memcpy(bitset->getBlist().getBits(), m_bits, numElements * sizeof(ANTLR_BITWORD)); + memcpy(bitset->get_blist().get_bits(), m_bits, numElements * sizeof(ANTLR_BITWORD)); // All seems good // @@ -105,10 +105,10 @@ // ANTLR_UINT32 numelements = ((numBits -1) >> ANTLR_BITSET_LOG_BITS) + 1; - m_blist.setBits( (ANTLR_BITWORD*) AllocPolicyType::alloc(numelements * sizeof(ANTLR_BITWORD))); + m_blist.set_bits( (ANTLR_BITWORD*) AllocPolicyType::alloc(numelements * sizeof(ANTLR_BITWORD))); - memset( m_blist.getBits(), 0, (numelements * sizeof(ANTLR_BITWORD))); - m_blist.setLength( numelements ); + memset( m_blist.get_bits(), 0, (numelements * sizeof(ANTLR_BITWORD))); + m_blist.set_length( numelements ); } template <class ImplTraits> @@ -124,12 +124,12 @@ // Allocate memory for the bitset structure itself // - bitset = new Bitset( ANTLR_BITSET_BITS * m_blist.getLength() ); + bitset = new Bitset( ANTLR_BITSET_BITS * m_blist.get_length() ); // Install the actual bits in the source set // - memcpy(bitset->m_blist.getBits(), m_blist.getBits(), - m_blist.getLength() * sizeof(ANTLR_BITWORD) ); + memcpy(bitset->m_blist.get_bits(), m_blist.get_bits(), + m_blist.get_length() * sizeof(ANTLR_BITWORD) ); // All seems good // @@ -165,18 +165,18 @@ // First make sure that the target bitset is big enough // for the new bits to be ored in. // - if ( m_blist.getLength() < bitset2->m_blist.getLength() ) - this->growToInclude( bitset2->m_blist.getLength() * sizeof(ANTLR_BITWORD) ); + if ( m_blist.get_length() < bitset2->m_blist.get_length() ) + this->growToInclude( bitset2->m_blist.get_length() * sizeof(ANTLR_BITWORD) ); // Or the miniimum number of bits after any resizing went on // - if ( m_blist.getLength() < bitset2->m_blist.getLength() ) - minimum = m_blist.getLength(); + if ( m_blist.get_length() < bitset2->m_blist.get_length() ) + minimum = m_blist.get_length(); else - minimum = bitset2->m_blist.getLength(); + minimum = bitset2->m_blist.get_length(); - ANTLR_BITWORD* bits1 = m_blist.getBits(); - ANTLR_BITWORD* bits2 = bitset2->m_blist.getBits(); + ANTLR_BITWORD* bits1 = m_blist.get_bits(); + ANTLR_BITWORD* bits2 = bitset2->m_blist.get_bits(); for (ANTLR_UINT32 i = minimum; i > 0; i--) bits1[i-1] |= bits2[i-1]; } @@ -194,8 +194,8 @@ // anyway. // degree = 0; - ANTLR_BITWORD* bits = m_blist.getBits(); - for (i = m_blist.getLength() - 1; i>= 0; i--) + ANTLR_BITWORD* bits = m_blist.get_bits(); + for (i = m_blist.get_length() - 1; i>= 0; i--) { if (bits[i] != 0) { @@ -216,10 +216,10 @@ { ANTLR_UINT32 word = Bitset::WordNumber(bit); - if (word >= m_blist.getLength() ) + if (word >= m_blist.get_length() ) this->growToInclude(bit); - ANTLR_BITWORD* bits = m_blist.getBits(); + ANTLR_BITWORD* bits = m_blist.get_bits(); bits[word] |= Bitset::BitMask(bit); } @@ -232,21 +232,21 @@ // be more efficient... // newBits = (ANTLR_BITWORD*) AllocPolicyType::alloc0(newSize * sizeof(ANTLR_BITWORD) ); - if ( m_blist.getBits() != NULL) + if ( m_blist.get_bits() != NULL) { // Copy existing bits // - memcpy( newBits, m_blist.getBits(), m_blist.getLength() * sizeof(ANTLR_BITWORD) ); + memcpy( newBits, m_blist.get_bits(), m_blist.get_length() * sizeof(ANTLR_BITWORD) ); // Out with the old bits... de de de derrr // - AllocPolicyType::free( m_blist.getBits() ); + AllocPolicyType::free( m_blist.get_bits() ); } // In with the new bits... keerrrang. // - m_blist.setBits(newBits); - m_blist.setLength(newSize); + m_blist.set_bits(newBits); + m_blist.set_length(newSize); } template <class ImplTraits> @@ -260,17 +260,17 @@ // Work out the minimum comparison set // - if ( m_blist.getLength() < bitset2->m_blist.getLength() ) - minimum = m_blist.getLength(); + if ( m_blist.get_length() < bitset2->m_blist.get_length() ) + minimum = m_blist.get_length(); else - minimum = bitset2->m_blist.getLength(); + minimum = bitset2->m_blist.get_length(); // Make sure explict in common bits are equal // for (i = minimum - 1; i < minimum ; i--) { - ANTLR_BITWORD* bits1 = m_blist.getBits(); - ANTLR_BITWORD* bits2 = bitset2->m_blist.getBits(); + ANTLR_BITWORD* bits1 = m_blist.get_bits(); + ANTLR_BITWORD* bits2 = bitset2->m_blist.get_bits(); if ( bits1[i] != bits2[i]) return false; } @@ -278,19 +278,19 @@ // Now make sure the bits of the larger set are all turned // off. // - if ( m_blist.getLength() > minimum) + if ( m_blist.get_length() > minimum) { - for (i = minimum ; i < m_blist.getLength(); i++) + for (i = minimum ; i < m_blist.get_length(); i++) { - ANTLR_BITWORD* bits = m_blist.getBits(); + ANTLR_BITWORD* bits = m_blist.get_bits(); if(bits[i] != 0) return false; } } - else if (bitset2->m_blist.getLength() > minimum) + else if (bitset2->m_blist.get_length() > minimum) { - ANTLR_BITWORD* bits = m_blist.getBits(); - for (i = minimum; i < bitset2->m_blist.getLength(); i++) + ANTLR_BITWORD* bits = m_blist.get_bits(); + for (i = minimum; i < bitset2->m_blist.get_length(); i++) { if ( bits[i] != 0 ) return false; @@ -305,10 +305,10 @@ { ANTLR_UINT32 wordNo = Bitset::WordNumber(bit); - if (wordNo >= m_blist.getLength()) + if (wordNo >= m_blist.get_length()) return false; - ANTLR_BITWORD* bits = m_blist.getBits(); + ANTLR_BITWORD* bits = m_blist.get_bits(); if ( (bits[wordNo] & Bitset::BitMask(bit)) == 0) return false; else @@ -318,11 +318,11 @@ template <class ImplTraits> ANTLR_INLINE ANTLR_UINT32 Bitset<ImplTraits>::numBits() const { - return m_blist.getLength() << ANTLR_BITSET_LOG_BITS; + return m_blist.get_length() << ANTLR_BITSET_LOG_BITS; } template <class ImplTraits> -ANTLR_INLINE typename ImplTraits::BitsetListType& Bitset<ImplTraits>::getBlist() +ANTLR_INLINE typename ImplTraits::BitsetListType& Bitset<ImplTraits>::get_blist() { return m_blist; } @@ -332,9 +332,9 @@ { ANTLR_UINT32 wordNo = Bitset::WordNumber(bit); - if (wordNo < m_blist.getLength()) + if (wordNo < m_blist.get_length()) { - ANTLR_BITWORD* bits = m_blist.getBits(); + ANTLR_BITWORD* bits = m_blist.get_bits(); bits[wordNo] &= ~(Bitset::BitMask(bit)); } } @@ -343,8 +343,8 @@ ANTLR_INLINE bool Bitset<ImplTraits>::isNilNode() const { ANTLR_UINT32 i; - ANTLR_BITWORD* bits = m_blist.getBits(); - for (i = m_blist.getLength() -1 ; i < m_blist.getLength(); i--) + ANTLR_BITWORD* bits = m_blist.get_bits(); + for (i = m_blist.get_length() -1 ; i < m_blist.get_length(); i--) { if(bits[i] != 0) return false; @@ -385,8 +385,8 @@ template <class ImplTraits> ANTLR_INLINE Bitset<ImplTraits>::~Bitset() { - if (m_blist.getBits() != NULL) - AllocPolicyType::free(m_blist.getBits()); + if (m_blist.get_bits() != NULL) + AllocPolicyType::free(m_blist.get_bits()); return; } @@ -396,7 +396,7 @@ ANTLR_UINT32 bl; ANTLR_UINT32 nw; - bl = (m_blist.getLength() << 1); + bl = (m_blist.get_length() << 1); nw = Bitset::NumWordsToHold(bit); if (bl > nw) @@ -435,18 +435,18 @@ // First make sure that the target bitset is big enough // for the new bits to be ored in. // - if ( m_blist.getLength() < bitset2->m_blist.getLength() ) - this->growToInclude( bitset2->m_blist.getLength() * sizeof(ANTLR_BITWORD) ); + if ( m_blist.get_length() < bitset2->m_blist.get_length() ) + this->growToInclude( bitset2->m_blist.get_length() * sizeof(ANTLR_BITWORD) ); // Or the miniimum number of bits after any resizing went on // - if ( m_blist.getLength() < bitset2->m_blist.getLength() ) - minimum = m_blist.getLength(); + if ( m_blist.get_length() < bitset2->m_blist.get_length() ) + minimum = m_blist.get_length(); else - minimum = bitset2->m_blist.getLength(); + minimum = bitset2->m_blist.get_length(); - ANTLR_BITWORD* bits1 = m_blist.getBits(); - ANTLR_BITWORD* bits2 = bitset2->m_blist.getBits(); + ANTLR_BITWORD* bits1 = m_blist.get_bits(); + ANTLR_BITWORD* bits2 = bitset2->m_blist.get_bits(); for (i = minimum; i > 0; i--) bits1[i-1] |= bits2[i-1]; } Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3collections.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3collections.hpp 2013-05-20 15:34:35 UTC (rev 4651) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3collections.hpp 2013-06-19 21:12:29 UTC (rev 4652) @@ -49,8 +49,8 @@ public: TrieEntry(const DataType& data, TrieEntry* next); - DataType& getData(); - const DataType& getData() const; + DataType& get_data(); + const DataType& get_data() const; TrieEntry* get_next() const; void set_next( TrieEntry* next ); }; @@ -75,16 +75,16 @@ IntTrieNode(); ~IntTrieNode(); - ANTLR_UINT32 getBitNum() const; + ANTLR_UINT32 get_bitNum() const; ANTLR_INTKEY get_key() const; - BucketsType* getBuckets() const; - IntTrieNode* getLeftN() const; - IntTrieNode* getRightN() const; - void setBitNum( ANTLR_UINT32 bitNum ); + BucketsType* get_buckets() const; + IntTrieNode* get_leftN() const; + IntTrieNode* get_rightN() const; + void set_bitNum( ANTLR_UINT32 bitNum ); void set_key( ANTLR_INTKEY key ); - void setBuckets( BucketsType* buckets ); - void setLeftN( IntTrieNode* leftN ); - void setRightN( IntTrieNode* rightN ); + void set_buckets( BucketsType* buckets ); + void set_leftN( IntTrieNode* leftN ); + void set_rightN( IntTrieNode* rightN ); }; /** Structure that defines an ANTLR3_INT_TRIE. For this particular implementation, @@ -106,8 +106,8 @@ class IntTrieBase { public: - static const ANTLR_UINT8* getBitIndex(); - static const ANTLR_UINT64* getBitMask(); + static const ANTLR_UINT8* get_bitIndex(); + static const ANTLR_UINT64* get_bitMask(); }; template< class ImplTraits, class DataType > Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3collections.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3collections.inl 2013-05-20 15:34:35 UTC (rev 4651) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3collections.inl 2013-06-19 21:12:29 UTC (rev 4652) @@ -7,12 +7,12 @@ m_next = next; } template< class ImplTraits, class DataType > -ANTLR_INLINE DataType& TrieEntry<ImplTraits, DataType>::getData() +ANTLR_INLINE DataType& TrieEntry<ImplTraits, DataType>::get_data() { return m_data; } template< class ImplTraits, class DataType > -ANTLR_INLINE const DataType& TrieEntry<ImplTraits, DataType>::getData() const +ANTLR_INLINE const DataType& TrieEntry<ImplTraits, DataType>::get_data() const { return m_data; } @@ -29,7 +29,7 @@ } template< class ImplTraits, class DataType > -ANTLR_INLINE ANTLR_UINT32 IntTrieNode<ImplTraits, DataType>::getBitNum() const +ANTLR_INLINE ANTLR_UINT32 IntTrieNode<ImplTraits, DataType>::get_bitNum() const { return m_bitNum; } @@ -39,22 +39,22 @@ return m_key; } template< class ImplTraits, class DataType > -ANTLR_INLINE typename IntTrieNode<ImplTraits, DataType>::BucketsType* IntTrieNode<ImplTraits, DataType>::getBuckets() const +ANTLR_INLINE typename IntTrieNode<ImplTraits, DataType>::BucketsType* IntTrieNode<ImplTraits, DataType>::get_buckets() const { return m_buckets; } template< class ImplTraits, class DataType > -ANTLR_INLINE IntTrieNode<ImplTraits, DataType>* IntTrieNode<ImplTraits, DataType>::getLeftN() const +ANTLR_INLINE IntTrieNode<ImplTraits, DataType>* IntTrieNode<ImplTraits, DataType>::get_leftN() const { return m_leftN; } template< class ImplTraits, class DataType > -ANTLR_INLINE IntTrieNode<ImplTraits, DataType>* IntTrieNode<ImplTraits, DataType>::getRightN() const +ANTLR_INLINE IntTrieNode<ImplTraits, DataType>* IntTrieNode<ImplTraits, DataType>::get_rightN() const { return m_rightN; } template< class ImplTraits, class DataType > -ANTLR_INLINE void IntTrieNode<ImplTraits, DataType>::setBitNum( ANTLR_UINT32 bitNum ) +ANTLR_INLINE void IntTrieNode<ImplTraits, DataType>::set_bitNum( ANTLR_UINT32 bitNum ) { m_bitNum = bitNum; } @@ -64,22 +64,22 @@ m_key = key; } template< class ImplTraits, class DataType > -ANTLR_INLINE void IntTrieNode<ImplTraits, DataType>::setBuckets( BucketsType* buckets ) +ANTLR_INLINE void IntTrieNode<ImplTraits, DataType>::set_buckets( BucketsType* buckets ) { m_buckets = buckets; } template< class ImplTraits, class DataType > -ANTLR_INLINE void IntTrieNode<ImplTraits, DataType>::setLeftN( IntTrieNode* leftN ) +ANTLR_INLINE void IntTrieNode<ImplTraits, DataType>::set_leftN( IntTrieNode* leftN ) { m_leftN = leftN; } template< class ImplTraits, class DataType > -ANTLR_INLINE void IntTrieNode<ImplTraits, DataType>::setRightN( IntTrieNode* rightN ) +ANTLR_INLINE void IntTrieNode<ImplTraits, DataType>::set_rightN( IntTrieNode* rightN ) { m_rightN = rightN; } -ANTLR_INLINE const ANTLR_UINT8* IntTrieBase::getBitIndex() +ANTLR_INLINE const ANTLR_UINT8* IntTrieBase::get_bitIndex() { static ANTLR_UINT8 bitIndex[256] = { @@ -107,7 +107,7 @@ return bitIndex; } -ANTLR_INLINE const ANTLR_UINT64* IntTrieBase::getBitMask() +ANTLR_INLINE const ANTLR_UINT64* IntTrieBase::get_bitMask() { static ANTLR_UINT64 bitMask[64] = { @@ -146,13 +146,13 @@ * keys in the trie. This is the trie 'depth'. The limit for * this implementation is 63 (bits 0..63). */ - m_root->setBitNum( depth ); + m_root->set_bitNum( depth ); /* And as we have nothing in here yet, we set both child pointers * of the root node to point back to itself. */ - m_root->setLeftN( m_root ); - m_root->setRightN( m_root ); + m_root->set_leftN( m_root ); + m_root->set_rightN( m_root ); m_count = 0; /* Finally, note that the key for this root node is 0 because @@ -195,12 +195,12 @@ * tree branches. */ thisNode = m_root; /* Start at the root node */ - nextNode = thisNode->getLeftN(); /* Examine the left node from the root */ + nextNode = thisNode->get_leftN(); /* Examine the left node from the root */ /* While we are descending the tree nodes... */ - const ANTLR_UINT64* bitMask = this->getBitMask(); - while( thisNode->getBitNum() > nextNode->getBitNum() ) + const ANTLR_UINT64* bitMask = this->get_bitMask(); + while( thisNode->get_bitNum() > nextNode->get_bitNum() ) { /* Next node now becomes the new 'current' node */ @@ -210,13 +210,13 @@ * in the key we are searching for. The new next node is the * right node if that bit is set and the left node it is not. */ - if (key & bitMask[nextNode->getBitNum()]) + if (key & bitMask[nextNode->get_bitNum()]) { - nextNode = nextNode->getRightN(); /* 1 is right */ + nextNode = nextNode->get_rightN(); /* 1 is right */ } else { - nextNode = nextNode->getLeftN(); /* 0 is left */ + nextNode = nextNode->get_leftN(); /* 0 is left */ } } @@ -235,7 +235,7 @@ { /* This was the key, so return the entry pointer */ - return nextNode->getBuckets(); + return nextNode->get_buckets(); } else { @@ -268,32 +268,32 @@ /* Cache the bit depth of this trie, which is always the highest index, * which is in the root node */ - depth = m_root->getBitNum(); + depth = m_root->get_bitNum(); thisNode = m_root; /* Start with the root node */ - nextNode = m_root->getLeftN(); /* And assume we start to the left */ + nextNode = m_root->get_leftN(); /* And assume we start to the left */ /* Now find the only node that can be currently reached by the bits in the * key we are being asked to insert. */ - const ANTLR_UINT64* bitMask = this->getBitMask(); - while (thisNode->getBitNum() > nextNode->getBitNum() ) + const ANTLR_UINT64* bitMask = this->get_bitMask(); + while (thisNode->get_bitNum() > nextNode->get_bitNum() ) { /* Still descending the structure, next node becomes current. */ thisNode = nextNode; - if (key & bitMask[nextNode->getBitNum()]) + if (key & bitMask[nextNode->get_bitNum()]) { /* Bit at the required index was 1, so travers the right node from here */ - nextNode = nextNode->getRightN(); + nextNode = nextNode->get_rightN(); } else { /* Bit at the required index was 0, so we traverse to the left */ - nextNode = nextNode->getLeftN(); + nextNode = nextNode->get_leftN(); } } /* Here we have located the only node that can be reached by the @@ -315,7 +315,7 @@ * added as duplicate keys. We might need to revise this opinion if we end up having many duplicate keys * as perhaps reverse order is just as good, so long as it is ordered. */ - nextEnt = nextNode->getBuckets(); + nextEnt = nextNode->get_buckets(); while (nextEnt->get_next() != NULL) { nextEnt = nextEnt->get_next(); @@ -344,7 +344,7 @@ /* Most common case is a 32 bit key really */ - const ANTLR_UINT8* bitIndex = this->getBitIndex(); + const ANTLR_UINT8* bitIndex = this->get_bitIndex(); #ifdef ANTLR_USE_64BIT if (xorKey & 0xFFFFFFFF00000000) { @@ -410,27 +410,27 @@ * according to whether we skip the bit that differs or not. */ thisNode = m_root; - entNode = m_root->getLeftN(); + entNode = m_root->get_leftN(); /* Note the slight difference in the checks here to cover both cases */ - while (thisNode->getBitNum() > entNode->getBitNum() && entNode->getBitNum() > depth) + while (thisNode->get_bitNum() > entNode->get_bitNum() && entNode->get_bitNum() > depth) { /* Still descending the structure, next node becomes current. */ thisNode = entNode; - if (key & bitMask[entNode->getBitNum()]) + if (key & bitMask[entNode->get_bitNum()]) { /* Bit at the required index was 1, so traverse the right node from here */ - entNode = entNode->getRightN(); + entNode = entNode->get_rightN(); } else { /* Bit at the required index was 0, so we traverse to the left */ - entNode = entNode->getLeftN(); + entNode = entNode->get_leftN(); } } @@ -445,9 +445,9 @@ /* Install it */ - nextNode->setBuckets(newEnt); + nextNode->set_buckets(newEnt); nextNode->set_key(key); - nextNode->setBitNum( depth ); + nextNode->set_bitNum( depth ); /* Work out the right and left pointers for this new node, which involve * terminating with the current found node either right or left according @@ -455,13 +455,13 @@ */ if (key & bitMask[depth]) { - nextNode->setLeftN(entNode); /* Terminates at previous position */ - nextNode->setRightN(nextNode); /* Terminates with itself */ + nextNode->set_leftN(entNode); /* Terminates at previous position */ + nextNode->set_rightN(nextNode); /* Terminates with itself */ } else { - nextNode->setRightN(entNode); /* Terminates at previous position */ - nextNode->setLeftN(nextNode); /* Terminates with itself */ + nextNode->set_rightN(entNode); /* Terminates at previous position */ + nextNode->set_leftN(nextNode); /* Terminates with itself */ } /* Finally, we need to change the pointers at the node we located @@ -469,13 +469,13 @@ * pointer for that node becomes the newly created node, otherwise the left * pointer does. */ - if (key & bitMask[thisNode->getBitNum()] ) + if (key & bitMask[thisNode->get_bitNum()] ) { - thisNode->setRightN( nextNode ); + thisNode->set_rightN( nextNode ); } else { - thisNode->setLeftN(nextNode); + thisNode->set_leftN(nextNode); } /* Et voila @@ -503,7 +503,7 @@ /* If this node has a left pointer that is not a back pointer * then recursively call to free this */ - if ( m_bitNum > m_leftN->getBitNum()) + if ( m_bitNum > m_leftN->get_bitNum()) { /* We have a left node that needs descending, so do it. */ @@ -513,7 +513,7 @@ /* The left nodes from here should now be dealt with, so * we need to descend any right nodes that are not back pointers */ - if ( m_bitNum > m_rightN->getBitNum() ) + if ( m_bitNum > m_rightN->get_bitNum() ) { /* There are some right nodes to descend and deal with. */ Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontoken.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontoken.hpp 2013-05-20 15:34:35 UTC (rev 4651) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontoken.hpp 2013-06-19 21:12:29 UTC (rev 4652) @@ -138,12 +138,11 @@ bool operator==( const CommonToken& ctoken ) const; bool operator<( const CommonToken& ctoken ) const; - ANTLR_MARKER getIndex() const; - void setIndex( ANTLR_MARKER index ); + InputStreamType* get_input() const; + ANTLR_MARKER get_index() const; + void set_index( ANTLR_MARKER index ); + void set_input( InputStreamType* input ); - InputStreamType* getInput() const; - void setInput( InputStreamType* input ); - /* ============================== * API */ @@ -153,16 +152,16 @@ */ StringType getText() const; - /** Function that 'might' be able to set the text associated + /** 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( const StringType& text ); + void set_tokText( const StringType& text ); - /** Function that 'might' be able to set the text associated + /** 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 @@ -172,72 +171,70 @@ void setText(ANTLR_UINT8* text); void setText(const char* text); - /** Function that returns the token type of this token + /** Pointer to a function that returns the token type of this token */ + ANTLR_UINT32 get_type() const; ANTLR_UINT32 getType() const; - /** Function that sets the type of this token + /** Pointer to a function that sets the type of this token */ - void setType(ANTLR_UINT32 ttype); + void set_type(ANTLR_UINT32 ttype); - /** Function that gets the 'line' number where this token resides + /** Pointer to a function that gets the 'line' number where this token resides */ - ANTLR_UINT32 getLine() const; + ANTLR_UINT32 get_line() const; - /** Function that sets the 'line' number where this token reside + /** Pointer to a function that sets the 'line' number where this token reside */ - void setLine(ANTLR_UINT32 line); + void set_line(ANTLR_UINT32 line); - /** Function that gets the offset in the line where this token exists + /** Pointer to a function that gets the offset in the line where this token exists */ - ANTLR_INT32 getCharPositionInLine() const; + ANTLR_INT32 get_charPositionInLine() const; + ANTLR_INT32 getCharPositionInLine() const; - /** Function that sets the offset in the line where this token exists + /** Pointer to a function that sets the offset in the line where this token exists */ - void setCharPositionInLine(ANTLR_INT32 pos); + void set_charPositionInLine(ANTLR_INT32 pos); - /** Function that gets the channel that this token was placed in (parsers + /** Pointer to a function that gets the channel that this token was placed in (parsers * can 'tune' to these channels. */ - ANTLR_UINT32 getChannel() const; + ANTLR_UINT32 get_channel() const; - /** Function that sets the channel that this token should belong to + /** Pointer to a function that sets the channel that this token should belong to */ - void setChannel(ANTLR_UINT32 channel); + void set_channel(ANTLR_UINT32 channel); - /** Function that returns an index 0...n-1 of the token in the token + /** Pointer to a function that returns an index 0...n-1 of the token in the token * input stream. */ - ANTLR_MARKER getTokenIndex() const; + ANTLR_MARKER get_tokenIndex() const; - /** Function that can set the token index of this token in the token + /** Pointer to a function that can set the token index of this token in the token * input stream. */ - void setTokenIndex(ANTLR_MARKER tokenIndex); + void set_tokenIndex(ANTLR_MARKER tokenIndex); - /** Function that gets the start index in the input stream for this token. + /** Pointer to a function that gets the start index in the input stream for this token. */ - ANTLR_MARKER getStartIndex() const; + ANTLR_MARKER get_startIndex() const; - /** Function that sets the start index in the input stream for this token. + /** Pointer to a function that sets the start index in the input stream for this token. */ - void setStartIndex(ANTLR_MARKER index); + void set_startIndex(ANTLR_MARKER index); - /** Function that gets the stop index in the input stream for this token. + /** Pointer to a function that gets the stop index in the input stream for this token. */ - ANTLR_MARKER getStopIndex() const; + ANTLR_MARKER get_stopIndex() const; - /** Function that sets the stop index in the input stream for this token. + /** Pointer to a function that sets the stop index in the input stream for this token. */ - void setStopIndex(ANTLR_MARKER index); + void set_stopIndex(ANTLR_MARKER index); + const StreamDataType* get_lineStart() const; + void set_lineStart( const StreamDataType* lineStart ); - /** - * NOTE: These methods are not present in Java target API - */ - const StreamDataType* getLineStart() const; - void setLineStart( const StreamDataType* lineStart ); - - /** Function that returns this token as a text representation that can be + /** 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. Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontoken.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontoken.inl 2013-05-20 15:34:35 UTC (rev 4651) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontoken.inl 2013-06-19 21:12:29 UTC (rev 4652) @@ -95,25 +95,25 @@ } template<class ImplTraits> -ANTLR_INLINE typename CommonToken<ImplTraits>::InputStreamType* CommonToken<ImplTraits>::getInput() const +ANTLR_INLINE typename CommonToken<ImplTraits>::InputStreamType* CommonToken<ImplTraits>::get_input() const { return m_input; } template<class ImplTraits> -ANTLR_INLINE ANTLR_MARKER CommonToken<ImplTraits>::getIndex() const +ANTLR_INLINE ANTLR_MARKER CommonToken<ImplTraits>::get_index() const { return m_index; } template<class ImplTraits> -ANTLR_INLINE void CommonToken<ImplTraits>::setIndex( ANTLR_MARKER index ) +ANTLR_INLINE void CommonToken<ImplTraits>::set_index( ANTLR_MARKER index ) { m_index = index; } template<class ImplTraits> -void CommonToken<ImplTraits>::setInput( InputStreamType* input ) +void CommonToken<ImplTraits>::set_input( InputStreamType* input ) { m_input = input; } @@ -136,7 +136,7 @@ // from the input stream // if (m_input != NULL) - return m_input->substr( this->getStartIndex(), this->getStopIndex() ); + return m_input->substr( this->get_startIndex(), this->get_stopIndex() ); // Nothing to return, there is no input stream // @@ -144,7 +144,7 @@ } template<class ImplTraits> -ANTLR_INLINE void CommonToken<ImplTraits>::setText( const StringType& text ) +ANTLR_INLINE void CommonToken<ImplTraits>::set_tokText( const StringType& text ) { m_tokText = text; } @@ -168,97 +168,109 @@ } template<class ImplTraits> +ANTLR_INLINE ANTLR_UINT32 CommonToken<ImplTraits>::get_type() const +{ + return m_type; +} + +template<class ImplTraits> ANTLR_INLINE ANTLR_UINT32 CommonToken<ImplTraits>::getType() const { return m_type; } template<class ImplTraits> -ANTLR_INLINE void CommonToken<ImplTraits>::setType(ANTLR_UINT32 ttype) +ANTLR_INLINE void CommonToken<ImplTraits>::set_type(ANTLR_UINT32 ttype) { m_type = ttype; } template<class ImplTraits> -ANTLR_INLINE ANTLR_UINT32 CommonToken<ImplTraits>::getLine() const +ANTLR_INLINE ANTLR_UINT32 CommonToken<ImplTraits>::get_line() const { return m_line; } template<class ImplTraits> -ANTLR_INLINE void CommonToken<ImplTraits>::setLine(ANTLR_UINT32 line) +ANTLR_INLINE void CommonToken<ImplTraits>::set_line(ANTLR_UINT32 line) { m_line = line; } template<class ImplTraits> -ANTLR_INLINE ANTLR_INT32 CommonToken<ImplTraits>::getCharPositionInLine() const +ANTLR_INLINE ANTLR_INT32 CommonToken<ImplTraits>::get_charPositionInLine() const { return m_charPositionInLine; } template<class ImplTraits> -ANTLR_INLINE void CommonToken<ImplTraits>::setCharPositionInLine(ANTLR_INT32 pos) +ANTLR_INLINE ANTLR_INT32 CommonToken<ImplTraits>::getCharPositionInLine() const { + return this->get_charPositionInLine(); +} + +template<class ImplTraits> +ANTLR_INLINE void CommonToken<ImplTraits>::set_charPositionInLine(ANTLR_INT32 pos) +{ m_charPositionInLine = pos; } template<class ImplTraits> -ANTLR_INLINE ANTLR_UINT32 CommonToken<ImplTraits>::getChannel() const +ANTLR_INLINE ANTLR_UINT32 CommonToken<ImplTraits>::get_channel() const { return m_channel; } template<class ImplTraits> -ANTLR_INLINE void CommonToken<ImplTraits>::setChannel(ANTLR_UINT32 channel) +ANTLR_INLINE void CommonToken<ImplTraits>::set_channel(ANTLR_UINT32 channel) { m_channel = channel; } template<class ImplTraits> -ANTLR_INLINE ANTLR_MARKER CommonToken<ImplTraits>::getTokenIndex() const +ANTLR_INLINE ANTLR_MARKER CommonToken<ImplTraits>::get_tokenIndex() const { return m_index; } template<class ImplTraits> -ANTLR_INLINE void CommonToken<ImplTraits>::setTokenIndex(ANTLR_MARKER tokenIndex) +ANTLR_INLINE void CommonToken<ImplTraits>::set_tokenIndex(ANTLR_MARKER tokenIndex) { m_index = tokenIndex; } template<class ImplTraits> -ANTLR_INLINE ANTLR_MARKER CommonToken<ImplTraits>::getStartIndex() const +ANTLR_INLINE ANTLR_MARKER CommonToken<ImplTraits>::get_startIndex() const { - return (m_startIndex == -1) ? (ANTLR_MARKER)(m_input->getData()) : m_startIndex; + return (m_startIndex == -1) ? (ANTLR_MARKER)(m_input->get_data()) : m_startIndex; } template<class ImplTraits> -ANTLR_INLINE void CommonToken<ImplTraits>::setStartIndex(ANTLR_MARKER index) +ANTLR_INLINE void CommonToken<ImplTraits>::set_startIndex(ANTLR_MARKER index) { m_startIndex = index; } template<class ImplTraits> -ANTLR_INLINE ANTLR_MARKER CommonToken<ImplTraits>::getStopIndex() const +ANTLR_INLINE ANTLR_MARKER CommonToken<ImplTraits>::get_stopIndex() const { return m_stopIndex; } template<class ImplTraits> -ANTLR_INLINE void CommonToken<ImplTraits>::setStopIndex(ANTLR_MARKER index) +ANTLR_INLINE void CommonToken<ImplTraits>::set_stopIndex(ANTLR_MARKER index) { m_stopIndex = index; } template<class ImplTraits> -ANTLR_INLINE const typename CommonToken<ImplTraits>::StreamDataType* CommonToken<ImplTraits>::getLineStart() const +ANTLR_INLINE const typename CommonToken<ImplTraits>::StreamDataType* CommonToken<ImplTraits>::get_lineStart() const { return m_lineStart; } template<class ImplTraits> -ANTLR_INLINE void CommonToken<ImplTraits>::setLineStart( const StreamDataType* lineStart ) +ANTLR... [truncated message content] |
From: <ibr...@us...> - 2013-06-20 21:58:22
|
Revision: 4653 http://sourceforge.net/p/tora/code/4653 Author: ibre5041 Date: 2013-06-20 21:58:18 +0000 (Thu, 20 Jun 2013) Log Message: ----------- Modified Paths: -------------- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3input.inl branches/tora3/extlibs/parsing.cpp/Makefile branches/tora3/extlibs/parsing.cpp/PLSQLParser.g branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/Cpp.stg branches/tora3/extlibs/parsing.cpp/t1.cpp Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3input.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3input.inl 2013-06-19 21:12:29 UTC (rev 4652) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3input.inl 2013-06-20 21:58:18 UTC (rev 4653) @@ -283,7 +283,7 @@ { m_nextChar = m_data; /* Input at first character */ m_line = 1; /* starts at line 1 */ - m_charPositionInLine = -1; + m_charPositionInLine = 0; m_currentLine = m_data; m_markDepth = 0; /* Reset markers */ Modified: branches/tora3/extlibs/parsing.cpp/Makefile =================================================================== --- branches/tora3/extlibs/parsing.cpp/Makefile 2013-06-19 21:12:29 UTC (rev 4652) +++ branches/tora3/extlibs/parsing.cpp/Makefile 2013-06-20 21:58:18 UTC (rev 4653) @@ -31,7 +31,7 @@ t0: t0.cpp PLSQLGuiLexer.tokens t0.cpp $(TOBJS) PLSQLGuiLexer.o Makefile UserGuiTraits.hpp g++ $(CFLAGS) -DUSESTL $(INCLUDES) $(TOBJS) t0.cpp PLSQLGuiLexer.o $(LIBS) -o $@ -t1: t1.cpp PLSQLLexer.tokens PLSQLParser.tokens t1.cpp $(TOBJS) $(PSOURCES) Makefile UserTraits.hpp +t1: t1.cpp PLSQLLexer.tokens PLSQLParser.tokens t1.cpp $(TOBJS) $(POBJS) Makefile UserTraits.hpp g++ $(CFLAGS) -DUSESTL $(INCLUDES) $(TOBJS) t1.cpp $(POBJS) -o $@ t2: t2.cpp PLSQLLexer.tokens PLSQLParser.tokens t1.cpp $(TOBJS) $(PSOURCES) Makefile UserTraits.hpp Modified: branches/tora3/extlibs/parsing.cpp/PLSQLParser.g =================================================================== --- branches/tora3/extlibs/parsing.cpp/PLSQLParser.g 2013-06-19 21:12:29 UTC (rev 4652) +++ branches/tora3/extlibs/parsing.cpp/PLSQLParser.g 2013-06-20 21:58:18 UTC (rev 4653) @@ -20,7 +20,7 @@ options { tokenVocab=PLSQLLexer; language=Cpp; - memoize=true; + //memoize=true; //output=AST; } @@ -829,7 +829,7 @@ // $<PL/SQL Statements -seq_of_statements +seq_of_statements returns[void* p, void*q] : (statement (SEMICOLON|EOF)|label_declaration)+ ; Modified: branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/Cpp.stg =================================================================== --- branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/Cpp.stg 2013-06-19 21:12:29 UTC (rev 4652) +++ branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/Cpp.stg 2013-06-20 21:58:18 UTC (rev 4653) @@ -998,8 +998,8 @@ <grammar.delegatedRules:{ruleDescriptor| <returnType()> <name>::<ruleDescriptor.name>(<ruleDescriptor.parameterScope:parameterScope()>) { - <if(ruleDescriptor.hasReturnValue)>return <endif> m_<ruleDescriptor.grammar:delegateName()>-><ruleDescriptor.name>( <ruleDescriptor.parameterScope.attributes:{a|<a.name>}; separator=", ">); - \}}; separator="\n"> + <if(ruleDescriptor.hasReturnValue)>return <endif>m_<ruleDescriptor.grammar:delegateName()>-><ruleDescriptor.name>(<if(ruleDescriptor.parameterScope)><ruleDescriptor.parameterScope.attributes:{a|<a.name>}; separator=", "><endif>); + \}}; separator="\n"> <endif> /* End of parsing rules Modified: branches/tora3/extlibs/parsing.cpp/t1.cpp =================================================================== --- branches/tora3/extlibs/parsing.cpp/t1.cpp 2013-06-19 21:12:29 UTC (rev 4652) +++ branches/tora3/extlibs/parsing.cpp/t1.cpp 2013-06-20 21:58:18 UTC (rev 4653) @@ -140,7 +140,7 @@ input = new PLSQLTraits::InputStreamType((const ANTLR_UINT8 *)data.c_str(), ANTLR_ENC_8BIT, data.length(), //strlen(data.c_str()), - (ANTLR_UINT8*)fName); + (ANTLR_UINT8*)fName); input->setUcaseLA(true); @@ -209,7 +209,12 @@ tstream->_LT(1); // Don't do this mormally, just causes lexer to run for timings here //putc('P', stdout); fflush(stdout); - psr->seq_of_statements(); + PLSQLParser::seq_of_statements_return r = psr->seq_of_statements(); + std::cout << r.start->getText() << '[' << r.start->get_line() << ',' << r.start->get_charPositionInLine() << ']' + << ".." + << r.stop->getText() << '[' << r.stop->get_line() << ',' << r.stop->get_charPositionInLine() << ']' + << std::endl; + //putc('F', stdout); fflush(stdout); //putc('*', stdout); fflush(stdout); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <ibr...@us...> - 2013-06-26 14:52:04
|
Revision: 4658 http://sourceforge.net/p/tora/code/4658 Author: ibre5041 Date: 2013-06-26 14:51:58 +0000 (Wed, 26 Jun 2013) Log Message: ----------- sync with antlr trunk(fixes branch) Modified Paths: -------------- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontoken.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3intstream.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3intstream.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.inl branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3traits.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3treeparser.hpp branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/Cpp.stg Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontoken.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontoken.inl 2013-06-25 15:56:00 UTC (rev 4657) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontoken.inl 2013-06-26 14:51:58 UTC (rev 4658) @@ -164,7 +164,7 @@ if( text == NULL ) m_tokText.clear(); else - m_tokText = text; + m_tokText = (const char*) text; } template<class ImplTraits> Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.hpp 2013-06-25 15:56:00 UTC (rev 4657) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.hpp 2013-06-26 14:51:58 UTC (rev 4658) @@ -45,7 +45,7 @@ typedef typename ImplTraits::StringType StringType; typedef typename ImplTraits::CommonTokenType CommonTokenType; typedef typename ImplTraits::TreeType TreeType; - //typedef CommonTree TokenType; + typedef CommonTree TokenType; typedef typename AllocPolicyType::template VectorType<TreeType*> ChildrenType; typedef typename AllocPolicyType::template ListType<TreeType*> ChildListType; @@ -55,6 +55,10 @@ /// ChildrenType m_children; + /// This is used to store the current child index position while descending + /// and ascending trees as the tree walk progresses. + /// + ANTLR_MARKER m_savedIndex; /// Start token index that encases this tree /// @@ -66,7 +70,7 @@ /// A single token, this is the payload for the tree /// - const CommonTokenType* m_token; + CommonTokenType* m_token; /// Points to the node that has this node as a child. /// If this is NULL, then this is the root node. @@ -80,25 +84,17 @@ public: CommonTree(); - CommonTree( const CommonTokenType* token ); - CommonTree( const CommonTree* token ); + CommonTree( CommonTokenType* token ); + CommonTree( CommonTree* token ); CommonTree( const CommonTree& ctree ); - ~CommonTree(); - const CommonTokenType* get_token() const; - void set_token(CommonTokenType*); - + TokenType* get_token() const; ChildrenType& get_children(); const ChildrenType& get_children() const; + ChildrenType* get_children_p(); ANTLR_INT32 get_childIndex() const; TreeType* get_parent() const; - ANTLR_MARKER get_startIndex() const; - void set_startIndex(ANTLR_MARKER index); - - ANTLR_MARKER get_stopIndex() const; - void set_stopIndex(ANTLR_MARKER index); - void set_parent( TreeType* parent); void set_childIndex( ANTLR_INT32 ); @@ -106,7 +102,7 @@ /// Add all elements of the supplied list as children of this node /// void addChildren(const ChildListType& kids); - + void createChildrenList(); TreeType* deleteChild(ANTLR_UINT32 i); /// Delete children from start to stop and replace with t even if t is /// a list (nil-root tree). Num of children can increase or decrease. @@ -128,11 +124,10 @@ void setChild(ANTLR_UINT32 i, TreeType* child); StringType toStringTree(); StringType toString(); - void freshenParentAndChildIndexes(); - void freshenParentAndChildIndexes(ANTLR_UINT32 offset); - void freshenParentAndChildIndexesDeeply(); - void freshenParentAndChildIndexesDeeply(ANTLR_UINT32 offset); - + void freshenPACIndexesAll(); + void freshenPACIndexes(ANTLR_UINT32 offset); + void reuse(); + ~CommonTree(); }; ANTLR_END_NAMESPACE() Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.inl 2013-06-25 15:56:00 UTC (rev 4657) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontree.inl 2013-06-26 14:51:58 UTC (rev 4658) @@ -3,82 +3,90 @@ template<class ImplTraits> CommonTree<ImplTraits>::CommonTree() { - m_startIndex = -1; - m_stopIndex = -1; - m_childIndex = -1; + m_savedIndex = 0; + m_startIndex = 0; + m_stopIndex = 0; m_token = NULL; m_parent = NULL; + m_childIndex = 0; } template<class ImplTraits> CommonTree<ImplTraits>::CommonTree( const CommonTree& ctree ) :m_children( ctree.m_children) { + m_savedIndex = ctree.m_savedIndex; m_startIndex = ctree.m_startIndex; m_stopIndex = ctree.m_stopIndex; - m_childIndex = ctree.m_childIndex; m_token = ctree.m_token; m_parent = ctree.m_parent; + m_childIndex = ctree.m_childIndex; } template<class ImplTraits> -CommonTree<ImplTraits>::CommonTree( const CommonTokenType* token ) +CommonTree<ImplTraits>::CommonTree( CommonTokenType* token ) { - m_startIndex = -1; - m_stopIndex = -1; - m_childIndex = -1; + m_savedIndex = 0; + m_startIndex = 0; + m_stopIndex = 0; m_token = token; m_parent = NULL; + m_childIndex = 0; } template<class ImplTraits> -CommonTree<ImplTraits>::CommonTree( const CommonTree* tree ) +CommonTree<ImplTraits>::CommonTree( CommonTree* tree ) { - m_startIndex = -1; - m_stopIndex = -1; - m_childIndex = -1; + m_savedIndex = 0; + m_startIndex = 0; + m_stopIndex = 0; m_token = tree->get_token(); m_parent = NULL; + m_childIndex = 0; } template<class ImplTraits> -const typename CommonTree<ImplTraits>::CommonTokenType* CommonTree<ImplTraits>::get_token() const +typename CommonTree<ImplTraits>::TokenType* CommonTree<ImplTraits>::get_token() const { return m_token; } template<class ImplTraits> -void CommonTree<ImplTraits>::set_token(typename CommonTree<ImplTraits>::CommonTokenType* token) +typename CommonTree<ImplTraits>::ChildrenType& CommonTree<ImplTraits>::get_children() { - return m_token; + return m_children; } template<class ImplTraits> -typename CommonTree<ImplTraits>::ChildrenType& CommonTree<ImplTraits>::get_children() +const typename CommonTree<ImplTraits>::ChildrenType& CommonTree<ImplTraits>::get_children() const { return m_children; } template<class ImplTraits> -const typename CommonTree<ImplTraits>::ChildrenType& CommonTree<ImplTraits>::get_children() const +typename CommonTree<ImplTraits>::ChildrenType* CommonTree<ImplTraits>::get_children_p() { - return m_children; + return &m_children; } template<class ImplTraits> void CommonTree<ImplTraits>::addChild(TreeType* child) { + ANTLR_UINT32 n; + ANTLR_UINT32 i; + if (child == NULL) return; ChildrenType& child_children = child->get_children(); - //ChildrenType& tree_children = this->get_children(); + ChildrenType& tree_children = this->get_children(); if (child->isNilNode() == true) { - if ( !child_children.empty() && child_children == m_children ) + if ( !child_children.empty() && child_children == tree_children ) { // TODO: Change to exception rather than ANTLR3_FPRINTF? + // fprintf(stderr, "ANTLR3: An attempt was made to add a child list to itself!\n"); return; } @@ -87,42 +95,55 @@ // if ( !child_children.empty() ) { - if (!m_children.empty()) + if (tree_children.empty()) { - // Need to copy the children - ANTLR_UINT32 n = child_children.size(); - for (ANTLR_UINT32 i = 0; i < n; i++) - { - TreeType* entry = child_children.at(i); - // ANTLR3 lists can be sparse, unlike Array Lists (TODO: really?) - if (entry != NULL) - m_children.push_back(entry); - entry->set_parent(this); - entry->set_childIndex(m_children.size()-1); - } - } else { // We are build ing the tree structure here, so we need not // worry about duplication of pointers as the tree node // factory will only clean up each node once. So we just // copy in the child's children pointer as the child is // a nil node (has not root itself). // - m_children.swap( child_children ); - this->freshenParentAndChildIndexes(); + tree_children.swap( child_children ); + this->freshenPACIndexesAll(); } + else + { + // Need to copy the children + // + n = child_children.size(); + + for (i = 0; i < n; i++) + { + TreeType* entry; + entry = child_children[i]; + + // ANTLR3 lists can be sparse, unlike Array Lists + // + if (entry != NULL) + { + tree_children.push_back(entry); + } + } + } } } else { // Tree we are adding is not a Nil and might have children to copy - m_children.push_back( child ); - child->set_parent(this); - child->set_childIndex(m_children.size()-1); + // + if (tree_children.empty()) + { + // No children in the tree we are adding to, so create a new list on + // the fly to hold them. + // + this->createChildrenList(); + } + tree_children.push_back( child ); } } template<class ImplTraits> -void CommonTree<ImplTraits>::addChildren(const ChildListType& kids) +void CommonTree<ImplTraits>::addChildren(const ChildListType& kids) { for( typename ChildListType::const_iterator iter = kids.begin(); iter != kids.end(); ++iter ) @@ -131,97 +152,124 @@ } } +//dummy one, as vector is always there template<class ImplTraits> +void CommonTree<ImplTraits>::createChildrenList() +{ +} + +template<class ImplTraits> typename CommonTree<ImplTraits>::TreeType* CommonTree<ImplTraits>::deleteChild(ANTLR_UINT32 i) { if( m_children.empty() ) return NULL; - TreeType* killed = m_children.erase( m_children.begin() + i); - this->freshenParentAndChildIndexes(i); - return killed; + + return m_children.erase( m_children.begin() + i); } template<class ImplTraits> void CommonTree<ImplTraits>::replaceChildren(ANTLR_INT32 startChildIndex, ANTLR_INT32 stopChildIndex, TreeType* newTree) { - + ANTLR_INT32 replacingHowMany; // How many nodes will go away + ANTLR_INT32 replacingWithHowMany; // How many nodes will replace them ANTLR_INT32 numNewChildren; // Tracking variable ANTLR_INT32 delta; // Difference in new vs existing count + ANTLR_INT32 i; + ANTLR_INT32 j; + if ( m_children.empty() ) { - fprintf(stderr, "replaceChildren call: Indexes are invalid; no children in list for %s", this->get_text().c_str() ); - // TODO throw here + fprintf(stderr, "replaceChildren call: Indexes are invalid; no children in list for %s", this->getText().c_str() ); return; } - // How many nodes will go away - ANTLR_INT32 replacingHowMany = stopChildIndex - startChildIndex + 1; - ANTLR_INT32 replacingWithHowMany; // How many nodes will replace them // Either use the existing list of children in the supplied nil node, or build a vector of the // tree we were given if it is not a nil node, then we treat both situations exactly the same // - ChildrenType newChildren; - ChildrenType &newChildrenRef(newChildren); + ChildrenType newChildren_temp; + ChildrenType* newChildren; // Iterator for whatever we are going to add in if (newTree->isNilNode()) { - newChildrenRef = newTree->get_children(); - } else { - newChildrenRef.push_back(newTree); + newChildren = newTree->get_children_p(); } + else + { + newChildren = &newChildren_temp; + newChildren->push_back(newTree); + } // Initialize - replacingWithHowMany = newChildrenRef.size(); - numNewChildren = newChildrenRef.size(); + // + replacingHowMany = stopChildIndex - startChildIndex + 1; + replacingWithHowMany = newChildren->size(); delta = replacingHowMany - replacingWithHowMany; + numNewChildren = newChildren->size(); // If it is the same number of nodes, then do a direct replacement // if (delta == 0) { - ANTLR_INT32 j = 0; - for (ANTLR_INT32 i = startChildIndex; i <= stopChildIndex; i++) + TreeType* child; + + // Same number of nodes + // + j = 0; + for (i = startChildIndex; i <= stopChildIndex; i++) { - TreeType *child = newChildrenRef.at(j); - m_children[i] = child; - child->set_parent(this); - child->set_childIndex(i); - j++; + child = newChildren->at(j); + ChildrenType& parent_children = this->get_children(); + parent_children[i] = child; + child->setParent(this); + child->setChildIndex(i); } } else if (delta > 0) { + ANTLR_UINT32 indexToDelete; + // Less nodes than there were before // reuse what we have then delete the rest - for (ANTLR_UINT32 j = 0; j < numNewChildren; j++) + // + ChildrenType& parent_children = this->get_children(); + for (j = 0; j < numNewChildren; j++) { - m_children[ startChildIndex + j ] = newChildrenRef.at(j); + parent_children[ startChildIndex + j ] = newChildren->at(j); } + // We just delete the same index position until done - ANTLR_UINT32 indexToDelete = startChildIndex + numNewChildren; - for (ANTLR_UINT32 j = indexToDelete; j <= stopChildIndex; j++) + // + indexToDelete = startChildIndex + numNewChildren; + + for (j = indexToDelete; j <= stopChildIndex; j++) { - m_children.erase( m_children.begin() + indexToDelete); + parent_children.erase( parent_children.begin() + indexToDelete); } - this->freshenParentAndChildIndexes(startChildIndex); + + this->freshenPACIndexes(startChildIndex); } else { + ChildrenType& parent_children = this->get_children(); + ANTLR_UINT32 numToInsert; + // More nodes than there were before // Use what we can, then start adding - for (ANTLR_UINT32 j = 0; j < replacingHowMany; j++) + // + for (j = 0; j < replacingHowMany; j++) { - m_children[ startChildIndex + j ] = newChildrenRef.at(j); + parent_children[ startChildIndex + j ] = newChildren->at(j); } - ANTLR_UINT32 numToInsert = replacingWithHowMany - replacingHowMany; - for (ANTLR_UINT32 j = replacingHowMany; j < replacingWithHowMany; j++) + numToInsert = replacingWithHowMany - replacingHowMany; + + for (j = replacingHowMany; j < replacingWithHowMany; j++) { - m_children.push_back( newChildrenRef.at(j) ); + parent_children.push_back( newChildren->at(j) ); } - this->freshenParentAndChildIndexes(startChildIndex); + this->freshenPACIndexes(startChildIndex); } } @@ -229,8 +277,14 @@ CommonTree<ImplTraits>* CommonTree<ImplTraits>::dupNode() const { // The node we are duplicating is in fact the common tree (that's why we are here) - // so we use the super pointer to duplicate. - return new CommonTree<ImplTraits>(this); + // so we use the super pointer to duplicate. + // + TreeType* clone = new TreeType(); + + // The pointer we return is the base implementation of course + // + clone->set_token( m_token ); + return clone; } template<class ImplTraits> @@ -267,23 +321,33 @@ template<class ImplTraits> ANTLR_UINT32 CommonTree<ImplTraits>::getCharPositionInLine() { - if(m_token == NULL || (m_token->get_charPositionInLine() == -1) ) + CommonTokenType* token; + token = m_token; + + if (token == NULL || (token->getCharPositionInLine() == -1) ) { - if(this->getChildCount() > 0) - return this->getChild(0)->get_charPositionInLine(); + if (this->getChildCount() > 0) + { + TreeType* child; + + child = this->getChild(0); + + return child->getCharPositionInLine(); + } return 0; } - return m_token->get_charPositionInLine(); + return token->getCharPositionInLine(); } template<class ImplTraits> typename CommonTree<ImplTraits>::TreeType* CommonTree<ImplTraits>::getChild(ANTLR_UINT32 i) { - if ( m_children.empty() || i >= m_children.size() ) + if ( m_children.empty() + || i >= m_children.size() ) { return NULL; } - return m_children.at(i); + return m_children[i]; } @@ -318,40 +382,16 @@ } template<class ImplTraits> -ANTLR_MARKER CommonTree<ImplTraits>::get_startIndex() const -{ - if( m_startIndex==-1 && m_token!=NULL) - return m_token->get_tokenIndex(); - return m_startIndex; -} - -template<class ImplTraits> -void CommonTree<ImplTraits>::set_startIndex( ANTLR_MARKER index) -{ - m_startIndex = index; -} - -template<class ImplTraits> -ANTLR_MARKER CommonTree<ImplTraits>::get_stopIndex() const -{ - if( m_stopIndex==-1 && m_token!=NULL) - return m_token->get_tokenIndex(); - return m_stopIndex; -} - -template<class ImplTraits> -void CommonTree<ImplTraits>::set_stopIndex( ANTLR_MARKER index) -{ - m_stopIndex = index; -} - -template<class ImplTraits> ANTLR_UINT32 CommonTree<ImplTraits>::getType() { - if (m_token == NULL) - return CommonTokenType::TOKEN_INVALID; + if (this == NULL) + { + return 0; + } else - return m_token->get_type(); + { + return m_token->getType(); + } } template<class ImplTraits> @@ -379,13 +419,21 @@ template<class ImplTraits> ANTLR_UINT32 CommonTree<ImplTraits>::getLine() { - if(m_token == NULL || m_token->get_line() == 0) + TreeType* cTree = this; + CommonTokenType* token; + token = cTree->get_token(); + + if (token == NULL || token->getLine() == 0) { if ( this->getChildCount() > 0) - return this->getChild(0)->get_line(); + { + TreeType* child; + child = this->getChild(0); + return child->getLine(); + } return 0; } - return m_token->get_line(); + return token->getLine(); } template<class ImplTraits> @@ -395,117 +443,121 @@ } template<class ImplTraits> -bool CommonTree<ImplTraits>::isNilNode() +bool CommonTree<ImplTraits>::isNilNode() { // This is a Nil tree if it has no payload (Token in our case) + // if(m_token == NULL) + { return true; + } else + { return false; + } } template<class ImplTraits> -void CommonTree<ImplTraits>::setChild(ANTLR_UINT32 i, TreeType* child) +void CommonTree<ImplTraits>::setChild(ANTLR_UINT32 i, TreeType* child) { - if( child==NULL) - return; - - if( child->isNilNode()) - { - // TODO: throw IllegalArgumentException - return; - } - - if( m_children.size() <= i ) + if( m_children.size() >= i ) m_children.resize(i+1); - m_children[i] = child; - child->set_parent(this); - child->set_childIndex(i); } template<class ImplTraits> typename CommonTree<ImplTraits>::StringType CommonTree<ImplTraits>::toStringTree() { - StringType retval; + StringType string; + ANTLR_UINT32 i; + ANTLR_UINT32 n; + TreeType* t; if( m_children.empty() ) + { return this->toString(); + } /* Need a new string with nothing at all in it. */ - if(this->isNilNode() == false) + if (this->isNilNode() == false) { - retval.append("("); - retval.append(this->toString()); - retval.append(" "); + string.append("("); + string.append(this->toString()); + string.append(" "); } - if ( !m_children.empty()) + if ( m_children != NULL) { - ANTLR_UINT32 n = m_children.size(); - for (ANTLR_UINT32 i = 0; i < n; i++) + n = m_children.size(); + + for (i = 0; i < n; i++) { - TreeType *t = m_children.at(i); + t = m_children[i]; + if (i > 0) { - retval.append(" "); + string.append(" "); } - retval.append(t->toStringTree()); + string.append(t->toStringTree()); } } if (this->isNilNode() == false) { - retval.append(")"); + string.append(")"); } - return retval; + + return string; } template<class ImplTraits> typename CommonTree<ImplTraits>::StringType CommonTree<ImplTraits>::toString() { - if( this->isNilNode()) - return StringType("nil"); + if (this->isNilNode() ) + { + StringType nilNode; + + nilNode = "nil"; + + return nilNode; + } + return m_token->getText(); } template<class ImplTraits> -void CommonTree<ImplTraits>::freshenParentAndChildIndexes() +void CommonTree<ImplTraits>::freshenPACIndexesAll() { - this->freshenParentAndChildIndexes(0); + this->freshenPACIndexes(0); } template<class ImplTraits> -void CommonTree<ImplTraits>::freshenParentAndChildIndexes(ANTLR_UINT32 offset) +void CommonTree<ImplTraits>::freshenPACIndexes(ANTLR_UINT32 offset) { - ANTLR_UINT32 count = this->getChildCount(); + ANTLR_UINT32 count; + ANTLR_UINT32 c; + + count = this->getChildCount(); // How many children do we have + // Loop from the supplied index and set the indexes and parent - for (ANTLR_UINT32 c = offset; c < count; c++) + // + for (c = offset; c < count; c++) { - TreeType* child = this->getChild(c); - child->set_childIndex(c); - child->set_parent(this); + TreeType* child; + + child = this->getChild(c); + + child->setChildIndex(c); + child->setParent(this); } } template<class ImplTraits> -void CommonTree<ImplTraits>::freshenParentAndChildIndexesDeeply() +void CommonTree<ImplTraits>::reuse() { - this->freshenParentAndChildIndexes(0); + delete this; //memory re-use should be taken by the library user } template<class ImplTraits> -void CommonTree<ImplTraits>::freshenParentAndChildIndexesDeeply(ANTLR_UINT32 offset) -{ - ANTLR_UINT32 count = this->getChildCount(); - for (ANTLR_UINT32 c = offset; c < count; c++) { - TreeType* child = getChild(c); - child->set_childIndex(c); - child->set_parent(this); - child->freshenParentAndChildIndexesDeeply(); - } -} - -template<class ImplTraits> CommonTree<ImplTraits>::~CommonTree() { } Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.hpp 2013-06-25 15:56:00 UTC (rev 4657) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.hpp 2013-06-26 14:51:58 UTC (rev 4658) @@ -59,7 +59,7 @@ void setParent( TreeType* child, TreeType* parent); TreeType* getParent( TreeType* child); - TreeType* errorNode( CommonTokenType* tnstream, const CommonTokenType* startToken, const CommonTokenType* stopToken); + TreeType* errorNode( CommonTokenType* tnstream, CommonTokenType* startToken, CommonTokenType* stopToken); bool isNilNode( TreeType* t); TreeType* becomeRoot( TreeType* newRoot, TreeType* oldRoot); @@ -67,14 +67,11 @@ TreeType* becomeRootToken(CommonTokenType* newRoot, TreeType* oldRoot); - TreeType* create( CommonTokenType const* payload); - TreeType* create( ANTLR_UINT32 tokenType, const CommonTokenType* fromToken); - TreeType* create( ANTLR_UINT32 tokenType, const CommonTokenType* fromToken, const char* text); - TreeType* create( ANTLR_UINT32 tokenType, const char* text); + TreeType* create( CommonTokenType* payload); + TreeType* createTypeToken( ANTLR_UINT32 tokenType, CommonTokenType* fromToken); + TreeType* createTypeTokenText ( ANTLR_UINT32 tokenType, CommonTokenType* fromToken, const ANTLR_UINT8* text); + TreeType* createTypeText ( ANTLR_UINT32 tokenType, const ANTLR_UINT8* text); - CommonTokenType* createToken( ANTLR_UINT32 tokenType, const char* text); - CommonTokenType* createToken( const CommonTokenType* fromToken); - TreeType* dupNode( TreeType* treeNode); ANTLR_UINT32 getType( TreeType* t); StringType getText( TreeType* t); @@ -88,9 +85,11 @@ ANTLR_UINT32 getChildCount( TreeType*); ANTLR_UINT64 getUniqueID( TreeType*); + CommonTokenType* createToken( ANTLR_UINT32 tokenType, const ANTLR_UINT8* text); + CommonTokenType* createTokenFromToken( CommonTokenType* fromToken); CommonTokenType* getToken( TreeType* t); - void setTokenBoundaries( TreeType* t, const CommonTokenType* startToken, const CommonTokenType* stopToken); + void setTokenBoundaries( TreeType* t, CommonTokenType* startToken, CommonTokenType* stopToken); ANTLR_MARKER getTokenStartIndex( TreeType* t); ANTLR_MARKER getTokenStopIndex( TreeType* t); Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.inl 2013-06-25 15:56:00 UTC (rev 4657) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3commontreeadaptor.inl 2013-06-26 14:51:58 UTC (rev 4658) @@ -33,7 +33,7 @@ // Ensure new subtree root has parent/child index set // - this->setChildIndex( newTree, t->get_childIndex() ); + this->setChildIndex( newTree, t->getChildIndex() ); this->setParent(newTree, parent); n = this->getChildCount(t); @@ -67,30 +67,24 @@ template<class ImplTraits> void CommonTreeAdaptor<ImplTraits>::setParent( TreeType* child, TreeType* parent) { - child->set_parent(parent); + child->setParent(parent); } template<class ImplTraits> -typename CommonTreeAdaptor<ImplTraits>::TreeType* -CommonTreeAdaptor<ImplTraits>::getParent( TreeType* child) +typename CommonTreeAdaptor<ImplTraits>::TreeType* CommonTreeAdaptor<ImplTraits>::getParent( TreeType* child) { - if ( child==NULL ) - return NULL; return child->getParent(); } template<class ImplTraits> -typename CommonTreeAdaptor<ImplTraits>::TreeType* -CommonTreeAdaptor<ImplTraits>::errorNode( CommonTokenType* tnstream, - const CommonTokenType* startToken, - const CommonTokenType* stopToken) +typename CommonTreeAdaptor<ImplTraits>::TreeType* CommonTreeAdaptor<ImplTraits>::errorNode( CommonTokenType* tnstream, CommonTokenType* startToken, CommonTokenType* stopToken) { // Use the supplied common tree node stream to get another tree from the factory // TODO: Look at creating the erronode as in Java, but this is complicated by the // need to track and free the memory allocated to it, so for now, we just // want something in the tree that isn't a NULL pointer. // - return this->create( CommonTokenType::TOKEN_INVALID, "Tree Error Node"); + return this->createTypeText( CommonTokenType::TOKEN_INVALID, "Tree Error Node"); } @@ -101,8 +95,7 @@ } template<class ImplTraits> -typename CommonTreeAdaptor<ImplTraits>::TreeType* -CommonTreeAdaptor<ImplTraits>::becomeRoot( TreeType* newRootTree, TreeType* oldRootTree) +typename CommonTreeAdaptor<ImplTraits>::TreeType* CommonTreeAdaptor<ImplTraits>::becomeRoot( TreeType* newRootTree, TreeType* oldRootTree) { TreeType* saveRoot; @@ -142,7 +135,8 @@ newRootTree = newRootTree->getChild(0); // Reclaim the old nilNode() - delete saveRoot; + // + saveRoot->reuse(); } /* Add old root into new root. addChild takes care of the case where oldRoot @@ -164,7 +158,7 @@ // don't know necessarilly know how to do this for the real node, we just ask the tree itself // to do it. // - delete oldRootTree; + oldRootTree->reuse(); } /* Always returns new root structure */ @@ -172,57 +166,71 @@ } template<class ImplTraits> -typename CommonTreeAdaptor<ImplTraits>::TreeType* -CommonTreeAdaptor<ImplTraits>::becomeRootToken( CommonTokenType* newRoot, TreeType* oldRoot) +typename CommonTreeAdaptor<ImplTraits>::TreeType* CommonTreeAdaptor<ImplTraits>::becomeRootToken(CommonTokenType* newRoot, TreeType* oldRoot) { return this->becomeRoot(this->create(newRoot), oldRoot); } template<class ImplTraits> -typename CommonTreeAdaptor<ImplTraits>::TreeType* -CommonTreeAdaptor<ImplTraits>::create( CommonTokenType const* payload) +typename CommonTreeAdaptor<ImplTraits>::TreeType* CommonTreeAdaptor<ImplTraits>::create( CommonTokenType* payload) { return new TreeType(payload); } template<class ImplTraits> -typename CommonTreeAdaptor<ImplTraits>::TreeType* -CommonTreeAdaptor<ImplTraits>::create( ANTLR_UINT32 tokenType, const CommonTokenType* fromToken) +typename CommonTreeAdaptor<ImplTraits>::TreeType* CommonTreeAdaptor<ImplTraits>::createTypeToken( ANTLR_UINT32 tokenType, + CommonTokenType* fromToken) { - /* Create the new token */ - CommonTokenType* newToken = this->createToken(fromToken); - /* Set the type of the new token to that supplied */ - newToken->set_type(tokenType); - /* Return a new node based upon this token */ - return this->create(newToken); + /* Create the new token + */ + fromToken = this->createTokenFromToken(fromToken); + + /* Set the type of the new token to that supplied + */ + fromToken->setType(tokenType); + + /* Return a new node based upon this token + */ + return this->create(fromToken); + } template<class ImplTraits> -typename CommonTreeAdaptor<ImplTraits>::TreeType* -CommonTreeAdaptor<ImplTraits>::create( ANTLR_UINT32 tokenType, const CommonTokenType* fromToken, const char* text) +typename CommonTreeAdaptor<ImplTraits>::TreeType* CommonTreeAdaptor<ImplTraits>::createTypeTokenText( ANTLR_UINT32 tokenType, CommonTokenType* fromToken, const ANTLR_UINT8* text) { - if (fromToken == NULL) - return create(tokenType, text); - /* Create the new token */ - fromToken = this->createToken(fromToken); - /* Set the type of the new token to that supplied */ - fromToken->set_type(tokenType); - /* Set the text of the token accordingly */ - fromToken->set_text(text); - /* Return a new node based upon this token */ + /* Create the new token + */ + fromToken = this->createTokenFromToken(fromToken); + + /* Set the type of the new token to that supplied + */ + fromToken->setType(tokenType); + + /* Set the text of the token accordingly + */ + fromToken->setText(text); + + /* Return a new node based upon this token + */ return this->create(fromToken); } template<class ImplTraits> -typename CommonTreeAdaptor<ImplTraits>::TreeType* -CommonTreeAdaptor<ImplTraits>::create( ANTLR_UINT32 tokenType, const char* text) +typename CommonTreeAdaptor<ImplTraits>::TreeType* CommonTreeAdaptor<ImplTraits>::createTypeText( ANTLR_UINT32 tokenType, const ANTLR_UINT8* text) { - CommonTokenType* fromToken = this->createToken(tokenType, text); + CommonTokenType* fromToken; + + /* Create the new token + */ + fromToken = this->createToken(tokenType, text); + + /* Return a new node based upon this token + */ return this->create(fromToken); } template<class ImplTraits> -typename CommonTreeAdaptor<ImplTraits>::TreeType* CommonTreeAdaptor<ImplTraits>::dupNode( TreeType* treeNode) +typename CommonTreeAdaptor<ImplTraits>::TreeType* CommonTreeAdaptor<ImplTraits>::dupNode( TreeType* treeNode) { return (treeNode == NULL) ? NULL : treeNode->dupNode(); } @@ -230,8 +238,6 @@ template<class ImplTraits> ANTLR_UINT32 CommonTreeAdaptor<ImplTraits>::getType( TreeType* t) { - if ( t==NULL) - return CommonTokenType::TOKEN_INVALID; return t->getType(); } @@ -244,8 +250,6 @@ template<class ImplTraits> typename CommonTreeAdaptor<ImplTraits>::TreeType* CommonTreeAdaptor<ImplTraits>::getChild( TreeType* t, ANTLR_UINT32 i) { - if ( t==NULL ) - return NULL; return t->getChild(i); } @@ -264,23 +268,18 @@ template<class ImplTraits> void CommonTreeAdaptor<ImplTraits>::setChildIndex( TreeType* t, ANTLR_INT32 i) { - if( t!= NULL) - t->set_childIndex(i); + t->setChildIndex(i); } template<class ImplTraits> ANTLR_INT32 CommonTreeAdaptor<ImplTraits>::getChildIndex( TreeType * t) { - if ( t==NULL ) - return 0; return t->getChildIndex(); } template<class ImplTraits> ANTLR_UINT32 CommonTreeAdaptor<ImplTraits>::getChildCount( TreeType* t) { - if ( t==NULL ) - return 0; return t->getChildCount(); } @@ -292,14 +291,14 @@ template<class ImplTraits> typename CommonTreeAdaptor<ImplTraits>::CommonTokenType* - CommonTreeAdaptor<ImplTraits>::createToken( ANTLR_UINT32 tokenType, const char* text) + CommonTreeAdaptor<ImplTraits>::createToken( ANTLR_UINT32 tokenType, const ANTLR_UINT8* text) { CommonTokenType* newToken = new CommonTokenType; if (newToken != NULL) { - newToken->set_tokText( text ); - newToken->set_type(tokenType); + newToken->set_tokText( (const char*) text ); + newToken->setType(tokenType); } return newToken; @@ -307,9 +306,27 @@ template<class ImplTraits> typename CommonTreeAdaptor<ImplTraits>::CommonTokenType* - CommonTreeAdaptor<ImplTraits>::createToken( const CommonTokenType* fromToken) + CommonTreeAdaptor<ImplTraits>::createTokenFromToken( CommonTokenType* fromToken) { - return new CommonTokenType(*fromToken); + CommonTokenType* newToken; + + newToken = new CommonTokenType; + + if (newToken != NULL) + { + // Create the text using our own string factory to avoid complicating + // commontoken. + // + StringType text = fromToken->getText(); + newToken->set_tokText( text ); + newToken->setLine( fromToken->getLine() ); + newToken->setTokenIndex( fromToken->getTokenIndex() ); + newToken->setCharPositionInLine( fromToken->getCharPositionInLine() ); + newToken->setChannel( fromToken->getChannel() ); + newToken->setType( fromToken->getType() ); + } + + return newToken; } template<class ImplTraits> @@ -320,37 +337,51 @@ } template<class ImplTraits> -void CommonTreeAdaptor<ImplTraits>::setTokenBoundaries( TreeType* t, const CommonTokenType* startToken, const CommonTokenType* stopToken) +void CommonTreeAdaptor<ImplTraits>::setTokenBoundaries( TreeType* t, CommonTokenType* startToken, CommonTokenType* stopToken) { - ANTLR_MARKER start = 0; - ANTLR_MARKER stop = 0; + ANTLR_MARKER start; + ANTLR_MARKER stop; + TreeType* ct; + if (t == NULL) + { return; + } if ( startToken != NULL) - start = startToken->get_tokenIndex(); + { + start = startToken->getTokenIndex(); + } + else + { + start = 0; + } if ( stopToken != NULL) - stop = stopToken->get_tokenIndex(); + { + stop = stopToken->getTokenIndex(); + } + else + { + stop = 0; + } - t->set_startIndex(start); - t->set_stopIndex(stop); + ct = t; + + ct->set_startIndex(start); + ct->set_stopIndex(stop); } template<class ImplTraits> ANTLR_MARKER CommonTreeAdaptor<ImplTraits>::getTokenStartIndex( TreeType* t) { - if ( t==NULL ) - return -1; return t->get_tokenStartIndex(); } template<class ImplTraits> ANTLR_MARKER CommonTreeAdaptor<ImplTraits>::getTokenStopIndex( TreeType* t) { - if ( t==NULL ) - return -1; return t->get_tokenStopIndex(); } @@ -611,8 +642,13 @@ template<class ImplTraits> typename CommonTreeAdaptor<ImplTraits>::TreeType* CommonTreeAdaptor<ImplTraits>::rulePostProcessing( TreeType* root) { - TreeType* saveRoot = root; + TreeType* saveRoot; + // Keep track of the root we are given. If it is a nilNode, then we + // can reuse it rather than orphaning it! + // + saveRoot = root; + if (root != NULL && root->isNilNode()) { if (root->getChildCount() == 0) @@ -622,14 +658,14 @@ else if (root->getChildCount() == 1) { root = root->getChild(0); - root->set_parent(NULL); - root->set_childIndex(-1); + root->setParent(NULL); + root->setChildIndex(-1); // The root we were given was a nil node, wiht one child, which means it has // been abandoned and would be lost in the node factory. However // nodes can be flagged as resuable to prevent this terrible waste // - delete saveRoot; + saveRoot->reuse(); } } return root; Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3intstream.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3intstream.hpp 2013-06-25 15:56:00 UTC (rev 4657) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3intstream.hpp 2013-06-26 14:51:58 UTC (rev 4658) @@ -376,11 +376,11 @@ }; template<class ImplTraits> -class TreeNodeIntStream : public IntStream<ImplTraits, typename ImplTraits::TreeNodeStreamType> +class TreeNodeIntStream : public IntStream<ImplTraits, typename ImplTraits::CommonTreeNodeStreamType> { public: - typedef typename ImplTraits::TreeNodeStreamType TreeNodeStreamType; - typedef IntStream<ImplTraits, TreeNodeStreamType > BaseType; + typedef typename ImplTraits::CommonTreeNodeStreamType CommonTreeNodeStreamType; + typedef IntStream<ImplTraits, CommonTreeNodeStreamType > BaseType; typedef typename ImplTraits::TreeType TreeType; typedef typename ImplTraits::CommonTokenType CommonTokenType; Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3intstream.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3intstream.inl 2013-06-25 15:56:00 UTC (rev 4657) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3intstream.inl 2013-06-26 14:51:58 UTC (rev 4658) @@ -1570,7 +1570,7 @@ template<class ImplTraits> void TreeNodeIntStream<ImplTraits>::consume() { - TreeNodeStreamType* ctns = this->get_super(); + CommonTreeNodeStreamType* ctns = this->get_super(); if( ctns->get_p() == -1 ) ctns->fillBufferRoot(); ctns->inc_p(); @@ -1578,14 +1578,14 @@ template<class ImplTraits> ANTLR_MARKER TreeNodeIntStream<ImplTraits>::tindex() { - TreeNodeStreamType* ctns = this->get_super(); + CommonTreeNodeStreamType* ctns = this->get_super(); return (ANTLR_MARKER)(ctns->get_p()); } template<class ImplTraits> ANTLR_UINT32 TreeNodeIntStream<ImplTraits>::_LA(ANTLR_INT32 i) { - TreeNodeStreamType* tns = this->get_super(); + CommonTreeNodeStreamType* tns = this->get_super(); // Ask LT for the 'token' at that position // @@ -1604,7 +1604,7 @@ template<class ImplTraits> ANTLR_MARKER TreeNodeIntStream<ImplTraits>::mark() { - TreeNodeStreamType* ctns = this->get_super(); + CommonTreeNodeStreamType* ctns = this->get_super(); if (ctns->get_p() == -1) { @@ -1640,14 +1640,14 @@ template<class ImplTraits> void TreeNodeIntStream<ImplTraits>::seek(ANTLR_MARKER index) { - TreeNodeStreamType* ctns = this->get_super(); + CommonTreeNodeStreamType* ctns = this->get_super(); ctns->set_p( ANTLR_UINT32_CAST(index) ); } template<class ImplTraits> ANTLR_UINT32 TreeNodeIntStream<ImplTraits>::size() { - TreeNodeStreamType* ctns = this->get_super(); + CommonTreeNodeStreamType* ctns = this->get_super(); if (ctns->get_p() == -1) { Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.hpp 2013-06-25 15:56:00 UTC (rev 4657) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.hpp 2013-06-26 14:51:58 UTC (rev 4658) @@ -53,25 +53,25 @@ /// ANTLR_BEGIN_NAMESPACE() -template<class ImplTraits, class ElementType> -//template<class ImplTraits> -class RewriteRuleElementStream : public ImplTraits::AllocPolicyType +template<class ImplTraits, class SuperType> +class RewriteRuleElementStream : public ImplTraits::AllocPolicyType { public: - //typedef typename ImplTraits::TreeType TreeType; + typedef typename ImplTraits::TreeType TreeType; typedef typename ImplTraits::AllocPolicyType AllocPolicyType; typedef typename ImplTraits::TreeAdaptorType TreeAdaptorType; - //typedef typename ImplTraits::template RecognizerType< typename SuperType::StreamType > RecognizerType; + typedef typename ImplTraits::template RecognizerType< typename SuperType::StreamType > RecognizerType; typedef typename ImplTraits::StringType StringType; - typedef typename AllocPolicyType::template VectorType< ElementType* > ElementsType; + typedef typename SuperType::TokenType TokenType; + typedef typename AllocPolicyType::template VectorType< TokenType* > ElementsType; protected: - /// Track single elements w/o creating a list. Upon 2nd add, alloc list + /// Track single elements w/o creating a list. Upon 2nd add, alloc list /// - ElementType* m_singleElement; + TokenType* m_singleElement; - /// The list of tokens or subtrees we are tracking + /// The list of tokens or subtrees we are tracking /// ElementsType m_elements; @@ -79,64 +79,63 @@ /// rule reference that this list tracks. Can include rulename too, but /// the exception would track that info. /// - StringType m_elementDescription; + StringType m_elementDescription; -private: - ElementType* dupImpl(typename ImplTraits::CommonTokenType* el); - ElementType* dupImpl(typename ImplTraits::TreeType* el); - - /// Pointer to the tree adaptor in use for this stream /// TreeAdaptorType* m_adaptor; + // Pointer to the recognizer shared state to which this stream belongs + // + RecognizerType* m_rec; + /// Cursor 0..n-1. If singleElement!=NULL, cursor is 0 until you next(), /// which bumps it to 1 meaning no more elements. /// - ANTLR_UINT32 m_cursor; + ANTLR_UINT32 m_cursor; /// 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. /// - bool m_dirty; + bool m_dirty; public: - RewriteRuleElementStream(TreeAdaptorType* adaptor, const char* description); - RewriteRuleElementStream(TreeAdaptorType* adaptor, const char* description, ElementType* oneElement); - RewriteRuleElementStream(TreeAdaptorType* adaptor, const char* description, const ElementsType& elements); + RewriteRuleElementStream(TreeAdaptorType* adaptor, RecognizerType* rec, ANTLR_UINT8* description); + RewriteRuleElementStream(TreeAdaptorType* adaptor, RecognizerType* rec, ANTLR_UINT8* description, TokenType* oneElement); + RewriteRuleElementStream(TreeAdaptorType* adaptor, RecognizerType* rec, ANTLR_UINT8* description, const ElementsType& elements); ~RewriteRuleElementStream(); - // Methods + // 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(); + void reset(); /// Add a new pANTLR3_BASE_TREE to this stream /// - void add(ElementType* el); + void add(TokenType* el); /// 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]. /// - //TokenType* next(); - ElementType* nextTree(); - //TokenType* nextToken(); - ElementType* _next(); + TokenType* next(); + TreeType* nextTree(); + TokenType* nextToken(); + TokenType* _next(); /// 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(). /// - ElementType* dup( ElementType* el ); + TokenType* dup( TokenType* el ); /// Ensure stream emits trees; tokens must be converted to AST nodes. /// AST nodes can be passed through unmolested. /// - ElementType* toTree(ElementType* el); + TreeType* toTree(TreeType* el); /// Returns true if there is a next element available /// @@ -151,7 +150,7 @@ /// Referencing to a rule result twice is ok; dup entire tree as /// we can't be adding trees; e.g., expr expr. /// - //TreeType* nextNode(); + TreeType* nextNode(); /// Number of elements available in the stream /// @@ -162,15 +161,14 @@ StringType getDescription(); protected: - void init(TreeAdaptorType* adaptor, const char* description); + void init(TreeAdaptorType* adaptor, RecognizerType* rec, ANTLR_UINT8* description); }; /// This is an implementation of a token stream, which is basically an element /// stream that deals with tokens only. /// template<class ImplTraits> -//class RewriteRuleTokenStream : public ImplTraits::template RewriteRuleElementStreamType< typename ImplTraits::ParserType> -class RewriteRuleTokenStream : public ImplTraits::template RewriteStreamType< const typename ImplTraits::CommonTokenType > +class RewriteRuleTokenStream : public ImplTraits::template RewriteRuleElementStreamType< typename ImplTraits::ParserType> { public: typedef typename ImplTraits::AllocPolicyType AllocPolicyType; @@ -181,26 +179,23 @@ typedef typename ImplTraits::TreeType TreeType; typedef typename AllocPolicyType::template VectorType< TokenType* > ElementsType; typedef typename ImplTraits::template RecognizerType< StreamType > RecognizerType; - typedef typename ImplTraits::template RewriteStreamType< const typename ImplTraits::CommonTokenType > BaseType; + typedef typename ImplTraits::template RewriteRuleElementStreamType< typename ImplTraits::ParserType> BaseType; public: - RewriteRuleTokenStream(TreeAdaptorType* adaptor, const char* description); - RewriteRuleTokenStream(TreeAdaptorType* adaptor, const char* description, TokenType* oneElement); - RewriteRuleTokenStream(TreeAdaptorType* adaptor, const char* description, const ElementsType& elements); - + RewriteRuleTokenStream(TreeAdaptorType* adaptor, RecognizerType* rec, ANTLR_UINT8* description); + RewriteRuleTokenStream(TreeAdaptorType* adaptor, RecognizerType* rec, ANTLR_UINT8* description, TokenType* oneElement); + RewriteRuleTokenStream(TreeAdaptorType* adaptor, RecognizerType* rec, ANTLR_UINT8* description, const ElementsType& elements); TreeType* nextNode(); - TokenType* nextToken(); private: - //TreeType* nextNodeToken(); + TreeType* nextNodeToken(); }; /// This is an implementation of a subtree stream which is a set of trees -/// modeled as an element stream. +/// modelled as an element stream. /// template<class ImplTraits> -//class RewriteRuleSubtreeStream : public ImplTraits::template RewriteStreamType< typename ImplTraits::TreeParserType> -class RewriteRuleSubtreeStream : public ImplTraits::template RewriteStreamType< typename ImplTraits::TreeType > +class RewriteRuleSubtreeStream : public ImplTraits::template RewriteRuleElementStreamType< typename ImplTraits::TreeParserType> { public: typedef typename ImplTraits::AllocPolicyType AllocPolicyType; @@ -211,46 +206,24 @@ typedef TreeType TokenType; typedef typename ImplTraits::template RecognizerType< StreamType > RecognizerType; typedef typename AllocPolicyType::template VectorType< TokenType* > ElementsType; - typedef typename ImplTraits::template RewriteStreamType< typename ImplTraits::TreeType > BaseType; + typedef typename ImplTraits::template RewriteRuleElementStreamType< typename ImplTraits::TreeParserType> BaseType; - RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, const char* description); - RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, const char* description, TokenType* oneElement); - RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, const char* description, const ElementsType& elements); +public: + RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, RecognizerType* rec, ANTLR_UINT8* description); + RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, RecognizerType* rec, ANTLR_UINT8* description, TokenType* oneElement); + RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, RecognizerType* rec, ANTLR_UINT8* description, const ElementsType& elements); - TreeType* nextNode(TreeType*); - -protected: TreeType* dup( TreeType* el ); private: TreeType* dupTree( TreeType* el ); }; -/* TODO This class is probably used in TreeParser only - * Notes about Java target - * - these classes reimplement only dup and toTree methods: - * base ElementStr - * abstract dup - * toTree(Object e) { return e; } - * TokenStr - * dup { throw } - * toTree(Object e) { return e; } - * SubTreeStr - * dup(Object e) { return adaptor.dupTree } - * NodeStr - * dup { throw } - * toTree(Object e) { return adaptor.dupNode } - * See: RewriteRuleElementStream::dup, RewriteRuleElementStream::dupImpl - * - * There should 3 types of specializations for RewriteRuleElementStreamType (which is not defined yet) - * ATM: RewriteRuleElementStreamType is replaced with ImplTraits::template RewriteStreamType - * /// This is an implementation of a node stream, which is basically an element /// stream that deals with tree nodes only. /// template<class ImplTraits> -//class RewriteRuleNodeStream : public ImplTraits::template RewriteStreamType< typename ImplTraits::TreeParserType> -class RewriteRuleNodeStream : public ImplTraits::template RewriteStreamType< typename ImplTraits::TreeType > +class RewriteRuleNodeStream : public ImplTraits::template RewriteRuleElementStreamType< typename ImplTraits::TreeParserType> { public: typedef typename ImplTraits::AllocPolicyType AllocPolicyType; @@ -261,20 +234,19 @@ typedef TreeType TokenType; typedef typename ImplTraits::template RecognizerType< StreamType > RecognizerType; typedef typename AllocPolicyType::template VectorType< TokenType* > ElementsType; - typedef typename ImplTraits::template RewriteRuleElementStreamType< typename ImplTraits::TreeType > BaseType; + typedef typename ImplTraits::template RewriteRuleElementStreamType< typename ImplTraits::TreeParserType> BaseType; public: - RewriteRuleNodeStream(TreeAdaptorType* adaptor, const char* description); - RewriteRuleNodeStream(TreeAdaptorType* adaptor, const char* description, TokenType* oneElement); - RewriteRuleNodeStream(TreeAdaptorType* adaptor, const char* description, const ElementsType& elements); + RewriteRuleNodeStream(TreeAdaptorType* adaptor, RecognizerType* rec, ANTLR_UINT8* description); + RewriteRuleNodeStream(TreeAdaptorType* adaptor, RecognizerType* rec, ANTLR_UINT8* description, TokenType* oneElement); + RewriteRuleNodeStream(TreeAdaptorType* adaptor, RecognizerType* rec, ANTLR_UINT8* description, const ElementsType& elements); -protected: TreeType* toTree(TreeType* element); private: TreeType* toTreeNode(TreeType* element); }; -*/ + ANTLR_END_NAMESPACE() #include "antlr3rewritestreams.inl" Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.inl 2013-06-25 15:56:00 UTC (rev 4657) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3rewritestreams.inl 2013-06-26 14:51:58 UTC (rev 4658) @@ -1,35 +1,34 @@ ANTLR_BEGIN_NAMESPACE() -template<class ImplTraits, class ElementType> -RewriteRuleElementStream<ImplTraits, ElementType>::RewriteRuleElementStream(TreeAdaptorType* adaptor, - const char* description) +template<class ImplTraits, class SuperType> +RewriteRuleElementStream<ImplTraits, SuperType>::RewriteRuleElementStream(TreeAdaptorType* adaptor, + RecognizerType* rec, ANTLR_UINT8* description) { - this->init(adaptor, description); + this->init(adaptor, rec, description); } -template<class ImplTraits, class ElementType> -RewriteRuleElementStream<ImplTraits, ElementType>::RewriteRuleElementStream(TreeAdaptorType* adaptor, - const char* description, - ElementType* oneElement) +template<class ImplTraits, class SuperType> +RewriteRuleElementStream<ImplTraits, SuperType>::RewriteRuleElementStream(TreeAdaptorType* adaptor, + RecognizerType* rec, ANTLR_UINT8* description, TokenType* oneElement) { - this->init(adaptor, description); + this->init(adaptor, rec, description); if( oneElement != NULL ) this->add( oneElement ); } -template<class ImplTraits, class ElementType> -RewriteRuleElementStream<ImplTraits, ElementType>::RewriteRuleElementStream(TreeAdaptorType* adaptor, - const char* description, - const ElementsType& elements) - : m_elements(elements) +template<class ImplTraits, class SuperType> +RewriteRuleElementStream<ImplTraits, SuperType>::RewriteRuleElementStream(TreeAdaptorType* adaptor, + RecognizerType* rec, ANTLR_UINT8* description, const ElementsType& elements) + :m_elements(elements) { - this->init(adaptor, description); + this->init(adaptor, rec, description); } -template<class ImplTraits, class ElementType> -void RewriteRuleElementStream<ImplTraits, ElementType>::init(TreeAdaptorType* adaptor, - const char* description) +template<class ImplTraits, class SuperType> +void RewriteRuleElementStream<ImplTraits, SuperType>::init(TreeAdaptorType* adaptor, + RecognizerType* rec, ANTLR_UINT8* description) { + m_rec = rec; m_adaptor = adaptor; m_cursor = 0; m_dirty = false; @@ -37,98 +36,90 @@ } template<class ImplTraits> -RewriteRuleTokenStream<ImplTraits>::RewriteRuleTokenStream(TreeAdaptorType* adaptor, - const char* description) - : BaseType(adaptor, description) +RewriteRuleTokenStream<ImplTraits>::RewriteRuleTokenStream(TreeAdaptorType* adaptor, + RecognizerType* rec, ANTLR_UINT8* description) + :BaseType(adaptor, rec, description) { } template<class ImplTraits> -RewriteRuleTokenStream<ImplTraits>::RewriteRuleTokenStream(TreeAdaptorType* adaptor, - const char* description, - TokenType* oneElement) - : BaseType(adaptor, description, oneElement) +RewriteRuleTokenStream<ImplTraits>::RewriteRuleTokenStream(TreeAdaptorType* adaptor, RecognizerType* rec, + ANTLR_UINT8* description, TokenType* oneElement) + :BaseType(adaptor, rec, description, oneElement) { } template<class ImplTraits> -RewriteRuleTokenStream<ImplTraits>::RewriteRuleTokenStream(TreeAdaptorType* adaptor, - const char* description, - const ElementsType& elements) - : BaseType(adaptor, description, elements) +RewriteRuleTokenStream<ImplTraits>::RewriteRuleTokenStream(TreeAdaptorType* adaptor, + RecognizerType* rec, ANTLR_UINT8* description, const ElementsType& elements) + :BaseType(adaptor, rec, description, elements) { } template<class ImplTraits> -RewriteRuleSubtreeStream<ImplTraits>::RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, - const char* description) - : BaseType(adaptor, description) +RewriteRuleSubtreeStream<ImplTraits>::RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, + RecognizerType* rec, ANTLR_UINT8* description) + :BaseType(adaptor, rec, description) { } template<class ImplTraits> -RewriteRuleSubtreeStream<ImplTraits>::RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, - const char* description, - TokenType* oneElement) - : BaseType(adaptor, description, oneElement) +RewriteRuleSubtreeStream<ImplTraits>::RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, RecognizerType* rec, + ANTLR_UINT8* description, TokenType* oneElement) + :BaseType(adaptor, rec, description, oneElement) { } template<class ImplTraits> -RewriteRuleSubtreeStream<ImplTraits>::RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, - const char* description, - const ElementsType& elements) - : BaseType(adaptor, description, elements) +RewriteRuleSubtreeStream<ImplTraits>::RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, + RecognizerType* rec, ANTLR_UINT8* description, const ElementsType& elements) + :BaseType(adaptor, rec, description, elements) { } -/* template<class ImplTraits> -RewriteRuleNodeStream<ImplTraits>::RewriteRuleNodeStream(TreeAdaptorType* adaptor, - const char* description) - : BaseType(adaptor, description) +RewriteRuleNodeStream<ImplTraits>::RewriteRuleNodeStream(TreeAdaptorType* adaptor, + RecognizerType* rec, ANTLR_UINT8* description) + :BaseType(adaptor, rec, description) { } template<class ImplTraits> -RewriteRuleNodeStream<ImplTraits>::RewriteRuleNodeStream(TreeAdaptorType* adaptor, - const char* description, - TokenType* oneElement) - : BaseType(adaptor, description, oneElement) +RewriteRuleNodeStream<ImplTraits>::RewriteRuleNodeStream(TreeAdaptorType* adaptor, RecognizerType* rec, + ANTLR_UINT8* description, TokenType* oneElement) + :BaseType(adaptor, rec, description, oneElement) { } template<class ImplTraits> -RewriteRuleNodeStream<ImplTraits>::RewriteRuleNodeStream(TreeAdaptorType* adaptor, - const char* description, - const ElementsType& elements) - : BaseType(adaptor, description, elements) +RewriteRuleNodeStream<ImplTraits>::RewriteRuleNodeStream(TreeAdaptorType* adaptor, + RecognizerType* rec, ANTLR_UINT8* description, const ElementsType& elements) + :BaseType(adaptor, rec, description, elements) { } -*/ -template<class ImplTraits, class ElementType> -void RewriteRuleElementStream<ImplTraits, ElementType>::reset() +template<class ImplTraits, class SuperType> +void RewriteRuleElementStream<ImplTraits, SuperType>::reset() { + m_dirty = true; m_cursor = 0; - m_dirty = true; } -template<class ImplTraits, class ElementType> -void RewriteRuleElementStream<ImplTraits, ElementType>::add(ElementType* el) +template<class ImplTraits, class SuperType> +void RewriteRuleElementStream<ImplTraits, SuperType>::add(TokenType* el) { - if ( el== NULL ) + if ( el== NULL ) return; - if ( !m_elements.empty() ) - { + if ( !m_elements.empty() ) + { // if in list, just add m_elements.push_back(el); return; } - - if ( m_singleElement == NULL ) - { + + if ( m_singleElement == NULL ) + { // no elements yet, track w/o list m_singleElement = el; return; @@ -140,23 +131,30 @@ m_elements.push_back(el); } -template<class ImplTraits, class ElementType> -ElementType* RewriteRuleElementStream<ImplTraits, ElementType>::_next() +template<class ImplTraits, class SuperType> +typename RewriteRuleElementStream<ImplTraits, SuperType>::TokenType* +RewriteRuleElementStream<ImplTraits, SuperType>::_next() { - ANTLR_UINT32 n = this->size(); + ANTLR_UINT32 n; + TreeType* t; + n = this->size(); + if (n == 0) { // This means that the stream is empty - return NULL; // Caller must cope with this (TODO throw RewriteEmptyStreamException) + // + return NULL; // Caller must cope with this } // Traversed all the available elements already? - if ( m_cursor >= n) // out of elements? + // + if ( m_cursor >= n) { if (n == 1) { // Special case when size is single element, it will just dup a lot + // return this->toTree(m_singleElement); } @@ -164,50 +162,57 @@ // that we just duplicate the entry n times (such as ID ent+ -> ^(ID ent)+) // This means we ran out of elements earlier than was expected. // - return NULL; // Caller must cope with this (TODO throw RewriteEmptyStreamException) + return NULL; // Caller must cope with this } // Elements available either for duping or just available + // if ( m_singleElement != NULL) { m_cursor++; // Cursor advances even for single element as this tells us to dup() return this->toTree(m_singleElement); } - // More than just a single element so we extract it from the + // More than just a single element so we extract it from the // vector. - ElementType* t = this->toTree(m_elements.at(m_cursor)); + // + t = this->toTree( m_elements.at(m_cursor)); m_cursor++; return t; } -template<class ImplTraits, class ElementType> -ElementType* -RewriteRuleElementStream<ImplTraits, ElementType>::nextTree() +template<class ImplTraits, class SuperType> +typename RewriteRuleElementStream<ImplTraits, SuperType>::TreeType* +RewriteRuleElementStream<ImplTraits, SuperType>::nextTree() { - ANTLR_UINT32 n = this->size(); - if ( m_dirty || ( (m_cursor >=n) && (n==1)) ) + ANTLR_UINT32 n; + TreeType* el; + + n = this->size(); + + if ( m_dirty || ( (m_cursor >=n) && (n==1)) ) { // if out of elements and size is 1, dup - ElementType* el = this->_next(); + // + el = this->_next(); return this->dup(el); } // test size above then fetch - ElementType* el = this->_next(); ... [truncated message content] |
From: <ibr...@us...> - 2013-07-05 19:48:49
|
Revision: 4671 http://sourceforge.net/p/tora/code/4671 Author: ibre5041 Date: 2013-07-05 19:48:44 +0000 (Fri, 05 Jul 2013) Log Message: ----------- Modified Paths: -------------- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3.hpp branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3lexer.inl branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/Cpp.stg Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3.hpp =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3.hpp 2013-07-02 20:53:57 UTC (rev 4670) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3.hpp 2013-07-05 19:48:44 UTC (rev 4671) @@ -30,6 +30,7 @@ #include <string> #include <sstream> +#include <memory> #include "antlr3defs.hpp" Modified: branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3lexer.inl =================================================================== --- branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3lexer.inl 2013-07-02 20:53:57 UTC (rev 4670) +++ branches/tora3/extlibs/libantlr3cpp-3.5.1/include/antlr3lexer.inl 2013-07-05 19:48:44 UTC (rev 4671) @@ -54,7 +54,7 @@ err_stream << "("; } err_stream << ex->get_line() << ")"; - + err_stream << ": lexer error " << ex->getName() << '(' << ex->getType() << ')' << " :\n\t" << ex->get_message() << " at position [" << ex->get_line() << ", " << ex->get_charPositionInLine()+1 << "], "; Modified: branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/Cpp.stg =================================================================== --- branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/Cpp.stg 2013-07-02 20:53:57 UTC (rev 4670) +++ branches/tora3/extlibs/parsing.cpp/org/antlr/codegen/templates/Cpp/Cpp.stg 2013-07-05 19:48:44 UTC (rev 4671) @@ -160,26 +160,7 @@ <if(literals)> <beginNamespace(actions)> -<if(LEXER)> -const ANTLR_UINT8* <name>Tokens::getTokenName(ANTLR_INT32 index) const -{ - if( EOF_TOKEN == index) - return (ANTLR_UINT8*) "\<EOF>"; - return TokenNames[index]; -} -/** \brief Table of all token names in symbolic order, mainly used for debugging. - */ -ANTLR_UINT8* <name>Tokens::TokenNames[<length(tokens)>+4] - = { - (ANTLR_UINT8*) "\<invalid>", /* String to print to indicate an invalid token */ - (ANTLR_UINT8*) "\<EOR>", - (ANTLR_UINT8*) "\<DOWN>", - (ANTLR_UINT8*) "\<UP>", - <rest(tokens):{it |(ANTLR_UINT8*) "<it.name>",//<it.type>}; separator="\n"> - }; -<endif> - /** String literals used by <name> that we must do things like MATCHS() with. * C will normally just lay down 8 bit characters, and you can use L"xxx" to * get wchar_t, but wchar_t is 16 bits on Windows, which is not UTF32 and so @@ -377,12 +358,7 @@ EOF_TOKEN = <name>ImplTraits::CommonTokenType::TOKEN_EOF <tokens:{it | , <it.name> = <it.type> }; separator="\n"> }; -<if(LEXER)> - const ANTLR_UINT8* getTokenName(ANTLR_INT32 index) const; -protected: - static ANTLR_UINT8* TokenNames[]; -<endif> }; /** Context tracking structure for <mainName()> @@ -435,7 +411,6 @@ <if(recognizer.filterMode)> void memoize(ANTLR_MARKER ruleIndex, ANTLR_MARKER ruleParseStart); bool alreadyParsedRule(ANTLR_MARKER ruleIndex); - <filteringNextToken()> <endif> <rules:{r | <if(!r.ruleDescriptor.isSynPred)><headerReturnType(ruleDescriptor=r.ruleDescriptor)> m<r.ruleDescriptor.name>( <r.ruleDescriptor.parameterScope:parameterScope()>);<endif>}; separator="\n"> <rules:{r | <if(r.ruleDescriptor.isSynPred)> <headerReturnType(ruleDescriptor=r.ruleDescriptor)> msynpred( antlr3::ClassForwarder\< <r.ruleDescriptor.name> > <r.ruleDescriptor.parameterScope:parameterScope()>); @@ -564,7 +539,7 @@ numRules, filterMode, superClass, - labelType="ImplTraits::CommonTokenType*") ::= << + labelType="std::auto_ptr< ImplTraits::CommonTokenType >") ::= << using namespace antlr3; @@ -749,81 +724,6 @@ >> - -filteringNextToken() ::= << -<name>ImplTraits::CommonTokenType* -<name>ImplTraits::TokenSourceType::nextToken() -{ - LexerType* lexer; - typename LexerType::RecognizerSharedStateType* state; - - lexer = this->get_super(); - state = lexer->get_lexstate(); - - /* Get rid of any previous token (token factory takes care of - * any deallocation when this token is finally used up. - */ - state->set_token_present( false ); - state->set_error( false ); /* Start out without an exception */ - state->set_failedflag(false); - - /* Record the start of the token in our input stream. - */ - state->set_tokenStartCharIndex( lexer->index(); - state->set_tokenStartCharPositionInLine( lexer->getCharPositionInLine() ); - state->set_tokenStartLine( lexer->getLine() ); - state->set_text(""); - - /* Now call the matching rules and see if we can generate a new token - */ - for (;;) - { - if (lexer->LA(1) == ANTLR_CHARSTREAM_EOF) - { - /* Reached the end of the stream, nothing more to do. - */ - CommonTokenType& teof = m_eofToken; - - teof.set_startIndex(lexer->getCharIndex()); - teof.set_stopIndex(lexer->getCharIndex()); - teof.setLine(lexer->getLine()); - return &teof; - } - - state->set_token_present(false); - state->set_error(false); /* Start out without an exception */ - - { - ANTLR_MARKER m; - - m = this->get_istream()->mark(); - state->set_backtracking(1); /* No exceptions */ - state->set_failedflag(false); - - /* Call the generated lexer, see if it can get a new token together. - */ - lexer->mTokens(); - state->set_backtracking(0); - - <! mTokens backtracks with synpred at BACKTRACKING==2 - and we set the synpredgate to allow actions at level 1. !> - - if(state->get_failed()) - { - lexer->rewind(m); - lexer->consume(); <! advance one char and try again !> - } - else - { - lexer->emit(); /* Assemble the token and emit it to the stream */ - TokenType& tok = state->get_token(); - return &tok; - } - } - } -} ->> - actionGate() ::= "this->get_backtracking()==0" filteringActionGate() ::= "this->get_backtracking()==1" @@ -1304,7 +1204,7 @@ <[ruleDescriptor.tokenLabels, ruleDescriptor.tokenListLabels, ruleDescriptor.ruleLabels] - :{it |<labelType> <it.label.text> = NULL;}; separator="\n" + :{it |<labelType> <it.label.text>;}; separator="\n" > <ruleDescriptor.charLabels:{it |ANTLR_UINT32 <it.label.text>;}; separator="\n"> <[ruleDescriptor.tokenListLabels, @@ -1323,11 +1223,6 @@ >> lexerRuleLabelFree() ::= << -<[ruleDescriptor.tokenLabels, - ruleDescriptor.tokenListLabels, - ruleDescriptor.ruleLabels] - :{it |<it.label.text> = NULL;}; separator="\n" -> <[ruleDescriptor.tokenListLabels, ruleDescriptor.ruleListLabels, ruleDescriptor.ruleListLabels] @@ -1398,7 +1293,7 @@ <ruleDescriptor.actions.declarations> <lexerRuleLabelDefs()> <if(trace)> - std::cerr \<\< "enter <ruleName> '" \<\< (char)this->LA(1) + std::cout \<\< "enter <ruleName> '" \<\< (char)this->LA(1) \<\< "' line=" \<\< this->getLine() \<\< ":" \<\< this->getCharPositionInLine() \<\< " failed=" \<\< this->get_failedflag() \<\< " backtracking=" \<\< this->get_backtracking() \<\< std::endl; <endif> @@ -1420,7 +1315,7 @@ this->get_lexstate()->set_type(_type); <endif> <if(trace)> - std::cerr \<\< "exit <ruleName> '" \<\< (char)this->LA(1) + std::cout \<\< "exit <ruleName> '" \<\< (char)this->LA(1) \<\< "' line=" \<\< this->getLine() \<\< ":" \<\< this->getCharPositionInLine() \<\< " failed=" \<\< this->get_failedflag() \<\< " backtracking=" \<\< this->get_backtracking() \<\< std::endl; <endif> @@ -1713,7 +1608,7 @@ ANTLR_UINT32 <label>StartCharPos<elementIndex> = this->getCharPositionInLine(); this->matchs(<string>); <checkRuleBacktrackFailure()> -<label> = new CommonTokenType; +<label> = <labelType>(new CommonTokenType); <label>->set_type( CommonTokenType::TOKEN_INVALID ); <label>->set_startIndex( <label>Start); <label>->set_stopIndex( this->getCharIndex()-1); @@ -1786,7 +1681,7 @@ ANTLR_UINT32 <label>StartCharPos<elementIndex> = this->getCharPositionInLine(); <if(scope)>m_<scope:delegateName()>-><endif>m<rule.name>(<if(scope)>m_<scope:delegateName()><endif> <if(args)>, <endif><args; separator=", ">); <checkRuleBacktrackFailure()> - <label> = new CommonTokenType(); + <label> = <labelType>(new CommonTokenType()); <label>->set_type( CommonTokenType::TOKEN_INVALID); <label>->set_startIndex( <label>Start<elementIndex> ); <label>->set_stopIndex( this->getCharIndex()-1 ); @@ -1812,18 +1707,18 @@ { ANTLR_UINT32 <label>Start<elementIndex>; ANTLR_UINT32 <label>StartLine<elementIndex> = this->getLine(); - ANTLR_UINT32 <label>StartCharPos<elementIndex> = this->getCharPositionInLine(); + ANTLR_UINT32 <label>StartCharPos<elementIndex> = this->getCharPositionInLine(); <labelType> <label>; <label>Start<elementIndex> = this->getCharIndex(); this->matchc(ANTLR_CHARSTREAM_EOF); <checkRuleBacktrackFailure()> - <label> = new CommonTokenType(); + <label> = <labelType>(new CommonTokenType()); <label>->set_type( CommonTokenType::TOKEN_EOF ); <label>->set_startIndex(<label>Start<elementIndex>); <label>->set_stopIndex(this->getCharIndex()-1); <label>->set_input( this->get_input() ); <label>->set_line( <label>StartLine<elementIndex> ); - <label>->set_charPositionInLine( <label>StartCharPos<elementIndex> ); + <label>->set_charPositionInLine( <label>StartCharPos<elementIndex> ); } <else> this->matchc(ANTLR_CHARSTREAM_EOF); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |