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

1 files changed, 253 insertions, 253 deletions

diff --git a/contrib/libs/re2/util/rune.cc b/contrib/libs/re2/util/rune.cc
index 824656f776..4f625ea380 100644
--- a/contrib/libs/re2/util/rune.cc
+++ b/contrib/libs/re2/util/rune.cc
@@ -1,260 +1,260 @@
-/* 
- * The authors of this software are Rob Pike and Ken Thompson. 
- *              Copyright (c) 2002 by Lucent Technologies. 
- * Permission to use, copy, modify, and distribute this software for any 
- * purpose without fee is hereby granted, provided that this entire notice 
- * is included in all copies of any software which is or includes a copy 
- * or modification of this software and in all copies of the supporting 
- * documentation for such software. 
- * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED 
- * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY 
- * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY 
- * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE. 
- */ 
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
 
-#include <stdarg.h> 
-#include <string.h> 
+#include <stdarg.h>
+#include <string.h>
 
-#include "util/utf.h" 
- 
-namespace re2 { 
- 
-enum 
-{ 
-	Bit1	= 7, 
-	Bitx	= 6, 
-	Bit2	= 5, 
-	Bit3	= 4, 
-	Bit4	= 3, 
-	Bit5	= 2,  
- 
-	T1	= ((1<<(Bit1+1))-1) ^ 0xFF,	/* 0000 0000 */ 
-	Tx	= ((1<<(Bitx+1))-1) ^ 0xFF,	/* 1000 0000 */ 
-	T2	= ((1<<(Bit2+1))-1) ^ 0xFF,	/* 1100 0000 */ 
-	T3	= ((1<<(Bit3+1))-1) ^ 0xFF,	/* 1110 0000 */ 
-	T4	= ((1<<(Bit4+1))-1) ^ 0xFF,	/* 1111 0000 */ 
-	T5	= ((1<<(Bit5+1))-1) ^ 0xFF,	/* 1111 1000 */ 
- 
-	Rune1	= (1<<(Bit1+0*Bitx))-1,		/* 0000 0000 0111 1111 */ 
-	Rune2	= (1<<(Bit2+1*Bitx))-1,		/* 0000 0111 1111 1111 */ 
-	Rune3	= (1<<(Bit3+2*Bitx))-1,		/* 1111 1111 1111 1111 */ 
-	Rune4	= (1<<(Bit4+3*Bitx))-1, 
-                                        /* 0001 1111 1111 1111 1111 1111 */ 
- 
-	Maskx	= (1<<Bitx)-1,			/* 0011 1111 */ 
-	Testx	= Maskx ^ 0xFF,			/* 1100 0000 */ 
- 
-	Bad	= Runeerror, 
-}; 
- 
-int 
-chartorune(Rune *rune, const char *str) 
-{ 
-	int c, c1, c2, c3; 
-	long l; 
- 
-	/* 
-	 * one character sequence 
-	 *	00000-0007F => T1 
-	 */ 
-	c = *(unsigned char*)str; 
-	if(c < Tx) { 
-		*rune = c; 
-		return 1; 
-	} 
- 
-	/* 
-	 * two character sequence 
-	 *	0080-07FF => T2 Tx 
-	 */ 
-	c1 = *(unsigned char*)(str+1) ^ Tx; 
-	if(c1 & Testx) 
-		goto bad; 
-	if(c < T3) { 
-		if(c < T2) 
-			goto bad; 
-		l = ((c << Bitx) | c1) & Rune2; 
-		if(l <= Rune1) 
-			goto bad; 
-		*rune = l; 
-		return 2; 
-	} 
- 
-	/* 
-	 * three character sequence 
-	 *	0800-FFFF => T3 Tx Tx 
-	 */ 
-	c2 = *(unsigned char*)(str+2) ^ Tx; 
-	if(c2 & Testx) 
-		goto bad; 
-	if(c < T4) { 
-		l = ((((c << Bitx) | c1) << Bitx) | c2) & Rune3; 
-		if(l <= Rune2) 
-			goto bad; 
-		*rune = l; 
-		return 3; 
-	} 
- 
-	/* 
-	 * four character sequence (21-bit value) 
-	 *	10000-1FFFFF => T4 Tx Tx Tx 
-	 */ 
-	c3 = *(unsigned char*)(str+3) ^ Tx; 
-	if (c3 & Testx) 
-		goto bad; 
-	if (c < T5) { 
-		l = ((((((c << Bitx) | c1) << Bitx) | c2) << Bitx) | c3) & Rune4; 
-		if (l <= Rune3) 
-			goto bad; 
-		*rune = l; 
-		return 4; 
-	} 
- 
-	/* 
-	 * Support for 5-byte or longer UTF-8 would go here, but 
-	 * since we don't have that, we'll just fall through to bad. 
-	 */ 
- 
-	/* 
-	 * bad decoding 
-	 */ 
-bad: 
-	*rune = Bad; 
-	return 1; 
-} 
- 
-int 
-runetochar(char *str, const Rune *rune) 
-{ 
-	/* Runes are signed, so convert to unsigned for range check. */ 
-	unsigned long c; 
- 
-	/* 
-	 * one character sequence 
-	 *	00000-0007F => 00-7F 
-	 */ 
-	c = *rune; 
-	if(c <= Rune1) { 
+#include "util/utf.h"
+
+namespace re2 {
+
+enum
+{
+	Bit1	= 7,
+	Bitx	= 6,
+	Bit2	= 5,
+	Bit3	= 4,
+	Bit4	= 3,
+	Bit5	= 2, 
+
+	T1	= ((1<<(Bit1+1))-1) ^ 0xFF,	/* 0000 0000 */
+	Tx	= ((1<<(Bitx+1))-1) ^ 0xFF,	/* 1000 0000 */
+	T2	= ((1<<(Bit2+1))-1) ^ 0xFF,	/* 1100 0000 */
+	T3	= ((1<<(Bit3+1))-1) ^ 0xFF,	/* 1110 0000 */
+	T4	= ((1<<(Bit4+1))-1) ^ 0xFF,	/* 1111 0000 */
+	T5	= ((1<<(Bit5+1))-1) ^ 0xFF,	/* 1111 1000 */
+
+	Rune1	= (1<<(Bit1+0*Bitx))-1,		/* 0000 0000 0111 1111 */
+	Rune2	= (1<<(Bit2+1*Bitx))-1,		/* 0000 0111 1111 1111 */
+	Rune3	= (1<<(Bit3+2*Bitx))-1,		/* 1111 1111 1111 1111 */
+	Rune4	= (1<<(Bit4+3*Bitx))-1,
+                                        /* 0001 1111 1111 1111 1111 1111 */
+
+	Maskx	= (1<<Bitx)-1,			/* 0011 1111 */
+	Testx	= Maskx ^ 0xFF,			/* 1100 0000 */
+
+	Bad	= Runeerror,
+};
+
+int
+chartorune(Rune *rune, const char *str)
+{
+	int c, c1, c2, c3;
+	long l;
+
+	/*
+	 * one character sequence
+	 *	00000-0007F => T1
+	 */
+	c = *(unsigned char*)str;
+	if(c < Tx) {
+		*rune = c;
+		return 1;
+	}
+
+	/*
+	 * two character sequence
+	 *	0080-07FF => T2 Tx
+	 */
+	c1 = *(unsigned char*)(str+1) ^ Tx;
+	if(c1 & Testx)
+		goto bad;
+	if(c < T3) {
+		if(c < T2)
+			goto bad;
+		l = ((c << Bitx) | c1) & Rune2;
+		if(l <= Rune1)
+			goto bad;
+		*rune = l;
+		return 2;
+	}
+
+	/*
+	 * three character sequence
+	 *	0800-FFFF => T3 Tx Tx
+	 */
+	c2 = *(unsigned char*)(str+2) ^ Tx;
+	if(c2 & Testx)
+		goto bad;
+	if(c < T4) {
+		l = ((((c << Bitx) | c1) << Bitx) | c2) & Rune3;
+		if(l <= Rune2)
+			goto bad;
+		*rune = l;
+		return 3;
+	}
+
+	/*
+	 * four character sequence (21-bit value)
+	 *	10000-1FFFFF => T4 Tx Tx Tx
+	 */
+	c3 = *(unsigned char*)(str+3) ^ Tx;
+	if (c3 & Testx)
+		goto bad;
+	if (c < T5) {
+		l = ((((((c << Bitx) | c1) << Bitx) | c2) << Bitx) | c3) & Rune4;
+		if (l <= Rune3)
+			goto bad;
+		*rune = l;
+		return 4;
+	}
+
+	/*
+	 * Support for 5-byte or longer UTF-8 would go here, but
+	 * since we don't have that, we'll just fall through to bad.
+	 */
+
+	/*
+	 * bad decoding
+	 */
+bad:
+	*rune = Bad;
+	return 1;
+}
+
+int
+runetochar(char *str, const Rune *rune)
+{
+	/* Runes are signed, so convert to unsigned for range check. */
+	unsigned long c;
+
+	/*
+	 * one character sequence
+	 *	00000-0007F => 00-7F
+	 */
+	c = *rune;
+	if(c <= Rune1) {
 		str[0] = static_cast<char>(c);
-		return 1; 
-	} 
- 
-	/* 
-	 * two character sequence 
-	 *	0080-07FF => T2 Tx 
-	 */ 
-	if(c <= Rune2) { 
+		return 1;
+	}
+
+	/*
+	 * two character sequence
+	 *	0080-07FF => T2 Tx
+	 */
+	if(c <= Rune2) {
 		str[0] = T2 | static_cast<char>(c >> 1*Bitx);
-		str[1] = Tx | (c & Maskx); 
-		return 2; 
-	} 
- 
-	/* 
-	 * If the Rune is out of range, convert it to the error rune. 
-	 * Do this test here because the error rune encodes to three bytes. 
-	 * Doing it earlier would duplicate work, since an out of range 
-	 * Rune wouldn't have fit in one or two bytes. 
-	 */ 
-	if (c > Runemax) 
-		c = Runeerror; 
- 
-	/* 
-	 * three character sequence 
-	 *	0800-FFFF => T3 Tx Tx 
-	 */ 
-	if (c <= Rune3) { 
+		str[1] = Tx | (c & Maskx);
+		return 2;
+	}
+
+	/*
+	 * If the Rune is out of range, convert it to the error rune.
+	 * Do this test here because the error rune encodes to three bytes.
+	 * Doing it earlier would duplicate work, since an out of range
+	 * Rune wouldn't have fit in one or two bytes.
+	 */
+	if (c > Runemax)
+		c = Runeerror;
+
+	/*
+	 * three character sequence
+	 *	0800-FFFF => T3 Tx Tx
+	 */
+	if (c <= Rune3) {
 		str[0] = T3 | static_cast<char>(c >> 2*Bitx);
-		str[1] = Tx | ((c >> 1*Bitx) & Maskx); 
+		str[1] = Tx | ((c >> 1*Bitx) & Maskx);
 		str[2] = Tx | (c & Maskx);
-		return 3; 
-	} 
- 
-	/* 
-	 * four character sequence (21-bit value) 
-	 *     10000-1FFFFF => T4 Tx Tx Tx 
-	 */ 
+		return 3;
+	}
+
+	/*
+	 * four character sequence (21-bit value)
+	 *     10000-1FFFFF => T4 Tx Tx Tx
+	 */
 	str[0] = T4 | static_cast<char>(c >> 3*Bitx);
-	str[1] = Tx | ((c >> 2*Bitx) & Maskx); 
-	str[2] = Tx | ((c >> 1*Bitx) & Maskx); 
-	str[3] = Tx | (c & Maskx); 
-	return 4; 
-} 
- 
-int 
-runelen(Rune rune) 
-{ 
-	char str[10]; 
- 
-	return runetochar(str, &rune); 
-} 
- 
-int 
-fullrune(const char *str, int n) 
-{ 
-	if (n > 0) { 
-		int c = *(unsigned char*)str; 
-		if (c < Tx) 
-			return 1; 
-		if (n > 1) { 
-			if (c < T3) 
-				return 1; 
-			if (n > 2) { 
-				if (c < T4 || n > 3) 
-					return 1; 
-			} 
-		} 
-	} 
-	return 0; 
-} 
- 
- 
-int 
-utflen(const char *s) 
-{ 
-	int c; 
-	long n; 
-	Rune rune; 
- 
-	n = 0; 
-	for(;;) { 
-		c = *(unsigned char*)s; 
-		if(c < Runeself) { 
-			if(c == 0) 
-				return n; 
-			s++; 
-		} else 
-			s += chartorune(&rune, s); 
-		n++; 
-	} 
-	return 0; 
-} 
- 
-char* 
-utfrune(const char *s, Rune c) 
-{ 
-	long c1; 
-	Rune r; 
-	int n; 
- 
-	if(c < Runesync)		/* not part of utf sequence */ 
-		return strchr((char*)s, c); 
- 
-	for(;;) { 
-		c1 = *(unsigned char*)s; 
-		if(c1 < Runeself) {	/* one byte rune */ 
-			if(c1 == 0) 
-				return 0; 
-			if(c1 == c) 
-				return (char*)s; 
-			s++; 
-			continue; 
-		} 
-		n = chartorune(&r, s); 
-		if(r == c) 
-			return (char*)s; 
-		s += n; 
-	} 
-	return 0; 
-} 
- 
-}  // namespace re2 
+	str[1] = Tx | ((c >> 2*Bitx) & Maskx);
+	str[2] = Tx | ((c >> 1*Bitx) & Maskx);
+	str[3] = Tx | (c & Maskx);
+	return 4;
+}
+
+int
+runelen(Rune rune)
+{
+	char str[10];
+
+	return runetochar(str, &rune);
+}
+
+int
+fullrune(const char *str, int n)
+{
+	if (n > 0) {
+		int c = *(unsigned char*)str;
+		if (c < Tx)
+			return 1;
+		if (n > 1) {
+			if (c < T3)
+				return 1;
+			if (n > 2) {
+				if (c < T4 || n > 3)
+					return 1;
+			}
+		}
+	}
+	return 0;
+}
+
+
+int
+utflen(const char *s)
+{
+	int c;
+	long n;
+	Rune rune;
+
+	n = 0;
+	for(;;) {
+		c = *(unsigned char*)s;
+		if(c < Runeself) {
+			if(c == 0)
+				return n;
+			s++;
+		} else
+			s += chartorune(&rune, s);
+		n++;
+	}
+	return 0;
+}
+
+char*
+utfrune(const char *s, Rune c)
+{
+	long c1;
+	Rune r;
+	int n;
+
+	if(c < Runesync)		/* not part of utf sequence */
+		return strchr((char*)s, c);
+
+	for(;;) {
+		c1 = *(unsigned char*)s;
+		if(c1 < Runeself) {	/* one byte rune */
+			if(c1 == 0)
+				return 0;
+			if(c1 == c)
+				return (char*)s;
+			s++;
+			continue;
+		}
+		n = chartorune(&r, s);
+		if(r == c)
+			return (char*)s;
+		s += n;
+	}
+	return 0;
+}
+
+}  // namespace re2