xref: /aosp_15_r20/external/antlr/runtime/Cpp/include/antlr3traits.hpp (revision 16467b971bd3e2009fad32dd79016f2c7e421deb)

#ifndef _ANTLR3_TRAITS_HPP
#define _ANTLR3_TRAITS_HPP

#include	"antlr3defs.hpp"


ANTLR_BEGIN_NAMESPACE()

//Users implementing overrides should inherit from this
template<class ImplTraits>
class CustomTraitsBase
{
public:
	typedef Empty AllocPolicyType;
	typedef Empty StringType;
	typedef Empty StringStreamType;
	typedef Empty StreamDataType;
	typedef Empty Endianness;

	//collections
	typedef Empty BitsetType;
	typedef Empty BitsetListType;

	typedef Empty InputStreamType;

	template<class StreamType>
	class IntStreamType : public Empty
	{
	public:
		typedef Empty BaseType;
	};

	typedef Empty LexStateType;

	typedef Empty CommonTokenType;
	typedef Empty TokenIntStreamType;

	typedef Empty TokenStreamType;
	typedef Empty TreeNodeStreamType;


	typedef Empty DebugEventListenerType;
	template<class StreamType>
	class RecognizerSharedStateType : public Empty
	{
	public:
		typedef Empty BaseType;
	};

	template<class StreamType>
	class RecognizerType : public Empty
	{
	public:
		typedef Empty BaseType;
	};

	typedef Empty TreeType;
	typedef Empty TreeAdaptorType;

	template<class StreamType>
	class ExceptionBaseType : public Empty
	{
	public:
		typedef Empty BaseType;
	};

	//this should be overridden with generated lexer
	typedef Empty BaseLexerType;

	typedef Empty TokenSourceType;
	typedef Empty BaseParserType;//this should be overridden with generated lexer
	typedef Empty BaseTreeParserType;

	template<class StreamType>
	class RewriteStreamType : public Empty
	{
	public:
		typedef Empty BaseType;
	};

	typedef Empty  RuleReturnValueType;

	//If we want to change the way tokens are stored
	static const bool TOKENS_ACCESSED_FROM_OWNING_RULE = false;
	static const int  TOKEN_FILL_BUFFER_INCREMENT = 100; //used only if the above val is true

	static void displayRecognitionError( const std::string& str ) {  printf("%s", str.c_str() ); }
};

template<class A, class B>
class TraitsSelector
{
public:
	typedef A selected;
};

template<class B>
class TraitsSelector<Empty, B>
{
public:
	typedef B selected;
};

template<class A, class B, class C>
class TraitsOneArgSelector
{
public:
	typedef A selected;
};

template<class A, class B>
class TraitsOneArgSelector<A,B,Empty>
{
public:
	typedef B selected;
};

template<bool v, class A, class B>
class BoolSelector
{
public:
	typedef A selected;
};

template<class A, class B>
class BoolSelector<false, A, B>
{
public:
	typedef B selected;
};

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>::StringType,
									std::string >::selected StringType;

	typedef typename TraitsSelector< typename UserTraits<TraitsType>::StringStreamType,
		                             std::stringstream >::selected StringStreamType;

	typedef typename TraitsSelector< typename UserTraits<TraitsType>::StreamDataType,
		                             ANTLR_UINT8 >::selected StreamDataType;

	typedef typename TraitsSelector< typename UserTraits<TraitsType>::Endianness,
									 RESOLVE_ENDIAN_AT_RUNTIME >::selected Endianness;

	typedef typename TraitsSelector< typename UserTraits<TraitsType>::BitsetType,
		                             Bitset<TraitsType> >::selected BitsetType;
	typedef typename TraitsSelector< typename UserTraits<TraitsType>::BitsetListType,
		                             BitsetList<TraitsType> >::selected BitsetListType;

	typedef typename TraitsSelector< typename UserTraits<TraitsType>::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
	{ };

	typedef typename TraitsSelector< typename UserTraits<TraitsType>::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);  }
};

template<
	     class LxrType,
         class PsrType,
		 template<class ImplTraits> class UserTraits = CustomTraitsBase,
		 class TreePsrType = antlr3::Empty
         >
class Traits  : public TraitsBase<UserTraits>
{
public:
	typedef Traits TraitsType;
	typedef TraitsBase<UserTraits> BaseTraitsType;

	typedef typename TraitsSelector< typename UserTraits<TraitsType>::CommonTokenType,
									 CommonToken<TraitsType> >::selected CommonTokenType;
	typedef typename TraitsSelector< typename UserTraits<TraitsType>::TokenIntStreamType,
		                             TokenIntStream<TraitsType> >::selected TokenIntStreamType;

	typedef typename TraitsSelector< typename UserTraits<TraitsType>::TokenStreamType,
									CommonTokenStream<TraitsType> >::selected TokenStreamType;
	typedef typename TraitsSelector< typename UserTraits<TraitsType>::TreeNodeStreamType,
		                            CommonTreeNodeStream<TraitsType> >::selected TreeNodeStreamType;

	typedef typename TraitsSelector< typename UserTraits<TraitsType>::DebugEventListenerType,
		                            DebugEventListener<TraitsType> >::selected DebugEventListenerType;

	template<class StreamType>
	class  RecognizerSharedStateType
		          : public TraitsOneArgSelector<
							typename UserTraits<TraitsType>::template RecognizerSharedStateType<StreamType>,
							RecognizerSharedState<TraitsType, StreamType>,
							typename UserTraits<TraitsType>::template RecognizerSharedStateType<StreamType>::BaseType
										>::selected
	{};

	template<class StreamType>
	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 BaseType::RecognizerSharedStateType RecognizerSharedStateType;

	public:
		RecognizerType(ANTLR_UINT32 sizeHint, RecognizerSharedStateType* state)
			: BaseType( sizeHint, state )
		{
		}
	};

	typedef typename TraitsSelector< typename UserTraits<TraitsType>::TreeType,
										CommonTree<TraitsType> >::selected TreeType;
	typedef typename TraitsSelector< typename UserTraits<TraitsType>::TreeAdaptorType,
										CommonTreeAdaptor<TraitsType> >::selected TreeAdaptorType;

	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
	{
	public:
		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 )
			:BaseType(message)
		{
		}
	};

	//this should be overridden with generated lexer
	typedef typename TraitsSelector< typename UserTraits<TraitsType>::BaseLexerType,
											Lexer<TraitsType> >::selected BaseLexerType;
	typedef LxrType LexerType;

	typedef typename TraitsSelector< typename UserTraits<TraitsType>::TokenSourceType,
											TokenSource<TraitsType> >::selected TokenSourceType;
	typedef typename TraitsSelector< typename UserTraits<TraitsType>::BaseParserType,
											Parser<TraitsType> >::selected BaseParserType;

	typedef PsrType ParserType;

	typedef typename TraitsSelector< typename UserTraits<TraitsType>::BaseTreeParserType,
											 TreeParser<TraitsType> >::selected BaseTreeParserType;
	typedef TreePsrType TreeParserType;

	template<class SuperType>
	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 SuperType::StreamType StreamType;
		typedef typename BaseType::RecognizerType Recognizer_Type;
		typedef typename BaseType::TokenType TokenType;
		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, Recognizer_Type* rec, ANTLR_UINT8* description, TokenType* oneElement)
			:BaseType(adaptor, rec, description, oneElement)
		{
		}
		RewriteStreamType(TreeAdaptorType* adaptor, Recognizer_Type* rec, ANTLR_UINT8* description, const ElementsType& elements)
			:BaseType(adaptor, rec, description, elements)
		{
		}
	};

	typedef typename TraitsSelector< typename UserTraits<TraitsType>::RuleReturnValueType,
										typename BoolSelector< TraitsType::TOKENS_ACCESSED_FROM_OWNING_RULE,
														RuleReturnValue_1<TraitsType>, RuleReturnValue<TraitsType> >::selected
								   >::selected RuleReturnValueType;
};


ANTLR_END_NAMESPACE()

#endif //_ANTLR3_TRAITS_HPP