Restoring authorship annotation for <isiv@yandex-team.ru>. Commit 1 of 2.

1 files changed, 241 insertions, 241 deletions

diff --git a/contrib/libs/antlr3_cpp_runtime/include/antlr3rewritestreams.inl b/contrib/libs/antlr3_cpp_runtime/include/antlr3rewritestreams.inl
index 47568da649..e3557d11a2 100644
--- a/contrib/libs/antlr3_cpp_runtime/include/antlr3rewritestreams.inl
+++ b/contrib/libs/antlr3_cpp_runtime/include/antlr3rewritestreams.inl
@@ -1,363 +1,363 @@
-namespace antlr3 {
+namespace antlr3 { 
 
-template<class ImplTraits, class ElementType>
-RewriteRuleElementStream<ImplTraits, ElementType>::RewriteRuleElementStream(TreeAdaptorType* adaptor,
-	const char* description)
+template<class ImplTraits, class ElementType> 
+RewriteRuleElementStream<ImplTraits, ElementType>::RewriteRuleElementStream(TreeAdaptorType* adaptor, 
+	const char* description) 
 {
-	this->init(adaptor, description);
+	this->init(adaptor, description); 
 }
 
-template<class ImplTraits, class ElementType>
-RewriteRuleElementStream<ImplTraits, ElementType>::RewriteRuleElementStream(TreeAdaptorType* adaptor,
-	const char* description,
-	const ElementType* oneElement)
+template<class ImplTraits, class ElementType> 
+RewriteRuleElementStream<ImplTraits, ElementType>::RewriteRuleElementStream(TreeAdaptorType* adaptor, 
+	const char* description, 
+	const ElementType* oneElement) 
 {
-	this->init(adaptor, description);
-	if( oneElement != NULL )
-		this->add( oneElement );
+	this->init(adaptor, 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 ElementType> 
+RewriteRuleElementStream<ImplTraits, ElementType>::RewriteRuleElementStream(TreeAdaptorType* adaptor, 
+	const char* description, 
+	const ElementsType& elements) 
+	: m_elements(elements) 
 {
-	this->init(adaptor, description);
+	this->init(adaptor, description); 
 }
 
-template<class ImplTraits, class ElementType>
-void RewriteRuleElementStream<ImplTraits, ElementType>::init(TreeAdaptorType* adaptor,
-	const char* description)
+template<class ImplTraits, class ElementType> 
+void RewriteRuleElementStream<ImplTraits, ElementType>::init(TreeAdaptorType* adaptor, 
+	const char* description) 
 {
-	m_adaptor = adaptor;
-	m_cursor  = 0;
-	m_dirty	  = false;
+	m_adaptor = adaptor; 
+	m_cursor  = 0; 
+	m_dirty	  = false; 
 }
 
 template<class ImplTraits>
 RewriteRuleTokenStream<ImplTraits>::RewriteRuleTokenStream(TreeAdaptorType* adaptor,
-	const char* description)
-	//: BaseType(adaptor, description)
+	const char* description) 
+	//: BaseType(adaptor, description) 
 {
 }
 
 template<class ImplTraits>
-RewriteRuleTokenStream<ImplTraits>::RewriteRuleTokenStream(TreeAdaptorType* adaptor,
-	const char* description,
-	const TokenType* oneElement)
-	//: BaseType(adaptor, description, oneElement)
+RewriteRuleTokenStream<ImplTraits>::RewriteRuleTokenStream(TreeAdaptorType* adaptor, 
+	const char* description, 
+	const TokenType* oneElement) 
+	//: BaseType(adaptor, description, oneElement) 
 {
 }
 
 template<class ImplTraits>
 RewriteRuleTokenStream<ImplTraits>::RewriteRuleTokenStream(TreeAdaptorType* adaptor,
-	const char* description,
-	const ElementsType& elements)
-	//: BaseType(adaptor, description, elements)
+	const char* description, 
+	const ElementsType& elements) 
+	//: BaseType(adaptor, description, elements) 
 {
 }
 
 template<class ImplTraits>
 RewriteRuleSubtreeStream<ImplTraits>::RewriteRuleSubtreeStream(TreeAdaptorType* adaptor,
-	const char* description)
-	//: BaseType(adaptor, description)
+	const char* description) 
+	//: BaseType(adaptor, description) 
 {
 }
 
 template<class ImplTraits>
-RewriteRuleSubtreeStream<ImplTraits>::RewriteRuleSubtreeStream(TreeAdaptorType* adaptor,
-	const char* description,
-	TreeTypePtr& oneElement)
-	//: BaseType(adaptor, description, oneElement)
+RewriteRuleSubtreeStream<ImplTraits>::RewriteRuleSubtreeStream(TreeAdaptorType* adaptor, 
+	const char* description, 
+	TreeTypePtr& oneElement) 
+	//: BaseType(adaptor, description, oneElement) 
 {
 }
 
 template<class ImplTraits>
 RewriteRuleSubtreeStream<ImplTraits>::RewriteRuleSubtreeStream(TreeAdaptorType* adaptor,
-	const char* description,
-	const ElementsType& elements)
-	//: BaseType(adaptor, description, elements)
+	const char* description, 
+	const ElementsType& elements) 
+	//: BaseType(adaptor, description, elements) 
 {
 }
 
-/*
+/* 
 template<class ImplTraits>
 RewriteRuleNodeStream<ImplTraits>::RewriteRuleNodeStream(TreeAdaptorType* adaptor,
-	const char* description)
-	: BaseType(adaptor, description)
+	const char* description) 
+	: BaseType(adaptor, description) 
 {
 }
 
 template<class ImplTraits>
-RewriteRuleNodeStream<ImplTraits>::RewriteRuleNodeStream(TreeAdaptorType* adaptor,
-	const char* description,
-	TokenType* oneElement)
-	: BaseType(adaptor, description, oneElement)
+RewriteRuleNodeStream<ImplTraits>::RewriteRuleNodeStream(TreeAdaptorType* adaptor, 
+	const char* description, 
+	TokenType* oneElement) 
+	: BaseType(adaptor, description, oneElement) 
 {
 }
 
 template<class ImplTraits>
 RewriteRuleNodeStream<ImplTraits>::RewriteRuleNodeStream(TreeAdaptorType* adaptor,
-	const char* description,
-	const ElementsType& elements)
-	: BaseType(adaptor, description, elements)
+	const char* description, 
+	const ElementsType& elements) 
+	: BaseType(adaptor, description, elements) 
 {
 }
-*/
+*/ 
 
-template<class ImplTraits, class ElementType>
-void RewriteRuleElementStream<ImplTraits, ElementType>::reset()
+template<class ImplTraits, class ElementType> 
+void RewriteRuleElementStream<ImplTraits, ElementType>::reset() 
 {
-	m_cursor = 0;
-	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 ElementType> 
+void RewriteRuleElementStream<ImplTraits, ElementType>::add(ElementType* el) 
 {
-	if ( el== NULL )
-		return;
+	if ( el== NULL ) 
+		return; 
 
-	m_elements.push_back(el);
+	m_elements.push_back(el); 
 }
 
-template<class ImplTraits, class ElementType>
-ElementType* RewriteRuleElementStream<ImplTraits, ElementType>::_next()
+template<class ImplTraits, class ElementType> 
+ElementType* RewriteRuleElementStream<ImplTraits, ElementType>::_next() 
 {
-	ANTLR_UINT32 n = this->size();
-
-	if (n == 0)
-	{
-		// This means that the stream is empty
-		return NULL;	// Caller must cope with this (TODO throw RewriteEmptyStreamException)
-	}
-
-	// Traversed all the available elements already?
-	if ( m_cursor >= n) // out of elements?
-	{
-		if (n == 1)
-		{
-			// Special case when size is single element, it will just dup a lot
-			//return this->toTree(m_singleElement);
-			return this->toTree(m_elements.at(0));
-		}
-
-		// Out of elements and the size is not 1, so we cannot assume
-		// 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)
-	}
-
-	// More than just a single element so we extract it from the
-	// vector.
-	ElementType* t = this->toTree(m_elements.at(m_cursor));
-	m_cursor++;
-	return t;
+	ANTLR_UINT32 n = this->size(); 
+
+	if (n == 0) 
+	{ 
+		// This means that the stream is empty 
+		return NULL;	// Caller must cope with this (TODO throw RewriteEmptyStreamException) 
+	} 
+
+	// Traversed all the available elements already? 
+	if ( m_cursor >= n) // out of elements? 
+	{ 
+		if (n == 1) 
+		{ 
+			// Special case when size is single element, it will just dup a lot 
+			//return this->toTree(m_singleElement); 
+			return this->toTree(m_elements.at(0)); 
+		} 
+
+		// Out of elements and the size is not 1, so we cannot assume 
+		// 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) 
+	} 
+
+	// More than just a single element so we extract it from the 
+	// vector. 
+	ElementType* 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 ElementType> 
+ElementType 
+RewriteRuleElementStream<ImplTraits, ElementType>::nextTree() 
 {
-	ANTLR_UINT32 n = this->size();
-	if ( m_dirty || ( (m_cursor >=n) && (n==1)) )
-	{
-		// if out of elements and size is 1, dup
-		ElementType* el = this->_next();
-		return this->dup(el);
-	}
-
-	// test size above then fetch
-	ElementType*  el = this->_next();
-	return el;
+	ANTLR_UINT32 n = this->size(); 
+	if ( m_dirty || ( (m_cursor >=n) && (n==1)) ) 
+	{ 
+		// if out of elements and size is 1, dup 
+		ElementType* el = this->_next(); 
+		return this->dup(el); 
+	} 
+
+	// test size above then fetch 
+	ElementType*  el = this->_next(); 
+	return el; 
 }
 
-/*
+/* 
 template<class ImplTraits, class SuperType>
 typename RewriteRuleElementStream<ImplTraits, SuperType>::TokenType*
 RewriteRuleElementStream<ImplTraits, SuperType>::nextToken()
 {
-	return this->_next();
+	return this->_next(); 
 }
 
 template<class ImplTraits, class SuperType>
 typename RewriteRuleElementStream<ImplTraits, SuperType>::TokenType*
 RewriteRuleElementStream<ImplTraits, SuperType>::next()
 {
-	ANTLR_UINT32   s;
-	s = this->size();
-	if ( (m_cursor >= s) && (s == 1) )
-	{
-		TreeTypePtr el;
-		el = this->_next();
-		return	this->dup(el);
-	}
-	return this->_next();
-}
-
-*/
-
-template<class ImplTraits, class ElementType>
-ElementType*
-RewriteRuleElementStream<ImplTraits, ElementType>::dup( ElementType* element)
-{
-	return dupImpl(element);
-}
-
-template<class ImplTraits, class ElementType>
-ElementType*
-RewriteRuleElementStream<ImplTraits, ElementType>::dupImpl( typename ImplTraits::CommonTokenType* element)
-{
-	return NULL; // TODO throw here
-}
-
-template<class ImplTraits, class ElementType>
-ElementType*
-RewriteRuleElementStream<ImplTraits, ElementType>::dupImpl( typename ImplTraits::TreeTypePtr element)
-{
-	return m_adaptor->dupTree(element);
-}
-
+	ANTLR_UINT32   s; 
+	s = this->size(); 
+	if ( (m_cursor >= s) && (s == 1) ) 
+	{ 
+		TreeTypePtr el; 
+		el = this->_next(); 
+		return	this->dup(el); 
+	} 
+	return this->_next(); 
+}
+
+*/ 
+ 
+template<class ImplTraits, class ElementType> 
+ElementType* 
+RewriteRuleElementStream<ImplTraits, ElementType>::dup( ElementType* element) 
+{ 
+	return dupImpl(element); 
+} 
+ 
+template<class ImplTraits, class ElementType> 
+ElementType* 
+RewriteRuleElementStream<ImplTraits, ElementType>::dupImpl( typename ImplTraits::CommonTokenType* element) 
+{ 
+	return NULL; // TODO throw here 
+} 
+ 
+template<class ImplTraits, class ElementType> 
+ElementType* 
+RewriteRuleElementStream<ImplTraits, ElementType>::dupImpl( typename ImplTraits::TreeTypePtr element) 
+{ 
+	return m_adaptor->dupTree(element); 
+} 
+ 
 template<class ImplTraits>
-typename RewriteRuleSubtreeStream<ImplTraits>::TreeTypePtr	
-RewriteRuleSubtreeStream<ImplTraits>::dup(TreeTypePtr element)
+typename RewriteRuleSubtreeStream<ImplTraits>::TreeTypePtr	 
+RewriteRuleSubtreeStream<ImplTraits>::dup(TreeTypePtr element) 
 {
-	return this->dupTree(element);
+	return this->dupTree(element); 
 }
 
 template<class ImplTraits>
-typename RewriteRuleSubtreeStream<ImplTraits>::TreeTypePtr
-RewriteRuleSubtreeStream<ImplTraits>::dupTree(TreeTypePtr element)
+typename RewriteRuleSubtreeStream<ImplTraits>::TreeTypePtr 
+RewriteRuleSubtreeStream<ImplTraits>::dupTree(TreeTypePtr element) 
 {
-	return BaseType::m_adaptor->dupNode(element);
+	return BaseType::m_adaptor->dupNode(element); 
 }
 
-template<class ImplTraits, class ElementType>
-ElementType*
-RewriteRuleElementStream<ImplTraits, ElementType>::toTree( ElementType* element)
+template<class ImplTraits, class ElementType> 
+ElementType* 
+RewriteRuleElementStream<ImplTraits, ElementType>::toTree( ElementType* element) 
 {
-	return element;
+	return element; 
 }
 
-/*
+/* 
 template<class ImplTraits>
-typename RewriteRuleNodeStream<ImplTraits>::TreeTypePtr
-RewriteRuleNodeStream<ImplTraits>::toTree(TreeTypePtr element)
+typename RewriteRuleNodeStream<ImplTraits>::TreeTypePtr 
+RewriteRuleNodeStream<ImplTraits>::toTree(TreeTypePtr element) 
 {
-	return this->toTreeNode(element);
+	return this->toTreeNode(element); 
 }
 
 template<class ImplTraits>
-typename RewriteRuleNodeStream<ImplTraits>::TreeTypePtr
-RewriteRuleNodeStream<ImplTraits>::toTreeNode(TreeTypePtr element)
+typename RewriteRuleNodeStream<ImplTraits>::TreeTypePtr 
+RewriteRuleNodeStream<ImplTraits>::toTreeNode(TreeTypePtr element) 
 {
-	return BaseType::m_adaptor->dupNode(element);
+	return BaseType::m_adaptor->dupNode(element); 
 }
-*/
+*/ 
 
-template<class ImplTraits, class ElementType>
-bool RewriteRuleElementStream<ImplTraits, ElementType>::hasNext()
+template<class ImplTraits, class ElementType> 
+bool RewriteRuleElementStream<ImplTraits, ElementType>::hasNext() 
 {
-	if ( !m_elements.empty() && m_cursor < m_elements.size())
-	{
-		return true;
-	}
-	else
-	{
-		return false;
-	}
+	if ( !m_elements.empty() && m_cursor < m_elements.size()) 
+	{ 
+		return true; 
+	} 
+	else 
+	{ 
+		return false; 
+	} 
 }
 
 template<class ImplTraits >
-typename RewriteRuleTokenStream<ImplTraits>::TreeTypePtr
+typename RewriteRuleTokenStream<ImplTraits>::TreeTypePtr 
 RewriteRuleTokenStream<ImplTraits>::nextNode()
 {
-	TokenType *Token = this->nextToken();
-	//return BaseType::m_adaptor->create(Token);
-	return m_adaptor->create(Token);
+	TokenType *Token = this->nextToken(); 
+	//return BaseType::m_adaptor->create(Token); 
+	return m_adaptor->create(Token); 
 }
 
-/*
+/* 
 template<class ImplTraits>
-typename RewriteRuleTokenStream<ImplTraits>::TreeTypePtr
+typename RewriteRuleTokenStream<ImplTraits>::TreeTypePtr 
 RewriteRuleTokenStream<ImplTraits>::nextNodeToken()
 {
-	return BaseType::m_adaptor->create(this->_next());
+	return BaseType::m_adaptor->create(this->_next()); 
 }
-*/
+*/ 
 
 /// Number of elements available in the stream
 ///
-template<class ImplTraits, class ElementType>
-ANTLR_UINT32 RewriteRuleElementStream<ImplTraits, ElementType>::size()
+template<class ImplTraits, class ElementType> 
+ANTLR_UINT32 RewriteRuleElementStream<ImplTraits, ElementType>::size() 
 {
-	return (ANTLR_UINT32)(m_elements.size());
+	return (ANTLR_UINT32)(m_elements.size()); 
 }
 
-template<class ImplTraits, class ElementType>
-typename RewriteRuleElementStream<ImplTraits, ElementType>::StringType
-RewriteRuleElementStream<ImplTraits, ElementType>::getDescription()
+template<class ImplTraits, class ElementType> 
+typename RewriteRuleElementStream<ImplTraits, ElementType>::StringType 
+RewriteRuleElementStream<ImplTraits, ElementType>::getDescription() 
 {
-	if ( m_elementDescription.empty() )
-	{
-		m_elementDescription = "<unknown source>";
-	}
-	return  m_elementDescription;
+	if ( m_elementDescription.empty() ) 
+	{ 
+		m_elementDescription = "<unknown source>"; 
+	} 
+	return  m_elementDescription; 
 }
 
-template<class ImplTraits, class ElementType>
-RewriteRuleElementStream<ImplTraits, ElementType>::~RewriteRuleElementStream()
+template<class ImplTraits, class ElementType> 
+RewriteRuleElementStream<ImplTraits, ElementType>::~RewriteRuleElementStream() 
 {
     // 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
-	// entries are called. However, if this particular function is called
-    // then we know that the entries in the stream are definitely
+	// need to clear any vector it has. This is so any 
+	// free pointers that are associated with the 
+	// entries are called. However, if this particular function is called 
+    // then we know that the entries in the stream are definitely 
     // tree nodes. Hence we check to see if any of them were nilNodes as
     // if they were, we can reuse them.
-	//
-	// We have some elements to traverse
-	//
-	for (ANTLR_UINT32 i = 0; i < m_elements.size(); i++)
-	{
-		ElementType *tree = m_elements.at(i);
-		//if  ( (tree != NULL) && tree->isNilNode() )
-		{
-			// Had to remove this for now, check is not comprehensive enough
-			// tree->reuse(tree);
-		}
-	}
-	m_elements.clear();
-}
-
-template<class ImplTraits>
-typename RewriteRuleTokenStream<ImplTraits>::TokenType*
-RewriteRuleTokenStream<ImplTraits>::nextToken()
-{
-	return this->_next();
-}
-
-template<class ImplTraits>
-typename RewriteRuleSubtreeStream<ImplTraits>::TreeTypePtr
-RewriteRuleSubtreeStream<ImplTraits>::nextNode(TreeTypePtr element)
-{
-	//System.out.println("nextNode: elements="+elements+", singleElement="+((Tree)singleElement).toStringTree());
-	ANTLR_UINT32 n = this->size();
-	if ( BaseType::m_dirty || (BaseType::m_cursor>=n && n==1) ) {
-		// if out of elements and size is 1, dup (at most a single node
-		// since this is for making root nodes).
-		TreeTypePtr el = this->_next();
-		return BaseType::m_adaptor->dupNode(el);
-	}
-	// test size above then fetch
-	TreeType *tree = this->_next();
-	while (BaseType::m_adaptor.isNil(tree) && BaseType::m_adaptor.getChildCount(tree) == 1)
-		tree = BaseType::m_adaptor->getChild(tree, 0);
-	//System.out.println("_next="+((Tree)tree).toStringTree());
-	TreeType *el = BaseType::m_adaptor->dupNode(tree); // dup just the root (want node here)
-	return el;
-}
-
-}
+	// 
+	// We have some elements to traverse 
+	// 
+	for (ANTLR_UINT32 i = 0; i < m_elements.size(); i++) 
+	{ 
+		ElementType *tree = m_elements.at(i); 
+		//if  ( (tree != NULL) && tree->isNilNode() ) 
+		{ 
+			// Had to remove this for now, check is not comprehensive enough 
+			// tree->reuse(tree); 
+		} 
+	} 
+	m_elements.clear(); 
+} 
+
+template<class ImplTraits> 
+typename RewriteRuleTokenStream<ImplTraits>::TokenType* 
+RewriteRuleTokenStream<ImplTraits>::nextToken() 
+{ 
+	return this->_next(); 
+}
+
+template<class ImplTraits> 
+typename RewriteRuleSubtreeStream<ImplTraits>::TreeTypePtr 
+RewriteRuleSubtreeStream<ImplTraits>::nextNode(TreeTypePtr element) 
+{ 
+	//System.out.println("nextNode: elements="+elements+", singleElement="+((Tree)singleElement).toStringTree()); 
+	ANTLR_UINT32 n = this->size(); 
+	if ( BaseType::m_dirty || (BaseType::m_cursor>=n && n==1) ) { 
+		// if out of elements and size is 1, dup (at most a single node 
+		// since this is for making root nodes). 
+		TreeTypePtr el = this->_next(); 
+		return BaseType::m_adaptor->dupNode(el); 
+	} 
+	// test size above then fetch 
+	TreeType *tree = this->_next(); 
+	while (BaseType::m_adaptor.isNil(tree) && BaseType::m_adaptor.getChildCount(tree) == 1) 
+		tree = BaseType::m_adaptor->getChild(tree, 0); 
+	//System.out.println("_next="+((Tree)tree).toStringTree()); 
+	TreeType *el = BaseType::m_adaptor->dupNode(tree); // dup just the root (want node here) 
+	return el; 
+} 
+ 
+}