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

1 files changed, 460 insertions, 460 deletions

diff --git a/contrib/libs/antlr3_cpp_runtime/include/antlr3input.inl b/contrib/libs/antlr3_cpp_runtime/include/antlr3input.inl
index d3d2c07b04..6837a06540 100644
--- a/contrib/libs/antlr3_cpp_runtime/include/antlr3input.inl
+++ b/contrib/libs/antlr3_cpp_runtime/include/antlr3input.inl
@@ -1,307 +1,307 @@
 namespace antlr3 {
- 
-template<class ImplTraits> 
-InputStream<ImplTraits>::InputStream(const ANTLR_UINT8* fileName, ANTLR_UINT32 encoding) 
-{ 
-    // First order of business is to read the file into some buffer space 
-    // as just straight 8 bit bytes. Then we will work out the encoding and 
-    // byte order and adjust the API functions that are installed for the 
-    // default 8Bit stream accordingly. 
-    // 
-    this->createFileStream(fileName); 
- 
+
+template<class ImplTraits>
+InputStream<ImplTraits>::InputStream(const ANTLR_UINT8* fileName, ANTLR_UINT32 encoding)
+{
+    // First order of business is to read the file into some buffer space
+    // as just straight 8 bit bytes. Then we will work out the encoding and
+    // byte order and adjust the API functions that are installed for the
+    // default 8Bit stream accordingly.
+    //
+    this->createFileStream(fileName);
+
     // We have the data in memory now so we can deal with it according to 
-    // the encoding scheme we were given by the user. 
-    // 
-    m_encoding = encoding; 
- 
+    // the encoding scheme we were given by the user.
+    //
+    m_encoding = encoding;
+
     // Now we need to work out the endian type and install any 
-    // API functions that differ from 8Bit 
-    // 
-    this->setupInputStream(); 
- 
-    // Now we can set up the file name 
+    // API functions that differ from 8Bit
+    //
+    this->setupInputStream();
+
+    // Now we can set up the file name
     //	
     BaseType::m_streamName	= (const char* )fileName;
     m_fileName		= BaseType::m_streamName;
-} 
- 
-template<class ImplTraits> 
-InputStream<ImplTraits>::InputStream(const ANTLR_UINT8* data, ANTLR_UINT32 encoding, ANTLR_UINT32 size, ANTLR_UINT8* name) 
-{ 
+}
+
+template<class ImplTraits>
+InputStream<ImplTraits>::InputStream(const ANTLR_UINT8* data, ANTLR_UINT32 encoding, ANTLR_UINT32 size, ANTLR_UINT8* name)
+{
 	// First order of business is to set up the stream and install the data pointer.
-    // Then we will work out the encoding and byte order and adjust the API functions that are installed for the 
-    // default 8Bit stream accordingly. 
-    // 
-    this->createStringStream(data); 
+    // Then we will work out the encoding and byte order and adjust the API functions that are installed for the
+    // default 8Bit stream accordingly.
+    //
+    this->createStringStream(data);
     
-    // Size (in bytes) of the given 'string' 
-    // 
+    // Size (in bytes) of the given 'string'
+    //
     m_sizeBuf		= size;
- 
+
     // We have the data in memory now so we can deal with it according to 
-    // the encoding scheme we were given by the user. 
-    // 
-    m_encoding = encoding; 
- 
+    // the encoding scheme we were given by the user.
+    //
+    m_encoding = encoding;
+
     // Now we need to work out the endian type and install any 
-    // API functions that differ from 8Bit 
-    // 
-    this->setupInputStream(); 
- 
-    // Now we can set up the file name 
+    // API functions that differ from 8Bit
+    //
+    this->setupInputStream();
+
+    // Now we can set up the file name
     //	
     BaseType::m_streamName	= (name == NULL ) ? "" : (const char*)name;
     m_fileName		= BaseType::m_streamName;
- 
-} 
- 
-template<class ImplTraits> 
-void InputStream<ImplTraits>::createStringStream(const ANTLR_UINT8* data) 
-{ 
+
+}
+
+template<class ImplTraits>
+void InputStream<ImplTraits>::createStringStream(const ANTLR_UINT8* data)
+{
 	if	(data == NULL)
 	{
 		ParseNullStringException ex;
 		throw ex;
 	}
- 
+
 	// Structure was allocated correctly, now we can install the pointer
 	//
-    m_data             = data; 
+    m_data             = data;
     m_isAllocated	   = false;
- 
+
 	// Call the common 8 bit input stream handler
 	// initialization.
 	//
 	this->genericSetupStream();
-} 
- 
-template<class ImplTraits> 
-void InputStream<ImplTraits>::createFileStream(const ANTLR_UINT8* fileName) 
-{ 
+}
+
+template<class ImplTraits>
+void InputStream<ImplTraits>::createFileStream(const ANTLR_UINT8* fileName)
+{
 	if	(fileName == NULL)
 	{
 		ParseFileAbsentException ex;
 		throw ex;
 	}
- 
+
 	// Structure was allocated correctly, now we can read the file.
 	//
 	FileUtils<ImplTraits>::AntlrRead8Bit(this, fileName);
- 
+
 	// Call the common 8 bit input stream handler
 	// initialization.
 	//
 	this->genericSetupStream();
-} 
- 
-template<class ImplTraits> 
-void InputStream<ImplTraits>::genericSetupStream() 
-{ 
+}
+
+template<class ImplTraits>
+void InputStream<ImplTraits>::genericSetupStream()
+{
 	this->set_charByteSize(1);
 	
-    /* Set up the input stream brand new 
-     */ 
-    this->reset(); 
+    /* Set up the input stream brand new
+     */
+    this->reset();
     
-    /* Install default line separator character (it can be replaced 
-     * by the grammar programmer later) 
-     */ 
-    this->set_newLineChar((ANTLR_UCHAR)'\n'); 
-} 
- 
-template<class ImplTraits> 
-InputStream<ImplTraits>::~InputStream() 
-{ 
+    /* Install default line separator character (it can be replaced
+     * by the grammar programmer later)
+     */
+    this->set_newLineChar((ANTLR_UCHAR)'\n');
+}
+
+template<class ImplTraits>
+InputStream<ImplTraits>::~InputStream()
+{
 	// Free the input stream buffer if we allocated it
-    // 
+    //
     if	(m_isAllocated && (m_data != NULL))
 		AllocPolicyType::free((void*)m_data); //const_cast is required
-} 
- 
-template<class ImplTraits> 
-ANTLR_INLINE const typename InputStream<ImplTraits>::DataType* InputStream<ImplTraits>::get_data() const 
-{ 
+}
+
+template<class ImplTraits>
+ANTLR_INLINE const typename InputStream<ImplTraits>::DataType* InputStream<ImplTraits>::get_data() const
+{
 	return m_data;
-} 
-template<class ImplTraits> 
-ANTLR_INLINE bool InputStream<ImplTraits>::get_isAllocated() const 
-{ 
+}
+template<class ImplTraits>
+ANTLR_INLINE bool InputStream<ImplTraits>::get_isAllocated() const
+{
 	return m_isAllocated;
-} 
-template<class ImplTraits> 
-ANTLR_INLINE const typename InputStream<ImplTraits>::DataType* InputStream<ImplTraits>::get_nextChar() const 
-{ 
+}
+template<class ImplTraits>
+ANTLR_INLINE const typename InputStream<ImplTraits>::DataType* InputStream<ImplTraits>::get_nextChar() const
+{
 	return m_nextChar;
-} 
-template<class ImplTraits> 
-ANTLR_INLINE ANTLR_UINT32 InputStream<ImplTraits>::get_sizeBuf() const 
-{ 
+}
+template<class ImplTraits>
+ANTLR_INLINE ANTLR_UINT32 InputStream<ImplTraits>::get_sizeBuf() const
+{
 	return m_sizeBuf;
-} 
-template<class ImplTraits> 
-ANTLR_INLINE ANTLR_UINT32 InputStream<ImplTraits>::get_line() const 
-{ 
+}
+template<class ImplTraits>
+ANTLR_INLINE ANTLR_UINT32 InputStream<ImplTraits>::get_line() const
+{
 	return m_line;
-} 
-template<class ImplTraits> 
-ANTLR_INLINE const typename InputStream<ImplTraits>::DataType* InputStream<ImplTraits>::get_currentLine() const 
-{ 
+}
+template<class ImplTraits>
+ANTLR_INLINE const typename InputStream<ImplTraits>::DataType* InputStream<ImplTraits>::get_currentLine() const
+{
 	return m_currentLine;
-} 
-template<class ImplTraits> 
-ANTLR_INLINE ANTLR_INT32 InputStream<ImplTraits>::get_charPositionInLine() const 
-{ 
+}
+template<class ImplTraits>
+ANTLR_INLINE ANTLR_INT32 InputStream<ImplTraits>::get_charPositionInLine() const
+{
 	return m_charPositionInLine;
-} 
-template<class ImplTraits> 
-ANTLR_INLINE ANTLR_UINT32 InputStream<ImplTraits>::get_markDepth() const 
-{ 
+}
+template<class ImplTraits>
+ANTLR_INLINE ANTLR_UINT32 InputStream<ImplTraits>::get_markDepth() const
+{
 	return m_markDepth;
-} 
-template<class ImplTraits> 
-ANTLR_INLINE typename InputStream<ImplTraits>::MarkersType& InputStream<ImplTraits>::get_markers() 
-{ 
+}
+template<class ImplTraits>
+ANTLR_INLINE typename InputStream<ImplTraits>::MarkersType& InputStream<ImplTraits>::get_markers()
+{
 	return m_markers;
-} 
-template<class ImplTraits> 
-ANTLR_INLINE const typename InputStream<ImplTraits>::StringType& InputStream<ImplTraits>::get_fileName() const 
-{ 
+}
+template<class ImplTraits>
+ANTLR_INLINE const typename InputStream<ImplTraits>::StringType& InputStream<ImplTraits>::get_fileName() const
+{
 	return m_fileName;
-} 
-template<class ImplTraits> 
-ANTLR_INLINE ANTLR_UINT32 InputStream<ImplTraits>::get_fileNo() const 
-{ 
+}
+template<class ImplTraits>
+ANTLR_INLINE ANTLR_UINT32 InputStream<ImplTraits>::get_fileNo() const
+{
 	return m_fileNo;
-} 
-template<class ImplTraits> 
-ANTLR_INLINE ANTLR_UCHAR InputStream<ImplTraits>::get_newlineChar() const 
-{ 
+}
+template<class ImplTraits>
+ANTLR_INLINE ANTLR_UCHAR InputStream<ImplTraits>::get_newlineChar() const
+{
 	return m_newlineChar;
-} 
-template<class ImplTraits> 
-ANTLR_INLINE ANTLR_UINT8 InputStream<ImplTraits>::get_charByteSize() const 
-{ 
+}
+template<class ImplTraits>
+ANTLR_INLINE ANTLR_UINT8 InputStream<ImplTraits>::get_charByteSize() const
+{
 	return m_charByteSize;
-} 
-template<class ImplTraits> 
-ANTLR_INLINE ANTLR_UINT32 InputStream<ImplTraits>::get_encoding() const 
-{ 
+}
+template<class ImplTraits>
+ANTLR_INLINE ANTLR_UINT32 InputStream<ImplTraits>::get_encoding() const
+{
 	return m_encoding;
-} 
-template<class ImplTraits> 
-ANTLR_INLINE void InputStream<ImplTraits>::set_data( DataType* data ) 
-{ 
+}
+template<class ImplTraits>
+ANTLR_INLINE void InputStream<ImplTraits>::set_data( DataType* data )
+{
 	m_data = data;
-} 
-template<class ImplTraits> 
-ANTLR_INLINE void InputStream<ImplTraits>::set_isAllocated( bool isAllocated ) 
-{ 
+}
+template<class ImplTraits>
+ANTLR_INLINE void InputStream<ImplTraits>::set_isAllocated( bool isAllocated )
+{
 	m_isAllocated = isAllocated;
-} 
-template<class ImplTraits> 
-ANTLR_INLINE void InputStream<ImplTraits>::set_nextChar( const DataType* nextChar ) 
-{ 
+}
+template<class ImplTraits>
+ANTLR_INLINE void InputStream<ImplTraits>::set_nextChar( const DataType* nextChar )
+{
 	m_nextChar = nextChar;
-} 
-template<class ImplTraits> 
-ANTLR_INLINE void InputStream<ImplTraits>::set_sizeBuf( ANTLR_UINT32 sizeBuf ) 
-{ 
+}
+template<class ImplTraits>
+ANTLR_INLINE void InputStream<ImplTraits>::set_sizeBuf( ANTLR_UINT32 sizeBuf )
+{
 	m_sizeBuf = sizeBuf;
-} 
-template<class ImplTraits> 
-ANTLR_INLINE void InputStream<ImplTraits>::set_line( ANTLR_UINT32 line ) 
-{ 
+}
+template<class ImplTraits>
+ANTLR_INLINE void InputStream<ImplTraits>::set_line( ANTLR_UINT32 line )
+{
 	m_line = line;
-} 
-template<class ImplTraits> 
-ANTLR_INLINE void InputStream<ImplTraits>::set_currentLine( const DataType* currentLine ) 
-{ 
+}
+template<class ImplTraits>
+ANTLR_INLINE void InputStream<ImplTraits>::set_currentLine( const DataType* currentLine )
+{
 	m_currentLine = currentLine;
-} 
-template<class ImplTraits> 
-ANTLR_INLINE void InputStream<ImplTraits>::set_charPositionInLine( ANTLR_INT32 charPositionInLine ) 
-{ 
+}
+template<class ImplTraits>
+ANTLR_INLINE void InputStream<ImplTraits>::set_charPositionInLine( ANTLR_INT32 charPositionInLine )
+{
 	m_charPositionInLine = charPositionInLine;
-} 
-template<class ImplTraits> 
-ANTLR_INLINE void InputStream<ImplTraits>::set_markDepth( ANTLR_UINT32 markDepth ) 
-{ 
+}
+template<class ImplTraits>
+ANTLR_INLINE void InputStream<ImplTraits>::set_markDepth( ANTLR_UINT32 markDepth )
+{
 	m_markDepth = markDepth;
-} 
-template<class ImplTraits> 
-ANTLR_INLINE void InputStream<ImplTraits>::set_markers( const MarkersType& markers ) 
-{ 
+}
+template<class ImplTraits>
+ANTLR_INLINE void InputStream<ImplTraits>::set_markers( const MarkersType& markers )
+{
 	m_markers = markers;
-} 
-template<class ImplTraits> 
-ANTLR_INLINE void InputStream<ImplTraits>::set_fileName( const StringType& fileName ) 
-{ 
+}
+template<class ImplTraits>
+ANTLR_INLINE void InputStream<ImplTraits>::set_fileName( const StringType& fileName )
+{
 	m_fileName = fileName;
-} 
-template<class ImplTraits> 
-ANTLR_INLINE void InputStream<ImplTraits>::set_fileNo( ANTLR_UINT32 fileNo ) 
-{ 
+}
+template<class ImplTraits>
+ANTLR_INLINE void InputStream<ImplTraits>::set_fileNo( ANTLR_UINT32 fileNo )
+{
 	m_fileNo = fileNo;
-} 
-template<class ImplTraits> 
-ANTLR_INLINE void InputStream<ImplTraits>::set_newlineChar( ANTLR_UCHAR newlineChar ) 
-{ 
+}
+template<class ImplTraits>
+ANTLR_INLINE void InputStream<ImplTraits>::set_newlineChar( ANTLR_UCHAR newlineChar )
+{
 	m_newlineChar = newlineChar;
-} 
-template<class ImplTraits> 
-ANTLR_INLINE void InputStream<ImplTraits>::set_charByteSize( ANTLR_UINT8 charByteSize ) 
-{ 
+}
+template<class ImplTraits>
+ANTLR_INLINE void InputStream<ImplTraits>::set_charByteSize( ANTLR_UINT8 charByteSize )
+{
 	m_charByteSize = charByteSize;
-} 
-template<class ImplTraits> 
-ANTLR_INLINE void InputStream<ImplTraits>::set_encoding( ANTLR_UINT32 encoding ) 
-{ 
+}
+template<class ImplTraits>
+ANTLR_INLINE void InputStream<ImplTraits>::set_encoding( ANTLR_UINT32 encoding )
+{
 	m_encoding = encoding;
-} 
- 
-template<class ImplTraits> 
-ANTLR_INLINE void InputStream<ImplTraits>::inc_charPositionInLine() 
-{ 
+}
+
+template<class ImplTraits>
+ANTLR_INLINE void InputStream<ImplTraits>::inc_charPositionInLine()
+{
 	++m_charPositionInLine;
-} 
- 
-template<class ImplTraits> 
-ANTLR_INLINE void InputStream<ImplTraits>::inc_line() 
-{ 
+}
+
+template<class ImplTraits>
+ANTLR_INLINE void InputStream<ImplTraits>::inc_line()
+{
 	++m_line;
-} 
- 
-template<class ImplTraits> 
-ANTLR_INLINE void InputStream<ImplTraits>::inc_markDepth() 
-{ 
+}
+
+template<class ImplTraits>
+ANTLR_INLINE void InputStream<ImplTraits>::inc_markDepth()
+{
 	++m_markDepth;
-} 
- 
-template<class ImplTraits> 
+}
+
+template<class ImplTraits>
 ANTLR_INLINE void	InputStream<ImplTraits>::reset()
-{ 
+{
 	m_nextChar		= m_data;	/* Input at first character */
     m_line			= 1;		/* starts at line 1	    */
     m_charPositionInLine	= 0;
     m_currentLine		= m_data;
     m_markDepth		= 0;		/* Reset markers	    */
     
-    /* Clear out up the markers table if it is there 
-     */ 
+    /* Clear out up the markers table if it is there
+     */
 	m_markers.clear();
-} 
- 
-template<class ImplTraits> 
-void    InputStream<ImplTraits>::reuse(ANTLR_UINT8* inString, ANTLR_UINT32 size, ANTLR_UINT8* name) 
-{ 
+}
+
+template<class ImplTraits>
+void    InputStream<ImplTraits>::reuse(ANTLR_UINT8* inString, ANTLR_UINT32 size, ANTLR_UINT8* name)
+{
 	m_isAllocated	= false;
     m_data		= inString;
     m_sizeBuf	= size;
     
-    // Now we can set up the file name. As we are reusing the stream, there may already 
-    // be a string that we can reuse for holding the filename. 
-    // 
+    // Now we can set up the file name. As we are reusing the stream, there may already
+    // be a string that we can reuse for holding the filename.
+    //
 	if	( BaseType::m_streamName.empty() ) 
 	{
 		BaseType::m_streamName	= ((name == NULL) ? "-memory-" : (const char *)name);
@@ -311,309 +311,309 @@ void    InputStream<ImplTraits>::reuse(ANTLR_UINT8* inString, ANTLR_UINT32 size,
 	{
 		BaseType::m_streamName = ((name == NULL) ? "-memory-" : (const char *)name);
 	}
- 
-    this->reset(); 
-} 
- 
-/* 
-template<class ImplTraits> 
+
+    this->reset();
+}
+
+/*
+template<class ImplTraits>
 typename InputStream<ImplTraits>::DataType*	InputStream<ImplTraits>::LT(ANTLR_INT32 lt)
-{ 
+{
 	return this->LA(lt);
-} 
-*/ 
- 
-template<class ImplTraits> 
+}
+*/
+
+template<class ImplTraits>
 ANTLR_UINT32	InputStream<ImplTraits>::size()
-{ 
+{
 	return m_sizeBuf;
-} 
- 
-template<class ImplTraits> 
+}
+
+template<class ImplTraits>
 ANTLR_MARKER	InputStream<ImplTraits>::index_impl()
-{ 
+{
 	return (ANTLR_MARKER)m_nextChar;
-} 
- 
- 
-template<class ImplTraits> 
+}
+
+
+template<class ImplTraits>
 typename InputStream<ImplTraits>::StringType	InputStream<ImplTraits>::substr(ANTLR_MARKER start, ANTLR_MARKER stop)
-{ 
+{
 	std::size_t len = static_cast<std::size_t>( (stop-start)/sizeof(DataType) + 1 );
 	StringType str( (const char*)start, len );
 	return str;
-} 
- 
-template<class ImplTraits> 
+}
+
+template<class ImplTraits>
 ANTLR_UINT32	InputStream<ImplTraits>::get_line()
-{ 
+{
 	return m_line;
-} 
- 
-template<class ImplTraits> 
+}
+
+template<class ImplTraits>
 const typename InputStream<ImplTraits>::DataType*	InputStream<ImplTraits>::getLineBuf()
-{ 
+{
 	return m_currentLine;
-} 
- 
-template<class ImplTraits> 
+}
+
+template<class ImplTraits>
 ANTLR_INLINE ANTLR_UINT32	InputStream<ImplTraits>::get_charPositionInLine()
-{ 
+{
 	return m_charPositionInLine;
-} 
- 
-template<class ImplTraits> 
+}
+
+template<class ImplTraits>
 ANTLR_INLINE void	InputStream<ImplTraits>::set_charPositionInLine(ANTLR_UINT32 position)
-{ 
+{
 	m_charPositionInLine = position;
-} 
- 
-template<class ImplTraits> 
+}
+
+template<class ImplTraits>
 void	InputStream<ImplTraits>::set_newLineChar(ANTLR_UINT32 newlineChar)
-{ 
+{
 	m_newlineChar = newlineChar;
-} 
- 
-template<class ImplTraits> 
-ANTLR_INLINE LexState<ImplTraits>::LexState() 
-{ 
+}
+
+template<class ImplTraits>
+ANTLR_INLINE LexState<ImplTraits>::LexState()
+{
 	m_nextChar = NULL;
 	m_line = 0;
 	m_currentLine = NULL;
 	m_charPositionInLine = 0;
-} 
- 
-template<class ImplTraits> 
-ANTLR_INLINE const typename LexState<ImplTraits>::DataType* LexState<ImplTraits>::get_nextChar() const 
-{ 
+}
+
+template<class ImplTraits>
+ANTLR_INLINE const typename LexState<ImplTraits>::DataType* LexState<ImplTraits>::get_nextChar() const
+{
 	return m_nextChar;
-} 
- 
-template<class ImplTraits> 
-ANTLR_INLINE ANTLR_UINT32 LexState<ImplTraits>::get_line() const 
-{ 
+}
+
+template<class ImplTraits>
+ANTLR_INLINE ANTLR_UINT32 LexState<ImplTraits>::get_line() const
+{
 	return m_line;
-} 
- 
-template<class ImplTraits> 
-ANTLR_INLINE const typename LexState<ImplTraits>::DataType* LexState<ImplTraits>::get_currentLine() const 
-{ 
+}
+
+template<class ImplTraits>
+ANTLR_INLINE const typename LexState<ImplTraits>::DataType* LexState<ImplTraits>::get_currentLine() const
+{
 	return m_currentLine;
-} 
- 
-template<class ImplTraits> 
-ANTLR_INLINE ANTLR_INT32 LexState<ImplTraits>::get_charPositionInLine() const 
-{ 
+}
+
+template<class ImplTraits>
+ANTLR_INLINE ANTLR_INT32 LexState<ImplTraits>::get_charPositionInLine() const
+{
 	return m_charPositionInLine;
-} 
- 
-template<class ImplTraits> 
-ANTLR_INLINE void LexState<ImplTraits>::set_nextChar( const DataType* nextChar ) 
-{ 
+}
+
+template<class ImplTraits>
+ANTLR_INLINE void LexState<ImplTraits>::set_nextChar( const DataType* nextChar )
+{
 	m_nextChar = nextChar;
-} 
- 
-template<class ImplTraits> 
-ANTLR_INLINE void LexState<ImplTraits>::set_line( ANTLR_UINT32 line ) 
-{ 
+}
+
+template<class ImplTraits>
+ANTLR_INLINE void LexState<ImplTraits>::set_line( ANTLR_UINT32 line )
+{
 	m_line = line;
-} 
- 
-template<class ImplTraits> 
-ANTLR_INLINE void LexState<ImplTraits>::set_currentLine( const DataType* currentLine ) 
-{ 
+}
+
+template<class ImplTraits>
+ANTLR_INLINE void LexState<ImplTraits>::set_currentLine( const DataType* currentLine )
+{
 	m_currentLine = currentLine;
-} 
- 
-template<class ImplTraits> 
-ANTLR_INLINE void LexState<ImplTraits>::set_charPositionInLine( ANTLR_INT32 charPositionInLine ) 
-{ 
+}
+
+template<class ImplTraits>
+ANTLR_INLINE void LexState<ImplTraits>::set_charPositionInLine( ANTLR_INT32 charPositionInLine )
+{
 	m_charPositionInLine = charPositionInLine;
-} 
- 
-template<class ImplTraits> 
+}
+
+template<class ImplTraits>
 ANTLR_INLINE typename InputStream<ImplTraits>::IntStreamType*	InputStream<ImplTraits>::get_istream()
-{ 
+{
 	return this;
-} 
- 
-template<class ImplTraits> 
-void InputStream<ImplTraits>::setupInputStream() 
-{ 
+}
+
+template<class ImplTraits>
+void InputStream<ImplTraits>::setupInputStream()
+{
 	bool  isBigEndian;
- 
-    // Used to determine the endianness of the machine we are currently 
-    // running on. 
-    // 
-    ANTLR_UINT16 bomTest = 0xFEFF; 
+
+    // Used to determine the endianness of the machine we are currently
+    // running on.
+    //
+    ANTLR_UINT16 bomTest = 0xFEFF;
     
-    // What endianess is the machine we are running on? If the incoming 
-    // encoding endianess is the same as this machine's natural byte order 
-    // then we can use more efficient API calls. 
-    // 
-    if  (*((ANTLR_UINT8*)(&bomTest)) == 0xFE) 
-    { 
-        isBigEndian = true; 
-    } 
-    else 
-    { 
-        isBigEndian = false; 
-    } 
- 
-    // What encoding did the user tell us {s}he thought it was? I am going 
-    // to get sick of the questions on antlr-interest, I know I am. 
-    // 
-    switch  (m_encoding) 
-    { 
+    // What endianess is the machine we are running on? If the incoming
+    // encoding endianess is the same as this machine's natural byte order
+    // then we can use more efficient API calls.
+    //
+    if  (*((ANTLR_UINT8*)(&bomTest)) == 0xFE)
+    {
+        isBigEndian = true;
+    }
+    else
+    {
+        isBigEndian = false;
+    }
+
+    // What encoding did the user tell us {s}he thought it was? I am going
+    // to get sick of the questions on antlr-interest, I know I am.
+    //
+    switch  (m_encoding)
+    {
         case    ENC_UTF8:
- 
-            // See if there is a BOM at the start of this UTF-8 sequence 
-            // and just eat it if there is. Windows .TXT files have this for instance 
-            // as it identifies UTF-8 even though it is of no consequence for byte order 
-            // as UTF-8 does not have a byte order. 
-            // 
-            if  (       (*(m_nextChar))      == 0xEF 
-                    &&  (*(m_nextChar+1))    == 0xBB 
-                    &&  (*(m_nextChar+2))    == 0xBF 
-                ) 
-            { 
-                // The UTF8 BOM is present so skip it 
-                // 
-                m_nextChar += 3; 
-            } 
- 
-            // Install the UTF8 input routines 
-            // 
+
+            // See if there is a BOM at the start of this UTF-8 sequence
+            // and just eat it if there is. Windows .TXT files have this for instance
+            // as it identifies UTF-8 even though it is of no consequence for byte order
+            // as UTF-8 does not have a byte order.
+            //
+            if  (       (*(m_nextChar))      == 0xEF
+                    &&  (*(m_nextChar+1))    == 0xBB
+                    &&  (*(m_nextChar+2))    == 0xBF
+                )
+            {
+                // The UTF8 BOM is present so skip it
+                //
+                m_nextChar += 3;
+            }
+
+            // Install the UTF8 input routines
+            //
 			this->setupIntStream( isBigEndian, isBigEndian );
 			this->set_charByteSize(0);
-            break; 
- 
+            break;
+
         case    ENC_UTF16:
- 
-            // See if there is a BOM at the start of the input. If not then 
-            // we assume that the byte order is the natural order of this 
-            // machine (or it is really UCS2). If there is a BOM we determine if the encoding 
-            // is the same as the natural order of this machine. 
-            // 
-            if  (       (ANTLR_UINT8)(*((ANTLR_UINT8*)m_nextChar))      == 0xFE 
-                    &&  (ANTLR_UINT8)(*((ANTLR_UINT8*)m_nextChar+1))    == 0xFF 
-                ) 
-            { 
-                // BOM Present, indicates Big Endian 
-                // 
-                m_nextChar += 1; 
- 
+
+            // See if there is a BOM at the start of the input. If not then
+            // we assume that the byte order is the natural order of this
+            // machine (or it is really UCS2). If there is a BOM we determine if the encoding
+            // is the same as the natural order of this machine.
+            //
+            if  (       (ANTLR_UINT8)(*((ANTLR_UINT8*)m_nextChar))      == 0xFE
+                    &&  (ANTLR_UINT8)(*((ANTLR_UINT8*)m_nextChar+1))    == 0xFF
+                )
+            {
+                // BOM Present, indicates Big Endian
+                //
+                m_nextChar += 1;
+
 				this->setupIntStream( isBigEndian, true );
-            } 
-            else if  (      (ANTLR_UINT8)(*((ANTLR_UINT8*)m_nextChar))      == 0xFF 
-                        &&  (ANTLR_UINT8)(*((ANTLR_UINT8*)m_nextChar+1))    == 0xFE 
-                ) 
-            { 
-                // BOM present, indicates Little Endian 
-                // 
-                m_nextChar += 1; 
- 
-                this->setupIntStream( isBigEndian, false ); 
-            } 
-            else 
-            { 
-                // No BOM present, assume local computer byte order 
-                // 
-                this->setupIntStream(isBigEndian, isBigEndian); 
-            } 
+            }
+            else if  (      (ANTLR_UINT8)(*((ANTLR_UINT8*)m_nextChar))      == 0xFF
+                        &&  (ANTLR_UINT8)(*((ANTLR_UINT8*)m_nextChar+1))    == 0xFE
+                )
+            {
+                // BOM present, indicates Little Endian
+                //
+                m_nextChar += 1;
+
+                this->setupIntStream( isBigEndian, false );
+            }
+            else
+            {
+                // No BOM present, assume local computer byte order
+                //
+                this->setupIntStream(isBigEndian, isBigEndian);
+            }
 			this->set_charByteSize(2);
-            break; 
- 
+            break;
+
         case    ENC_UTF32:
- 
-            // See if there is a BOM at the start of the input. If not then 
-            // we assume that the byte order is the natural order of this 
-            // machine. If there is we determine if the encoding 
-            // is the same as the natural order of this machine. 
-            // 
-            if  (       (ANTLR_UINT8)(*((ANTLR_UINT8*)m_nextChar))      == 0x00 
-                    &&  (ANTLR_UINT8)(*((ANTLR_UINT8*)m_nextChar+1))    == 0x00 
-                    &&  (ANTLR_UINT8)(*((ANTLR_UINT8*)m_nextChar+2))    == 0xFE 
-                    &&  (ANTLR_UINT8)(*((ANTLR_UINT8*)m_nextChar+3))    == 0xFF 
-                ) 
-            { 
-                // BOM Present, indicates Big Endian 
-                // 
-                m_nextChar += 1; 
- 
-                this->setupIntStream(isBigEndian, true); 
-            } 
-            else if  (      (ANTLR_UINT8)(*((ANTLR_UINT8*)m_nextChar))      == 0xFF 
-                        &&  (ANTLR_UINT8)(*((ANTLR_UINT8*)m_nextChar+1))    == 0xFE 
-                        &&  (ANTLR_UINT8)(*((ANTLR_UINT8*)m_nextChar+1))    == 0x00 
-                        &&  (ANTLR_UINT8)(*((ANTLR_UINT8*)m_nextChar+1))    == 0x00 
-                ) 
-            { 
-                // BOM present, indicates Little Endian 
-                // 
-                m_nextChar += 1; 
- 
+
+            // See if there is a BOM at the start of the input. If not then
+            // we assume that the byte order is the natural order of this
+            // machine. If there is we determine if the encoding
+            // is the same as the natural order of this machine.
+            //
+            if  (       (ANTLR_UINT8)(*((ANTLR_UINT8*)m_nextChar))      == 0x00
+                    &&  (ANTLR_UINT8)(*((ANTLR_UINT8*)m_nextChar+1))    == 0x00
+                    &&  (ANTLR_UINT8)(*((ANTLR_UINT8*)m_nextChar+2))    == 0xFE
+                    &&  (ANTLR_UINT8)(*((ANTLR_UINT8*)m_nextChar+3))    == 0xFF
+                )
+            {
+                // BOM Present, indicates Big Endian
+                //
+                m_nextChar += 1;
+
+                this->setupIntStream(isBigEndian, true);
+            }
+            else if  (      (ANTLR_UINT8)(*((ANTLR_UINT8*)m_nextChar))      == 0xFF
+                        &&  (ANTLR_UINT8)(*((ANTLR_UINT8*)m_nextChar+1))    == 0xFE
+                        &&  (ANTLR_UINT8)(*((ANTLR_UINT8*)m_nextChar+1))    == 0x00
+                        &&  (ANTLR_UINT8)(*((ANTLR_UINT8*)m_nextChar+1))    == 0x00
+                )
+            {
+                // BOM present, indicates Little Endian
+                //
+                m_nextChar += 1;
+
 				this->setupIntStream( isBigEndian, false );
-            } 
-            else 
-            { 
-                // No BOM present, assume local computer byte order 
-                // 
+            }
+            else
+            {
+                // No BOM present, assume local computer byte order
+                //
 				this->setupIntStream( isBigEndian, isBigEndian );
-            } 
+            }
 			this->set_charByteSize(4);
-            break; 
- 
+            break;
+
         case    ENC_UTF16BE:
- 
-            // Encoding is definately Big Endian with no BOM 
-            // 
+
+            // Encoding is definately Big Endian with no BOM
+            //
 			this->setupIntStream( isBigEndian, true );
 			this->set_charByteSize(2);
-            break; 
- 
+            break;
+
         case    ENC_UTF16LE:
- 
-            // Encoding is definately Little Endian with no BOM 
-            // 
-            this->setupIntStream( isBigEndian, false ); 
+
+            // Encoding is definately Little Endian with no BOM
+            //
+            this->setupIntStream( isBigEndian, false );
 			this->set_charByteSize(2);
-            break; 
- 
+            break;
+
         case    ENC_UTF32BE:
- 
-            // Encoding is definately Big Endian with no BOM 
-            // 
+
+            // Encoding is definately Big Endian with no BOM
+            //
 			this->setupIntStream( isBigEndian, true );
 			this->set_charByteSize(4);
-            break; 
- 
+            break;
+
         case    ENC_UTF32LE:
- 
-            // Encoding is definately Little Endian with no BOM 
-            // 
+
+            // Encoding is definately Little Endian with no BOM
+            //
 			this->setupIntStream( isBigEndian, false );
 			this->set_charByteSize(4);
-            break; 
- 
+            break;
+
         case    ENC_EBCDIC:
- 
-            // EBCDIC is basically the same as ASCII but with an on the 
-            // fly translation to ASCII 
-            // 
-            this->setupIntStream( isBigEndian, isBigEndian ); 
+
+            // EBCDIC is basically the same as ASCII but with an on the
+            // fly translation to ASCII
+            //
+            this->setupIntStream( isBigEndian, isBigEndian );
 			this->set_charByteSize(1);
-            break; 
- 
+            break;
+
         case    ENC_8BIT:
-        default: 
- 
-            // Standard 8bit/ASCII 
-            // 
-            this->setupIntStream( isBigEndian, isBigEndian ); 
+        default:
+
+            // Standard 8bit/ASCII
+            //
+            this->setupIntStream( isBigEndian, isBigEndian );
 			this->set_charByteSize(1);
-            break; 
+            break;
     }    
-} 
- 
+}
+
 }