Restoring authorship annotation for Alexander Gololobov <davenger@yandex-team.com>. Commit 1 of 2.

contrib/libs/grpc/src/cpp/common/channel_arguments.cc

@@ -65,15 +65,15 @@ ChannelArguments::ChannelArguments(const ChannelArguments& other)
   }
 }
 
-ChannelArguments::~ChannelArguments() {
+ChannelArguments::~ChannelArguments() { 
   grpc_core::ExecCtx exec_ctx;
   for (auto& arg : args_) {
     if (arg.type == GRPC_ARG_POINTER) {
       arg.value.pointer.vtable->destroy(arg.value.pointer.p);
-    }
-  }
-}
-
+    } 
+  } 
+} 
+ 
 void ChannelArguments::Swap(ChannelArguments& other) {
   args_.swap(other.args_);
   strings_.swap(other.strings_);
@@ -190,7 +190,7 @@ void ChannelArguments::SetPointerWithVtable(
   arg.type = GRPC_ARG_POINTER;
   strings_.push_back(key);
   arg.key = const_cast<char*>(strings_.back().c_str());
-  arg.value.pointer.p = vtable->copy(value);
+  arg.value.pointer.p = vtable->copy(value); 
   arg.value.pointer.vtable = vtable;
   args_.push_back(arg);
 }

contrib/libs/pire/Makefile.am

@@ -1,2 +1,2 @@
-ACLOCAL_AMFLAGS = -I m4
-SUBDIRS = pire tests pkg samples
+ACLOCAL_AMFLAGS = -I m4 
+SUBDIRS = pire tests pkg samples 

contrib/libs/pire/README

@@ -1,6 +1,6 @@
-This is PIRE, Perl Incompatible Regular Expressions library.
-
-For detailed information about what it is, how to build and use it,
-see http://wiki.yandex-team.ru/DmitrijjProkopcev/pire .
-
-Please report bugs to dprokoptsev@yandex-team.ru or davenger@yandex-team.ru.
+This is PIRE, Perl Incompatible Regular Expressions library. 
+ 
+For detailed information about what it is, how to build and use it, 
+see http://wiki.yandex-team.ru/DmitrijjProkopcev/pire . 
+ 
+Please report bugs to dprokoptsev@yandex-team.ru or davenger@yandex-team.ru. 

contrib/libs/pire/configure.ac

@@ -1,47 +1,47 @@
-AC_PREREQ([2.63])
-AC_INIT([pire], [0.0.2], [dprokoptsev@yandex-team.ru])
-AM_INIT_AUTOMAKE([foreign -Wall])
-AC_CONFIG_SRCDIR([pire/classes.cpp])
-AC_CONFIG_HEADERS([config.h])
-AC_CONFIG_MACRO_DIR([m4])
-
-AC_LANG_CPLUSPLUS
-
-# Require neccessary binaries to build ourselves
-AC_PROG_CXX
-AC_PROG_CC
-AC_PROG_LEX
-AC_PROG_YACC
-AC_PROG_LIBTOOL
-
-# Check for cppunit
-AM_PATH_CPPUNIT([0.0.0],[with_unittests=yes],[
-	AC_WARN([cppunit not found. Unit tests will not compile and run.])
-	with_unittests=no
-])
-AM_CONDITIONAL([WITH_UNITTESTS], [test x"$with_unittests" = xyes])
-
-# Just for conscience' sake
-AC_CHECK_HEADERS([stdlib.h string.h sys/time.h])
-AC_HEADER_STDBOOL
-AC_C_INLINE
-AC_TYPE_SIZE_T
-AC_CHECK_TYPES([ptrdiff_t])
-AC_FUNC_ERROR_AT_LINE
-AC_FUNC_MALLOC
-AC_CHECK_FUNCS([memset strchr])
-
-# Require little-endian platform
-AC_C_BIGENDIAN
-if test x"$ac_cv_c_bigendian" = xyes; then
-	AC_ERROR([pire has not been ported to big-endian platforms yet.])
-fi
-
-# Optional features
-AC_ARG_ENABLE([extra], AS_HELP_STRING([--enable-extra], [Add extra functionality (capturing scanner, etc...)]))
-AC_ARG_ENABLE([debug], AS_HELP_STRING([--enable-debug], [Make Pire dump all constructed FSMs to std::clog (useless unless debugging Pire)]))
-AM_CONDITIONAL([ENABLE_EXTRA], [test x"$enable_extra" = xyes])
-AM_CONDITIONAL([ENABLE_DEBUG], [test x"$enable_debug" = xyes])
-
-AC_CONFIG_FILES([Makefile pire/Makefile tests/Makefile pkg/Makefile samples/Makefile samples/bench/Makefile])
-AC_OUTPUT
+AC_PREREQ([2.63]) 
+AC_INIT([pire], [0.0.2], [dprokoptsev@yandex-team.ru]) 
+AM_INIT_AUTOMAKE([foreign -Wall]) 
+AC_CONFIG_SRCDIR([pire/classes.cpp]) 
+AC_CONFIG_HEADERS([config.h]) 
+AC_CONFIG_MACRO_DIR([m4]) 
+ 
+AC_LANG_CPLUSPLUS 
+ 
+# Require neccessary binaries to build ourselves 
+AC_PROG_CXX 
+AC_PROG_CC 
+AC_PROG_LEX 
+AC_PROG_YACC 
+AC_PROG_LIBTOOL 
+ 
+# Check for cppunit 
+AM_PATH_CPPUNIT([0.0.0],[with_unittests=yes],[ 
+	AC_WARN([cppunit not found. Unit tests will not compile and run.]) 
+	with_unittests=no 
+]) 
+AM_CONDITIONAL([WITH_UNITTESTS], [test x"$with_unittests" = xyes]) 
+ 
+# Just for conscience' sake 
+AC_CHECK_HEADERS([stdlib.h string.h sys/time.h]) 
+AC_HEADER_STDBOOL 
+AC_C_INLINE 
+AC_TYPE_SIZE_T 
+AC_CHECK_TYPES([ptrdiff_t]) 
+AC_FUNC_ERROR_AT_LINE 
+AC_FUNC_MALLOC 
+AC_CHECK_FUNCS([memset strchr]) 
+ 
+# Require little-endian platform 
+AC_C_BIGENDIAN 
+if test x"$ac_cv_c_bigendian" = xyes; then 
+	AC_ERROR([pire has not been ported to big-endian platforms yet.]) 
+fi 
+ 
+# Optional features 
+AC_ARG_ENABLE([extra], AS_HELP_STRING([--enable-extra], [Add extra functionality (capturing scanner, etc...)])) 
+AC_ARG_ENABLE([debug], AS_HELP_STRING([--enable-debug], [Make Pire dump all constructed FSMs to std::clog (useless unless debugging Pire)])) 
+AM_CONDITIONAL([ENABLE_EXTRA], [test x"$enable_extra" = xyes]) 
+AM_CONDITIONAL([ENABLE_DEBUG], [test x"$enable_debug" = xyes]) 
+ 
+AC_CONFIG_FILES([Makefile pire/Makefile tests/Makefile pkg/Makefile samples/Makefile samples/bench/Makefile]) 
+AC_OUTPUT 

contrib/libs/pire/pire/Makefile.am

@@ -1,121 +1,121 @@
-
-AM_CXXFLAGS = -Wall
-if ENABLE_DEBUG
-AM_CXXFLAGS += -DPIRE_DEBUG
-endif
-if ENABLE_CHECKED
-AM_CXXFLAGS += -DPIRE_CHECKED
-endif
-
-lib_LTLIBRARIES = libpire.la
-libpire_la_SOURCES = \
-	align.h \
-	any.h \
-	classes.cpp \
-	defs.h \
-	determine.h \
-	encoding.cpp \
-	encoding.h \
-	extra.h \
-	fsm.cpp \
-	fsm.h \
-	fwd.h \
-	glue.cpp \
-	glue.h \
+ 
+AM_CXXFLAGS = -Wall 
+if ENABLE_DEBUG 
+AM_CXXFLAGS += -DPIRE_DEBUG 
+endif 
+if ENABLE_CHECKED 
+AM_CXXFLAGS += -DPIRE_CHECKED 
+endif 
+ 
+lib_LTLIBRARIES = libpire.la 
+libpire_la_SOURCES = \ 
+	align.h \ 
+	any.h \ 
+	classes.cpp \ 
+	defs.h \ 
+	determine.h \ 
+	encoding.cpp \ 
+	encoding.h \ 
+	extra.h \ 
+	fsm.cpp \ 
+	fsm.h \ 
+	fwd.h \ 
+	glue.cpp \ 
+	glue.h \ 
 	minimize.h \
 	half_final_fsm.cpp \
 	half_final_fsm.h \
-	partition.h \
-	pire.h \
-	re_lexer.cpp \
-	re_lexer.h \
-	run.h \
-	scanner_io.cpp \
-	vbitset.h \
-	re_parser.ypp \
+	partition.h \ 
+	pire.h \ 
+	re_lexer.cpp \ 
+	re_lexer.h \ 
+	run.h \ 
+	scanner_io.cpp \ 
+	vbitset.h \ 
+	re_parser.ypp \ 
 	scanners/half_final.h \
-	scanners/loaded.h \
-	scanners/multi.h \
-	scanners/slow.h \
-	scanners/simple.h \
-	scanners/common.h \
-	scanners/pair.h \
-	stub/stl.h \
-	stub/lexical_cast.h \
-	stub/saveload.h \
-	stub/singleton.h \
-	stub/utf8.cpp \
-	stub/utf8.h \
-	stub/noncopyable.h \
-	stub/codepage_h.h \
-	stub/doccodes_h.h \
-	stub/unidata_h.h \
-	stub/unidata_cpp.h
-
-if ENABLE_EXTRA
-libpire_la_SOURCES += \
-	extra/capture.cpp \
-	extra/capture.h \
-	extra/count.cpp \
-	extra/count.h \
-	extra/glyphs.cpp \
-	extra/glyphs.h
-endif
-
-pire_hdrdir = $(includedir)/pire
-pire_hdr_HEADERS = \
-	align.h \
-	any.h \
-	defs.h \
-	determine.h \
-	encoding.h \
-	extra.h \
-	fsm.h \
-	fwd.h \
-	glue.h \
+	scanners/loaded.h \ 
+	scanners/multi.h \ 
+	scanners/slow.h \ 
+	scanners/simple.h \ 
+	scanners/common.h \ 
+	scanners/pair.h \ 
+	stub/stl.h \ 
+	stub/lexical_cast.h \ 
+	stub/saveload.h \ 
+	stub/singleton.h \ 
+	stub/utf8.cpp \ 
+	stub/utf8.h \ 
+	stub/noncopyable.h \ 
+	stub/codepage_h.h \ 
+	stub/doccodes_h.h \ 
+	stub/unidata_h.h \ 
+	stub/unidata_cpp.h 
+ 
+if ENABLE_EXTRA 
+libpire_la_SOURCES += \ 
+	extra/capture.cpp \ 
+	extra/capture.h \ 
+	extra/count.cpp \ 
+	extra/count.h \ 
+	extra/glyphs.cpp \ 
+	extra/glyphs.h 
+endif 
+ 
+pire_hdrdir = $(includedir)/pire 
+pire_hdr_HEADERS = \ 
+	align.h \ 
+	any.h \ 
+	defs.h \ 
+	determine.h \ 
+	encoding.h \ 
+	extra.h \ 
+	fsm.h \ 
+	fwd.h \ 
+	glue.h \ 
 	minimize.h \
 	half_final_fsm.h \
-	partition.h \
-	pire.h \
-	re_lexer.h \
-	re_parser.h \
-	run.h \
-	static_assert.h \
-	vbitset.h
-
-if ENABLE_EXTRA
-pire_extradir = $(includedir)/pire/extra
-pire_extra_HEADERS = \
-	extra/capture.h \
-	extra/count.h \
-	extra/glyphs.h
-endif
-
-pire_scannersdir = $(includedir)/pire/scanners
-pire_scanners_HEADERS = \
-	scanners/common.h \
+	partition.h \ 
+	pire.h \ 
+	re_lexer.h \ 
+	re_parser.h \ 
+	run.h \ 
+	static_assert.h \ 
+	vbitset.h 
+ 
+if ENABLE_EXTRA 
+pire_extradir = $(includedir)/pire/extra 
+pire_extra_HEADERS = \ 
+	extra/capture.h \ 
+	extra/count.h \ 
+	extra/glyphs.h 
+endif 
+ 
+pire_scannersdir = $(includedir)/pire/scanners 
+pire_scanners_HEADERS = \ 
+	scanners/common.h \ 
 	scanners/half_final.h \
-	scanners/multi.h \
-	scanners/slow.h \
-	scanners/simple.h \
-	scanners/loaded.h \
-	scanners/pair.h
-
-pire_stubdir = $(includedir)/pire/stub
-pire_stub_HEADERS = \
-	stub/stl.h \
-	stub/defaults.h \
-	stub/singleton.h \
-	stub/saveload.h \
-	stub/lexical_cast.h
-
-bin_PROGRAMS = pire_inline 
-
-pire_inline_SOURCES = inline.lpp stub/hacks.h stub/memstreams.h
-pire_inline_LDADD = libpire.la
-
-BUILT_SOURCES = re_parser.h re_parser.cpp
-CLEANFILES    = re_parser.h re_parser.cpp
-
-AM_YFLAGS = -d
-
+	scanners/multi.h \ 
+	scanners/slow.h \ 
+	scanners/simple.h \ 
+	scanners/loaded.h \ 
+	scanners/pair.h 
+ 
+pire_stubdir = $(includedir)/pire/stub 
+pire_stub_HEADERS = \ 
+	stub/stl.h \ 
+	stub/defaults.h \ 
+	stub/singleton.h \ 
+	stub/saveload.h \ 
+	stub/lexical_cast.h 
+ 
+bin_PROGRAMS = pire_inline  
+ 
+pire_inline_SOURCES = inline.lpp stub/hacks.h stub/memstreams.h 
+pire_inline_LDADD = libpire.la 
+ 
+BUILT_SOURCES = re_parser.h re_parser.cpp 
+CLEANFILES    = re_parser.h re_parser.cpp 
+ 
+AM_YFLAGS = -d 
+ 

contrib/libs/pire/pire/align.h

@@ -1,103 +1,103 @@
-/*
- * align.h -- functions for positioning streams and memory pointers
- *            to word boundaries
- *
- * Copyright (c) 2007-2010, Dmitry Prokoptsev <dprokoptsev@gmail.com>,
- *                          Alexander Gololobov <agololobov@gmail.com>
- *
- * This file is part of Pire, the Perl Incompatible
- * Regular Expressions library.
- *
- * Pire is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
+/* 
+ * align.h -- functions for positioning streams and memory pointers 
+ *            to word boundaries 
  * 
- * Pire is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser Public License for more details.
- * You should have received a copy of the GNU Lesser Public License
- * along with Pire.  If not, see <http://www.gnu.org/licenses>.
- */
-
-
-#ifndef PIRE_ALIGN_H
-#define PIRE_ALIGN_H
-
+ * Copyright (c) 2007-2010, Dmitry Prokoptsev <dprokoptsev@gmail.com>, 
+ *                          Alexander Gololobov <agololobov@gmail.com> 
+ * 
+ * This file is part of Pire, the Perl Incompatible 
+ * Regular Expressions library. 
+ * 
+ * Pire is free software: you can redistribute it and/or modify 
+ * it under the terms of the GNU Lesser Public License as published by 
+ * the Free Software Foundation, either version 3 of the License, or 
+ * (at your option) any later version. 
+ *  
+ * Pire is distributed in the hope that it will be useful, 
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of 
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
+ * GNU Lesser Public License for more details. 
+ * You should have received a copy of the GNU Lesser Public License 
+ * along with Pire.  If not, see <http://www.gnu.org/licenses>. 
+ */ 
+ 
+ 
+#ifndef PIRE_ALIGN_H 
+#define PIRE_ALIGN_H 
+ 
 #include <contrib/libs/pire/pire/stub/stl.h>
 #include <contrib/libs/pire/pire/stub/saveload.h>
 
-#include "platform.h"
-
-namespace Pire {
-	
-	namespace Impl {
-
-		template<class T>
-		inline T AlignUp(T t, size_t bound)
-		{
-			return (T) (((size_t) t + (bound-1)) & ~(bound-1));
-		}
-
-		template<class T>
-		inline T AlignDown(T t, size_t bound)
-		{
-			return (T) ((size_t) t & ~(bound-1));
-		}
-		
-		inline void AlignSave(yostream* s, size_t size)
-		{
-			size_t tail = AlignUp(size, sizeof(size_t)) - size;
-			if (tail) {
-				static const char buf[sizeof(MaxSizeWord)] = {0};
-				SavePodArray(s, buf, tail);
-			}
-		}
-
-		inline void AlignLoad(yistream* s, size_t size)
-		{
-			size_t tail = AlignUp(size, sizeof(size_t)) - size;
-			if (tail) {
-				char buf[sizeof(MaxSizeWord)];
-				LoadPodArray(s, buf, tail);
-			}
-		}
-		
-		template<class T>
-		inline void AlignedSaveArray(yostream* s, const T* array, size_t count)
-		{
-			SavePodArray(s, array, count);
-			AlignSave(s, sizeof(*array) * count);
-		}
-
-		template<class T>
-		inline void AlignedLoadArray(yistream* s, T* array, size_t count)
-		{
-			LoadPodArray(s, array, count);
-			AlignLoad(s, sizeof(*array) * count);
-		}
-
-		template<class T>
-		inline bool IsAligned(T t, size_t bound)
-		{
-			return ((size_t) t & (bound-1)) == 0;
-		}
-		
-		inline const void* AlignPtr(const size_t*& p, size_t& size)
-		{
-			if (!IsAligned(p, sizeof(size_t))) {
-				const size_t* next = AlignUp(p, sizeof(size_t));
-				if (next > p+size)
-					throw Error("EOF reached in NPire::Impl::align");
-				size -= (next - p);
-				p = next;
-			}
-			return (const void*) p;
-		}
-
-	}
-	
-}
-
-#endif
+#include "platform.h" 
+ 
+namespace Pire { 
+	 
+	namespace Impl { 
+ 
+		template<class T> 
+		inline T AlignUp(T t, size_t bound) 
+		{ 
+			return (T) (((size_t) t + (bound-1)) & ~(bound-1)); 
+		} 
+ 
+		template<class T> 
+		inline T AlignDown(T t, size_t bound) 
+		{ 
+			return (T) ((size_t) t & ~(bound-1)); 
+		} 
+		 
+		inline void AlignSave(yostream* s, size_t size) 
+		{ 
+			size_t tail = AlignUp(size, sizeof(size_t)) - size; 
+			if (tail) { 
+				static const char buf[sizeof(MaxSizeWord)] = {0}; 
+				SavePodArray(s, buf, tail); 
+			} 
+		} 
+ 
+		inline void AlignLoad(yistream* s, size_t size) 
+		{ 
+			size_t tail = AlignUp(size, sizeof(size_t)) - size; 
+			if (tail) { 
+				char buf[sizeof(MaxSizeWord)]; 
+				LoadPodArray(s, buf, tail); 
+			} 
+		} 
+		 
+		template<class T> 
+		inline void AlignedSaveArray(yostream* s, const T* array, size_t count) 
+		{ 
+			SavePodArray(s, array, count); 
+			AlignSave(s, sizeof(*array) * count); 
+		} 
+ 
+		template<class T> 
+		inline void AlignedLoadArray(yistream* s, T* array, size_t count) 
+		{ 
+			LoadPodArray(s, array, count); 
+			AlignLoad(s, sizeof(*array) * count); 
+		} 
+ 
+		template<class T> 
+		inline bool IsAligned(T t, size_t bound) 
+		{ 
+			return ((size_t) t & (bound-1)) == 0; 
+		} 
+		 
+		inline const void* AlignPtr(const size_t*& p, size_t& size) 
+		{ 
+			if (!IsAligned(p, sizeof(size_t))) { 
+				const size_t* next = AlignUp(p, sizeof(size_t)); 
+				if (next > p+size) 
+					throw Error("EOF reached in NPire::Impl::align"); 
+				size -= (next - p); 
+				p = next; 
+			} 
+			return (const void*) p; 
+		} 
+ 
+	} 
+	 
+} 
+ 
+#endif 

contrib/libs/pire/pire/any.h

@@ -1,131 +1,131 @@
-/*
- * any.h -- a wrapper capable of holding a value of arbitrary type.
- *
- * Copyright (c) 2007-2010, Dmitry Prokoptsev <dprokoptsev@gmail.com>,
- *                          Alexander Gololobov <agololobov@gmail.com>
- *
- * This file is part of Pire, the Perl Incompatible
- * Regular Expressions library.
- *
- * Pire is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
+/* 
+ * any.h -- a wrapper capable of holding a value of arbitrary type. 
  * 
- * Pire is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser Public License for more details.
- * You should have received a copy of the GNU Lesser Public License
- * along with Pire.  If not, see <http://www.gnu.org/licenses>.
- */
-
-
-#ifndef PIRE_ANY_H
-#define PIRE_ANY_H
-
-
-#include <typeinfo>
-
+ * Copyright (c) 2007-2010, Dmitry Prokoptsev <dprokoptsev@gmail.com>, 
+ *                          Alexander Gololobov <agololobov@gmail.com> 
+ * 
+ * This file is part of Pire, the Perl Incompatible 
+ * Regular Expressions library. 
+ * 
+ * Pire is free software: you can redistribute it and/or modify 
+ * it under the terms of the GNU Lesser Public License as published by 
+ * the Free Software Foundation, either version 3 of the License, or 
+ * (at your option) any later version. 
+ *  
+ * Pire is distributed in the hope that it will be useful, 
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of 
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
+ * GNU Lesser Public License for more details. 
+ * You should have received a copy of the GNU Lesser Public License 
+ * along with Pire.  If not, see <http://www.gnu.org/licenses>. 
+ */ 
+ 
+ 
+#ifndef PIRE_ANY_H 
+#define PIRE_ANY_H 
+ 
+ 
+#include <typeinfo> 
+ 
 #include <contrib/libs/pire/pire/stub/stl.h>
-
-namespace Pire {
-
-class Any {
-
-public:
+ 
+namespace Pire { 
+ 
+class Any { 
+ 
+public: 
 	Any() = default;
-
-	Any(const Any& any)
-	{
-		if (any.h)
-			h = any.h->Duplicate();
-	}
-
-	Any& operator= (Any any)
-	{
-		any.Swap(*this);
-		return *this;
-	}
-
-	template <class T>
-	Any(const T& t)
-		: h(new Holder<T>(t))
-	{
-	}
-
-	bool Empty() const {
-		return !h;
-	}
-	template <class T>
-	bool IsA() const {
-		return h && h->IsA(typeid(T));
-	}
-
-	template <class T>
-	T& As()
-	{
-		if (h && IsA<T>())
-			return *reinterpret_cast<T*>(h->Ptr());
-		else
-			throw Pire::Error("type mismatch");
-	}
-
-	template <class T>
-	const T& As() const
-	{
-		if (h && IsA<T>())
-			return *reinterpret_cast<const T*>(h->Ptr());
-		else
-			throw Pire::Error("type mismatch");
-	}
-
+ 
+	Any(const Any& any) 
+	{ 
+		if (any.h) 
+			h = any.h->Duplicate(); 
+	} 
+ 
+	Any& operator= (Any any) 
+	{ 
+		any.Swap(*this); 
+		return *this; 
+	} 
+ 
+	template <class T> 
+	Any(const T& t) 
+		: h(new Holder<T>(t)) 
+	{ 
+	} 
+ 
+	bool Empty() const { 
+		return !h; 
+	} 
+	template <class T> 
+	bool IsA() const { 
+		return h && h->IsA(typeid(T)); 
+	} 
+ 
+	template <class T> 
+	T& As() 
+	{ 
+		if (h && IsA<T>()) 
+			return *reinterpret_cast<T*>(h->Ptr()); 
+		else 
+			throw Pire::Error("type mismatch"); 
+	} 
+ 
+	template <class T> 
+	const T& As() const 
+	{ 
+		if (h && IsA<T>()) 
+			return *reinterpret_cast<const T*>(h->Ptr()); 
+		else 
+			throw Pire::Error("type mismatch"); 
+	} 
+ 
 	void Swap(Any& a) noexcept {
-		DoSwap(h, a.h);
-	}
-
-private:
-
-	struct AbstractHolder {
-		virtual ~AbstractHolder() {
-		}
+		DoSwap(h, a.h); 
+	} 
+ 
+private: 
+ 
+	struct AbstractHolder { 
+		virtual ~AbstractHolder() { 
+		} 
 		virtual THolder<AbstractHolder> Duplicate() const = 0;
-		virtual bool IsA(const std::type_info& id) const = 0;
-		virtual void* Ptr() = 0;
-		virtual const void* Ptr() const = 0;
-	};
-
-	template <class T>
-	struct Holder: public AbstractHolder {
-		Holder(T t)
-			: d(t)
-		{
-		}
+		virtual bool IsA(const std::type_info& id) const = 0; 
+		virtual void* Ptr() = 0; 
+		virtual const void* Ptr() const = 0; 
+	}; 
+ 
+	template <class T> 
+	struct Holder: public AbstractHolder { 
+		Holder(T t) 
+			: d(t) 
+		{ 
+		} 
 		THolder<AbstractHolder> Duplicate() const {
 			return THolder<AbstractHolder>(new Holder<T>(d));
-		}
-		bool IsA(const std::type_info& id) const {
-			return id == typeid(T);
-		}
-		void* Ptr() {
-			return &d;
-		}
-		const void* Ptr() const {
-			return &d;
-		}
-	private:
-		T d;
-	};
-
+		} 
+		bool IsA(const std::type_info& id) const { 
+			return id == typeid(T); 
+		} 
+		void* Ptr() { 
+			return &d; 
+		} 
+		const void* Ptr() const { 
+			return &d; 
+		} 
+	private: 
+		T d; 
+	}; 
+ 
 	THolder<AbstractHolder> h;
-};
-
-}
-
-namespace std {
-	inline void swap(Pire::Any& a, Pire::Any& b) {
-		a.Swap(b);
-	}
-}
-
-#endif
+}; 
+ 
+} 
+ 
+namespace std { 
+	inline void swap(Pire::Any& a, Pire::Any& b) { 
+		a.Swap(b); 
+	} 
+} 
+ 
+#endif 

contrib/libs/pire/pire/classes.cpp

@@ -1,152 +1,152 @@
-/*
- * classes.cpp -- implementation for Pire::CharClasses feature.
- *
- * Copyright (c) 2007-2010, Dmitry Prokoptsev <dprokoptsev@gmail.com>,
- *                          Alexander Gololobov <agololobov@gmail.com>
- *
- * This file is part of Pire, the Perl Incompatible
- * Regular Expressions library.
- *
- * Pire is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
+/* 
+ * classes.cpp -- implementation for Pire::CharClasses feature. 
  * 
- * Pire is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser Public License for more details.
- * You should have received a copy of the GNU Lesser Public License
- * along with Pire.  If not, see <http://www.gnu.org/licenses>.
- */
-
-
+ * Copyright (c) 2007-2010, Dmitry Prokoptsev <dprokoptsev@gmail.com>, 
+ *                          Alexander Gololobov <agololobov@gmail.com> 
+ * 
+ * This file is part of Pire, the Perl Incompatible 
+ * Regular Expressions library. 
+ * 
+ * Pire is free software: you can redistribute it and/or modify 
+ * it under the terms of the GNU Lesser Public License as published by 
+ * the Free Software Foundation, either version 3 of the License, or 
+ * (at your option) any later version. 
+ *  
+ * Pire is distributed in the hope that it will be useful, 
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of 
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
+ * GNU Lesser Public License for more details. 
+ * You should have received a copy of the GNU Lesser Public License 
+ * along with Pire.  If not, see <http://www.gnu.org/licenses>. 
+ */ 
+ 
+ 
 #include <contrib/libs/pire/pire/stub/stl.h>
 #include <contrib/libs/pire/pire/stub/singleton.h>
 #include <contrib/libs/pire/pire/stub/noncopyable.h>
 #include <contrib/libs/pire/pire/stub/utf8.h>
 
-#include "re_lexer.h"
-
-namespace Pire {
-
-namespace {
-
-	class CharClassesTable: private NonCopyable {
-	private:
-		class CharClass {
-		public:
-			CharClass() {}
-			explicit CharClass(wchar32 ch) { m_bounds.push_back(ymake_pair(ch, ch)); }
-			CharClass(wchar32 lower, wchar32 upper) { m_bounds.push_back(ymake_pair(lower, upper)); }
-
-			CharClass& operator |= (const CharClass& cc)
-			{
-				std::copy(cc.m_bounds.begin(), cc.m_bounds.end(), std::back_inserter(m_bounds));
-				return *this;
-			}
-
-			CharClass  operator |  (const CharClass& cc) const
-			{
-				CharClass r(*this);
-				r |= cc;
-				return r;
-			}
-
+#include "re_lexer.h" 
+ 
+namespace Pire { 
+ 
+namespace { 
+ 
+	class CharClassesTable: private NonCopyable { 
+	private: 
+		class CharClass { 
+		public: 
+			CharClass() {} 
+			explicit CharClass(wchar32 ch) { m_bounds.push_back(ymake_pair(ch, ch)); } 
+			CharClass(wchar32 lower, wchar32 upper) { m_bounds.push_back(ymake_pair(lower, upper)); } 
+ 
+			CharClass& operator |= (const CharClass& cc) 
+			{ 
+				std::copy(cc.m_bounds.begin(), cc.m_bounds.end(), std::back_inserter(m_bounds)); 
+				return *this; 
+			} 
+ 
+			CharClass  operator |  (const CharClass& cc) const 
+			{ 
+				CharClass r(*this); 
+				r |= cc; 
+				return r; 
+			} 
+ 
 			TSet<wchar32> ToSet() const
-			{
+			{ 
 				TSet<wchar32> ret;
 				for (auto&& bound : m_bounds)
 					for (wchar32 c = bound.first; c <= bound.second; ++c)
-						ret.insert(c);
-				return ret;
-			}
-
-		private:
+						ret.insert(c); 
+				return ret; 
+			} 
+ 
+		private: 
 			TVector<ypair<wchar32, wchar32> > m_bounds;
-		};
-
-	public:
-		bool Has(wchar32 wc) const
-		{
-			return (m_classes.find(to_lower(wc & ~ControlMask)) != m_classes.end());
-		}
-
+		}; 
+ 
+	public: 
+		bool Has(wchar32 wc) const 
+		{ 
+			return (m_classes.find(to_lower(wc & ~ControlMask)) != m_classes.end()); 
+		} 
+ 
 		TSet<wchar32> Get(wchar32 wc) const
-		{
+		{ 
 			auto it = m_classes.find(to_lower(wc & ~ControlMask));
-			if (it == m_classes.end())
-				throw Error("Unknown character class");
-			return it->second.ToSet();
-		}
-
-		CharClassesTable()
-		{
-			m_classes['l'] = CharClass('A', 'Z') | CharClass('a', 'z');
-			m_classes['c']
-				= CharClass(0x0410, 0x044F) // Russian capital A to Russan capital YA, Russian small A to Russian small YA
-				| CharClass(0x0401)         // Russian capital Yo
-				| CharClass(0x0451)         // Russian small Yo
-				;
-
-			m_classes['w'] = m_classes['l'] | m_classes['c'];
-			m_classes['d'] = CharClass('0', '9');
-			m_classes['s']
-				= CharClass(' ') | CharClass('\t') | CharClass('\r') | CharClass('\n')
-				| CharClass(0x00A0)         // Non-breaking space
-				;
-
-			// A few special classes which do not have any negation
-			m_classes['n'] = CharClass('\n');
-			m_classes['r'] = CharClass('\r');
-			m_classes['t'] = CharClass('\t');
-		}
-
+			if (it == m_classes.end()) 
+				throw Error("Unknown character class"); 
+			return it->second.ToSet(); 
+		} 
+ 
+		CharClassesTable() 
+		{ 
+			m_classes['l'] = CharClass('A', 'Z') | CharClass('a', 'z'); 
+			m_classes['c'] 
+				= CharClass(0x0410, 0x044F) // Russian capital A to Russan capital YA, Russian small A to Russian small YA 
+				| CharClass(0x0401)         // Russian capital Yo 
+				| CharClass(0x0451)         // Russian small Yo 
+				; 
+ 
+			m_classes['w'] = m_classes['l'] | m_classes['c']; 
+			m_classes['d'] = CharClass('0', '9'); 
+			m_classes['s'] 
+				= CharClass(' ') | CharClass('\t') | CharClass('\r') | CharClass('\n') 
+				| CharClass(0x00A0)         // Non-breaking space 
+				; 
+ 
+			// A few special classes which do not have any negation 
+			m_classes['n'] = CharClass('\n'); 
+			m_classes['r'] = CharClass('\r'); 
+			m_classes['t'] = CharClass('\t'); 
+		} 
+ 
 		TMap<wchar32, CharClass> m_classes;
-	};
-
-	class CharClassesImpl: public Feature {
-	public:
-		CharClassesImpl(): m_table(Singleton<CharClassesTable>()) {}
-		int Priority() const { return 10; }
-
-		void Alter(Term& t)
-		{
-			if (t.Value().IsA<Term::CharacterRange>()) {
-				const Term::CharacterRange& range = t.Value().As<Term::CharacterRange>();
-				typedef Term::CharacterRange::first_type CharSet;
-				const CharSet& old = range.first;
-				CharSet altered;
-				bool pos = false;
-				bool neg = false;
+	}; 
+ 
+	class CharClassesImpl: public Feature { 
+	public: 
+		CharClassesImpl(): m_table(Singleton<CharClassesTable>()) {} 
+		int Priority() const { return 10; } 
+ 
+		void Alter(Term& t) 
+		{ 
+			if (t.Value().IsA<Term::CharacterRange>()) { 
+				const Term::CharacterRange& range = t.Value().As<Term::CharacterRange>(); 
+				typedef Term::CharacterRange::first_type CharSet; 
+				const CharSet& old = range.first; 
+				CharSet altered; 
+				bool pos = false; 
+				bool neg = false; 
 				for (auto&& i : old)
 					if (i.size() == 1 && (i[0] & ControlMask) == Control && m_table->Has(i[0])) {
 						if (is_upper(i[0] & ~ControlMask))
-							neg = true;
-						else
-							pos = true;
-
+							neg = true; 
+						else 
+							pos = true; 
+ 
 						TSet<wchar32> klass = m_table->Get(i[0]);
 						for (auto&& j : klass)
 							altered.insert(Term::String(1, j));
-					} else
+					} else 
 						altered.insert(i);
-
-				if (neg && (pos || range.second))
-					Error("Positive and negative character ranges mixed");
-				t = Term(t.Type(), Term::CharacterRange(altered, neg || range.second));
-			}
-		}
-
-	private:
-		CharClassesTable* m_table;
-	};
-
-}
-
-namespace Features {
+ 
+				if (neg && (pos || range.second)) 
+					Error("Positive and negative character ranges mixed"); 
+				t = Term(t.Type(), Term::CharacterRange(altered, neg || range.second)); 
+			} 
+		} 
+ 
+	private: 
+		CharClassesTable* m_table; 
+	}; 
+ 
+} 
+ 
+namespace Features { 
 	Feature::Ptr CharClasses() { return Feature::Ptr(new CharClassesImpl); }
-}
-
-}
-
+} 
+ 
+} 
+ 

contrib/libs/pire/pire/defs.h

@@ -1,112 +1,112 @@
-/*
- * defs.h -- common Pire definitions.
- *
- * Copyright (c) 2007-2010, Dmitry Prokoptsev <dprokoptsev@gmail.com>,
- *                          Alexander Gololobov <agololobov@gmail.com>
- *
- * This file is part of Pire, the Perl Incompatible
- * Regular Expressions library.
- *
- * Pire is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Pire is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser Public License for more details.
- * You should have received a copy of the GNU Lesser Public License
- * along with Pire.  If not, see <http://www.gnu.org/licenses>.
- */
-
-
-#ifndef PIRE_DEFS_H
-#define PIRE_DEFS_H
-
-#ifndef PIRE_NO_CONFIG
-#include <pire/config.h>
-#endif
-#include <stdlib.h>
-
-#if defined(_MSC_VER)
-#define PIRE_HAVE_DECLSPEC_ALIGN
-#else
-#define PIRE_HAVE_ALIGNAS
-#endif
-
-#define PIRE_HAVE_LAMBDAS
-
-namespace Pire {
-
-#ifdef PIRE_DEBUG
-#	define PIRE_IFDEBUG(x) x
-#else
-#	define PIRE_IFDEBUG(x)
-#endif
-
-#ifdef PIRE_CHECKED
-#	define PIRE_IF_CHECKED(e) e
-#else
-#	define PIRE_IF_CHECKED(e)
-#endif
-
-
-	typedef unsigned short Char;
-
-	namespace SpecialChar {
-	enum {
-		Epsilon = 257,
-		BeginMark = 258,
-		EndMark = 259,
-
-		// Actual size of input alphabet
-		MaxCharUnaligned = 260,
-
-		// Size of letter transition tables, must be a multiple of the machine word size
-		MaxChar = (MaxCharUnaligned + (sizeof(void*)-1)) & ~(sizeof(void*)-1)
-	};
-	}
-
-	using namespace SpecialChar;
-
-	namespace Impl {
-#ifndef PIRE_WORDS_BIGENDIAN
-		inline size_t ToLittleEndian(size_t val) { return val; }
-#else
-		template<unsigned N>
-		inline size_t SwapBytes(size_t val)
-		{
-			static const size_t Mask = (1 << (N/2)) - 1;
-			return ((SwapBytes<N/2>(val) & Mask) << (N/2)) | SwapBytes<N/2>(val >> (N/2));
-		}
-
-		template<>
-		inline size_t SwapBytes<8>(size_t val) { return val & 0xFF; }
-
-		inline size_t ToLittleEndian(size_t val) { return SwapBytes<sizeof(val)*8>(val); }
-#endif
-
-        struct Struct { void* p; };
-	}
-}
-
-#ifndef PIRE_ALIGNED_DECL
-#	if defined(PIRE_HAVE_ALIGNAS)
-#		define PIRE_ALIGNED_DECL(x) alignas(::Pire::Impl::Struct) static const char x[]
-#	elif defined(PIRE_HAVE_ATTR_ALIGNED)
-#		define PIRE_ALIGNED_DECL(x) static const char x[] __attribute__((aligned(sizeof(void*))))
-#	elif defined(PIRE_HAVE_DECLSPEC_ALIGN)
-#		define PIRE_ALIGNED_DECL(x) __declspec(align(8)) static const char x[]
-#	endif
-#endif
-
-#ifndef PIRE_LITERAL
-#	if defined(PIRE_HAVE_LAMBDAS)
-#		define PIRE_LITERAL(data) ([]() -> const char* { PIRE_ALIGNED_DECL(__pire_regexp__) = data; return __pire_regexp__; })()
-#	elif defined(PIRE_HAVE_SCOPED_EXPR)
-#		define PIRE_LITERAL(data) ({ PIRE_ALIGNED_DECL(__pire_regexp__) = data; __pire_regexp__; })
-#	endif
-#endif
-
-#endif
+/* 
+ * defs.h -- common Pire definitions. 
+ * 
+ * Copyright (c) 2007-2010, Dmitry Prokoptsev <dprokoptsev@gmail.com>, 
+ *                          Alexander Gololobov <agololobov@gmail.com> 
+ * 
+ * This file is part of Pire, the Perl Incompatible 
+ * Regular Expressions library. 
+ * 
+ * Pire is free software: you can redistribute it and/or modify 
+ * it under the terms of the GNU Lesser Public License as published by 
+ * the Free Software Foundation, either version 3 of the License, or 
+ * (at your option) any later version. 
+ * 
+ * Pire is distributed in the hope that it will be useful, 
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of 
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
+ * GNU Lesser Public License for more details. 
+ * You should have received a copy of the GNU Lesser Public License 
+ * along with Pire.  If not, see <http://www.gnu.org/licenses>. 
+ */ 
+ 
+ 
+#ifndef PIRE_DEFS_H 
+#define PIRE_DEFS_H 
+ 
+#ifndef PIRE_NO_CONFIG 
+#include <pire/config.h> 
+#endif 
+#include <stdlib.h> 
+ 
+#if defined(_MSC_VER) 
+#define PIRE_HAVE_DECLSPEC_ALIGN 
+#else 
+#define PIRE_HAVE_ALIGNAS 
+#endif 
+ 
+#define PIRE_HAVE_LAMBDAS 
+ 
+namespace Pire { 
+ 
+#ifdef PIRE_DEBUG 
+#	define PIRE_IFDEBUG(x) x 
+#else 
+#	define PIRE_IFDEBUG(x) 
+#endif 
+ 
+#ifdef PIRE_CHECKED 
+#	define PIRE_IF_CHECKED(e) e 
+#else 
+#	define PIRE_IF_CHECKED(e) 
+#endif 
+ 
+ 
+	typedef unsigned short Char; 
+ 
+	namespace SpecialChar { 
+	enum { 
+		Epsilon = 257, 
+		BeginMark = 258, 
+		EndMark = 259, 
+ 
+		// Actual size of input alphabet 
+		MaxCharUnaligned = 260, 
+ 
+		// Size of letter transition tables, must be a multiple of the machine word size 
+		MaxChar = (MaxCharUnaligned + (sizeof(void*)-1)) & ~(sizeof(void*)-1) 
+	}; 
+	} 
+ 
+	using namespace SpecialChar; 
+ 
+	namespace Impl { 
+#ifndef PIRE_WORDS_BIGENDIAN 
+		inline size_t ToLittleEndian(size_t val) { return val; } 
+#else 
+		template<unsigned N> 
+		inline size_t SwapBytes(size_t val) 
+		{ 
+			static const size_t Mask = (1 << (N/2)) - 1; 
+			return ((SwapBytes<N/2>(val) & Mask) << (N/2)) | SwapBytes<N/2>(val >> (N/2)); 
+		} 
+ 
+		template<> 
+		inline size_t SwapBytes<8>(size_t val) { return val & 0xFF; } 
+ 
+		inline size_t ToLittleEndian(size_t val) { return SwapBytes<sizeof(val)*8>(val); } 
+#endif 
+ 
+        struct Struct { void* p; }; 
+	} 
+} 
+ 
+#ifndef PIRE_ALIGNED_DECL 
+#	if defined(PIRE_HAVE_ALIGNAS) 
+#		define PIRE_ALIGNED_DECL(x) alignas(::Pire::Impl::Struct) static const char x[] 
+#	elif defined(PIRE_HAVE_ATTR_ALIGNED) 
+#		define PIRE_ALIGNED_DECL(x) static const char x[] __attribute__((aligned(sizeof(void*)))) 
+#	elif defined(PIRE_HAVE_DECLSPEC_ALIGN) 
+#		define PIRE_ALIGNED_DECL(x) __declspec(align(8)) static const char x[] 
+#	endif 
+#endif 
+ 
+#ifndef PIRE_LITERAL 
+#	if defined(PIRE_HAVE_LAMBDAS) 
+#		define PIRE_LITERAL(data) ([]() -> const char* { PIRE_ALIGNED_DECL(__pire_regexp__) = data; return __pire_regexp__; })() 
+#	elif defined(PIRE_HAVE_SCOPED_EXPR) 
+#		define PIRE_LITERAL(data) ({ PIRE_ALIGNED_DECL(__pire_regexp__) = data; __pire_regexp__; }) 
+#	endif 
+#endif 
+ 
+#endif 

contrib/libs/pire/pire/determine.h

@@ -1,145 +1,145 @@
-/*
- * determine.h -- the FSM determination routine.
- *
- * Copyright (c) 2007-2010, Dmitry Prokoptsev <dprokoptsev@gmail.com>,
- *                          Alexander Gololobov <agololobov@gmail.com>
- *
- * This file is part of Pire, the Perl Incompatible
- * Regular Expressions library.
- *
- * Pire is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
+/* 
+ * determine.h -- the FSM determination routine. 
  * 
- * Pire is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser Public License for more details.
- * You should have received a copy of the GNU Lesser Public License
- * along with Pire.  If not, see <http://www.gnu.org/licenses>.
- */
-
-
-#ifndef PIRE_DETERMINE_H
-#define PIRE_DETERMINE_H
-
+ * Copyright (c) 2007-2010, Dmitry Prokoptsev <dprokoptsev@gmail.com>, 
+ *                          Alexander Gololobov <agololobov@gmail.com> 
+ * 
+ * This file is part of Pire, the Perl Incompatible 
+ * Regular Expressions library. 
+ * 
+ * Pire is free software: you can redistribute it and/or modify 
+ * it under the terms of the GNU Lesser Public License as published by 
+ * the Free Software Foundation, either version 3 of the License, or 
+ * (at your option) any later version. 
+ *  
+ * Pire is distributed in the hope that it will be useful, 
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of 
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
+ * GNU Lesser Public License for more details. 
+ * You should have received a copy of the GNU Lesser Public License 
+ * along with Pire.  If not, see <http://www.gnu.org/licenses>. 
+ */ 
+ 
+ 
+#ifndef PIRE_DETERMINE_H 
+#define PIRE_DETERMINE_H 
+ 
 #include <contrib/libs/pire/pire/stub/stl.h>
 
-#include "partition.h"
-
-namespace Pire {
-	namespace Impl {
-
-		/**
-		 * An interface of a determination task.
-		 * You don't have to derive from this class; it is just a start point template.
-		 */
-		class DetermineTask {
-		private:
-			struct ImplementationSpecific1;
-			struct ImplementationSpecific2;
-
-		public:
-			/// A type representing a new state (may be a set of old states, a pair of them, etc...)
-			typedef ImplementationSpecific1 State;
-
-			/// A type of letter equivalence classes table.
-			typedef Partition<char, ImplementationSpecific2> LettersTbl;
-
-			/// A container used for storing map of states to thier indices.
+#include "partition.h" 
+ 
+namespace Pire { 
+	namespace Impl { 
+ 
+		/** 
+		 * An interface of a determination task. 
+		 * You don't have to derive from this class; it is just a start point template. 
+		 */ 
+		class DetermineTask { 
+		private: 
+			struct ImplementationSpecific1; 
+			struct ImplementationSpecific2; 
+ 
+		public: 
+			/// A type representing a new state (may be a set of old states, a pair of them, etc...) 
+			typedef ImplementationSpecific1 State; 
+ 
+			/// A type of letter equivalence classes table. 
+			typedef Partition<char, ImplementationSpecific2> LettersTbl; 
+ 
+			/// A container used for storing map of states to thier indices. 
 			typedef TMap<State, size_t> InvStates;
-
-			/// Should return used letters' partition.
-			const LettersTbl& Letters() const;
-
-			/// Should return initial state (surprise!)
-			State Initial() const;
-
-			/// Should calculate next state, given the current state and a letter.
-			State Next(State state, Char letter) const;
-
-			/// Should return true iff the state need to be processed.
-			bool IsRequired(const State& /*state*/) const { return true; }
-
-			/// Called when the set of new states is closed.
+ 
+			/// Should return used letters' partition. 
+			const LettersTbl& Letters() const; 
+ 
+			/// Should return initial state (surprise!) 
+			State Initial() const; 
+ 
+			/// Should calculate next state, given the current state and a letter. 
+			State Next(State state, Char letter) const; 
+ 
+			/// Should return true iff the state need to be processed. 
+			bool IsRequired(const State& /*state*/) const { return true; } 
+ 
+			/// Called when the set of new states is closed. 
 			void AcceptStates(const TVector<State>& newstates);
-
-			/// Called for each transition from one new state to another.
-			void Connect(size_t from, size_t to, Char letter);
-
-			typedef bool Result;
-			Result Success() { return true; }
-			Result Failure() { return false; }
-		};
-
-		/**
-		 * A helper function for FSM determining and all determine-like algorithms
-		 * like scanners' agglutination.
-		 *
-		 * Given an indirectly specified automaton (through Task::Initial() and Task::Next()
-		 * functions, see above), performs a breadth-first traversal, finding and enumerating
-		 * all effectively reachable states. Then passes all found states and transitions
-		 * between them back to the task.
-		 *
-		 * Initial state is always placed at zero position.
-		 *
-		 * Please note that the function does not take care of any payload (including final flags);
-		 * it is the task's responsibility to agglutinate them properly.
-		 *
-		 * Returns task.Succeed() if everything was done; task.Failure() if maximum limit of state count was reached.
-		 */
-		template<class Task>
-		typename Task::Result Determine(Task& task, size_t maxSize)
-		{
-			typedef typename Task::State State;
-			typedef typename Task::InvStates InvStates;
+ 
+			/// Called for each transition from one new state to another. 
+			void Connect(size_t from, size_t to, Char letter); 
+ 
+			typedef bool Result; 
+			Result Success() { return true; } 
+			Result Failure() { return false; } 
+		}; 
+ 
+		/** 
+		 * A helper function for FSM determining and all determine-like algorithms 
+		 * like scanners' agglutination. 
+		 * 
+		 * Given an indirectly specified automaton (through Task::Initial() and Task::Next() 
+		 * functions, see above), performs a breadth-first traversal, finding and enumerating 
+		 * all effectively reachable states. Then passes all found states and transitions 
+		 * between them back to the task. 
+		 * 
+		 * Initial state is always placed at zero position. 
+		 * 
+		 * Please note that the function does not take care of any payload (including final flags); 
+		 * it is the task's responsibility to agglutinate them properly. 
+		 * 
+		 * Returns task.Succeed() if everything was done; task.Failure() if maximum limit of state count was reached. 
+		 */ 
+		template<class Task> 
+		typename Task::Result Determine(Task& task, size_t maxSize) 
+		{ 
+			typedef typename Task::State State; 
+			typedef typename Task::InvStates InvStates; 
 			typedef TDeque< TVector<size_t> > TransitionTable;
-
+ 
 			TVector<State> states;
-			InvStates invstates;
-			TransitionTable transitions;
+			InvStates invstates; 
+			TransitionTable transitions; 
 			TVector<size_t> stateIndices;
-
-			states.push_back(task.Initial());
-			invstates.insert(typename InvStates::value_type(states[0], 0));
-
-			for (size_t stateIdx = 0; stateIdx < states.size(); ++stateIdx) {
-				if (!task.IsRequired(states[stateIdx]))
-					continue;
-				TransitionTable::value_type row(task.Letters().Size());
+ 
+			states.push_back(task.Initial()); 
+			invstates.insert(typename InvStates::value_type(states[0], 0)); 
+ 
+			for (size_t stateIdx = 0; stateIdx < states.size(); ++stateIdx) { 
+				if (!task.IsRequired(states[stateIdx])) 
+					continue; 
+				TransitionTable::value_type row(task.Letters().Size()); 
 				for (auto&& letter : task.Letters()) {
 					State newState = task.Next(states[stateIdx], letter.first);
 					auto i = invstates.find(newState);
-					if (i == invstates.end()) {
-						if (!maxSize--)
-							return task.Failure();
-						i = invstates.insert(typename InvStates::value_type(newState, states.size())).first;
-						states.push_back(newState);
-					}
+					if (i == invstates.end()) { 
+						if (!maxSize--) 
+							return task.Failure(); 
+						i = invstates.insert(typename InvStates::value_type(newState, states.size())).first; 
+						states.push_back(newState); 
+					} 
 					row[letter.second.first] = i->second;
-				}
-				transitions.push_back(row);
-				stateIndices.push_back(stateIdx);
-			}
-
+				} 
+				transitions.push_back(row); 
+				stateIndices.push_back(stateIdx); 
+			} 
+ 
 			TVector<Char> invletters(task.Letters().Size());
 			for (auto&& letter : task.Letters())
 				invletters[letter.second.first] = letter.first;
-
-			task.AcceptStates(states);
-			size_t from = 0;
-			for (TransitionTable::iterator i = transitions.begin(), ie = transitions.end(); i != ie; ++i, ++from) {
+ 
+			task.AcceptStates(states); 
+			size_t from = 0; 
+			for (TransitionTable::iterator i = transitions.begin(), ie = transitions.end(); i != ie; ++i, ++from) { 
 				TVector<Char>::iterator l = invletters.begin();
-				for (TransitionTable::value_type::iterator j = i->begin(), je = i->end(); j != je; ++j, ++l)
-					task.Connect(stateIndices[from], *j, *l);
-			}
-			return task.Success();
-		}
+				for (TransitionTable::value_type::iterator j = i->begin(), je = i->end(); j != je; ++j, ++l) 
+					task.Connect(stateIndices[from], *j, *l); 
+			} 
+			return task.Success(); 
+		} 
 
 		// Faster transition table representation for determined FSM
 		typedef TVector<size_t> DeterminedTransitions;
-	}
-}
-
-#endif
+	} 
+} 
+ 
+#endif