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

1 files changed, 137 insertions, 137 deletions

diff --git a/contrib/libs/hyperscan/src/nfa/vermicelli.h b/contrib/libs/hyperscan/src/nfa/vermicelli.h
index 7b35deb8d6..ed797d83f9 100644
--- a/contrib/libs/hyperscan/src/nfa/vermicelli.h
+++ b/contrib/libs/hyperscan/src/nfa/vermicelli.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015-2020, Intel Corporation 
+ * Copyright (c) 2015-2020, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -46,20 +46,20 @@ const u8 *vermicelliExec(char c, char nocase, const u8 *buf,
                  nocase ? "nocase " : "", c, (size_t)(buf_end - buf));
     assert(buf < buf_end);
 
-    VERM_TYPE chars = VERM_SET_FN(c); /* nocase already uppercase */ 
- 
+    VERM_TYPE chars = VERM_SET_FN(c); /* nocase already uppercase */
+
     // Handle small scans.
-#ifdef HAVE_AVX512 
-    if (buf_end - buf <= VERM_BOUNDARY) { 
-        const u8 *ptr = nocase 
-                      ? vermMiniNocase(chars, buf, buf_end, 0) 
-                      : vermMini(chars, buf, buf_end, 0); 
-        if (ptr) { 
-            return ptr; 
-        } 
-        return buf_end; 
-    } 
-#else 
+#ifdef HAVE_AVX512
+    if (buf_end - buf <= VERM_BOUNDARY) {
+        const u8 *ptr = nocase
+                      ? vermMiniNocase(chars, buf, buf_end, 0)
+                      : vermMini(chars, buf, buf_end, 0);
+        if (ptr) {
+            return ptr;
+        }
+        return buf_end;
+    }
+#else
     if (buf_end - buf < VERM_BOUNDARY) {
         for (; buf < buf_end; buf++) {
             char cur = (char)*buf;
@@ -72,7 +72,7 @@ const u8 *vermicelliExec(char c, char nocase, const u8 *buf,
         }
         return buf;
     }
-#endif 
+#endif
 
     uintptr_t min = (uintptr_t)buf % VERM_BOUNDARY;
     if (min) {
@@ -112,20 +112,20 @@ const u8 *nvermicelliExec(char c, char nocase, const u8 *buf,
                  nocase ? "nocase " : "", c, (size_t)(buf_end - buf));
     assert(buf < buf_end);
 
-    VERM_TYPE chars = VERM_SET_FN(c); /* nocase already uppercase */ 
- 
+    VERM_TYPE chars = VERM_SET_FN(c); /* nocase already uppercase */
+
     // Handle small scans.
-#ifdef HAVE_AVX512 
-    if (buf_end - buf <= VERM_BOUNDARY) { 
-        const u8 *ptr = nocase 
-                      ? vermMiniNocase(chars, buf, buf_end, 1) 
-                      : vermMini(chars, buf, buf_end, 1); 
-        if (ptr) { 
-            return ptr; 
-        } 
-        return buf_end; 
-    } 
-#else 
+#ifdef HAVE_AVX512
+    if (buf_end - buf <= VERM_BOUNDARY) {
+        const u8 *ptr = nocase
+                      ? vermMiniNocase(chars, buf, buf_end, 1)
+                      : vermMini(chars, buf, buf_end, 1);
+        if (ptr) {
+            return ptr;
+        }
+        return buf_end;
+    }
+#else
     if (buf_end - buf < VERM_BOUNDARY) {
         for (; buf < buf_end; buf++) {
             char cur = (char)*buf;
@@ -138,7 +138,7 @@ const u8 *nvermicelliExec(char c, char nocase, const u8 *buf,
         }
         return buf;
     }
-#endif 
+#endif
 
     size_t min = (size_t)buf % VERM_BOUNDARY;
     if (min) {
@@ -179,28 +179,28 @@ const u8 *vermicelliDoubleExec(char c1, char c2, char nocase, const u8 *buf,
     VERM_TYPE chars1 = VERM_SET_FN(c1); /* nocase already uppercase */
     VERM_TYPE chars2 = VERM_SET_FN(c2); /* nocase already uppercase */
 
-#ifdef HAVE_AVX512 
-    if (buf_end - buf <= VERM_BOUNDARY) { 
-        const u8 *ptr = nocase 
-                      ? dvermMiniNocase(chars1, chars2, buf, buf_end) 
-                      : dvermMini(chars1, chars2, buf, buf_end); 
-        if (ptr) { 
-            return ptr; 
-        } 
- 
-        /* check for partial match at end */ 
-        u8 mask = nocase ? CASE_CLEAR : 0xff; 
-        if ((buf_end[-1] & mask) == (u8)c1) { 
-            DEBUG_PRINTF("partial!!!\n"); 
-            return buf_end - 1; 
-        } 
- 
-        return buf_end; 
-    } 
-#endif 
- 
-    assert((buf_end - buf) >= VERM_BOUNDARY); 
-    uintptr_t min = (uintptr_t)buf % VERM_BOUNDARY; 
+#ifdef HAVE_AVX512
+    if (buf_end - buf <= VERM_BOUNDARY) {
+        const u8 *ptr = nocase
+                      ? dvermMiniNocase(chars1, chars2, buf, buf_end)
+                      : dvermMini(chars1, chars2, buf, buf_end);
+        if (ptr) {
+            return ptr;
+        }
+
+        /* check for partial match at end */
+        u8 mask = nocase ? CASE_CLEAR : 0xff;
+        if ((buf_end[-1] & mask) == (u8)c1) {
+            DEBUG_PRINTF("partial!!!\n");
+            return buf_end - 1;
+        }
+
+        return buf_end;
+    }
+#endif
+
+    assert((buf_end - buf) >= VERM_BOUNDARY);
+    uintptr_t min = (uintptr_t)buf % VERM_BOUNDARY;
     if (min) {
         // Input isn't aligned, so we need to run one iteration with an
         // unaligned load, then skip buf forward to the next aligned address.
@@ -257,26 +257,26 @@ const u8 *vermicelliDoubleMaskedExec(char c1, char c2, char m1, char m2,
     VERM_TYPE mask1 = VERM_SET_FN(m1);
     VERM_TYPE mask2 = VERM_SET_FN(m2);
 
-#ifdef HAVE_AVX512 
-    if (buf_end - buf <= VERM_BOUNDARY) { 
-        const u8 *ptr = dvermMiniMasked(chars1, chars2, mask1, mask2, buf, 
-                                        buf_end); 
-        if (ptr) { 
-            return ptr; 
-        } 
- 
-        /* check for partial match at end */ 
-        if ((buf_end[-1] & m1) == (u8)c1) { 
-            DEBUG_PRINTF("partial!!!\n"); 
-            return buf_end - 1; 
-        } 
- 
-        return buf_end; 
-    } 
-#endif 
- 
-    assert((buf_end - buf) >= VERM_BOUNDARY); 
-    uintptr_t min = (uintptr_t)buf % VERM_BOUNDARY; 
+#ifdef HAVE_AVX512
+    if (buf_end - buf <= VERM_BOUNDARY) {
+        const u8 *ptr = dvermMiniMasked(chars1, chars2, mask1, mask2, buf,
+                                        buf_end);
+        if (ptr) {
+            return ptr;
+        }
+
+        /* check for partial match at end */
+        if ((buf_end[-1] & m1) == (u8)c1) {
+            DEBUG_PRINTF("partial!!!\n");
+            return buf_end - 1;
+        }
+
+        return buf_end;
+    }
+#endif
+
+    assert((buf_end - buf) >= VERM_BOUNDARY);
+    uintptr_t min = (uintptr_t)buf % VERM_BOUNDARY;
     if (min) {
         // Input isn't aligned, so we need to run one iteration with an
         // unaligned load, then skip buf forward to the next aligned address.
@@ -308,7 +308,7 @@ const u8 *vermicelliDoubleMaskedExec(char c1, char c2, char m1, char m2,
 
     /* check for partial match at end */
     if ((buf_end[-1] & m1) == (u8)c1) {
-        DEBUG_PRINTF("partial!!!\n"); 
+        DEBUG_PRINTF("partial!!!\n");
         return buf_end - 1;
     }
 
@@ -324,20 +324,20 @@ const u8 *rvermicelliExec(char c, char nocase, const u8 *buf,
                  nocase ? "nocase " : "", c, (size_t)(buf_end - buf));
     assert(buf < buf_end);
 
-    VERM_TYPE chars = VERM_SET_FN(c); /* nocase already uppercase */ 
- 
+    VERM_TYPE chars = VERM_SET_FN(c); /* nocase already uppercase */
+
     // Handle small scans.
-#ifdef HAVE_AVX512 
-    if (buf_end - buf <= VERM_BOUNDARY) { 
-        const u8 *ptr = nocase 
-                      ? rvermMiniNocase(chars, buf, buf_end, 0) 
-                      : rvermMini(chars, buf, buf_end, 0); 
-        if (ptr) { 
-            return ptr; 
-        } 
-        return buf - 1; 
-    } 
-#else 
+#ifdef HAVE_AVX512
+    if (buf_end - buf <= VERM_BOUNDARY) {
+        const u8 *ptr = nocase
+                      ? rvermMiniNocase(chars, buf, buf_end, 0)
+                      : rvermMini(chars, buf, buf_end, 0);
+        if (ptr) {
+            return ptr;
+        }
+        return buf - 1;
+    }
+#else
     if (buf_end - buf < VERM_BOUNDARY) {
         for (buf_end--; buf_end >= buf; buf_end--) {
             char cur = (char)*buf_end;
@@ -350,7 +350,7 @@ const u8 *rvermicelliExec(char c, char nocase, const u8 *buf,
         }
         return buf_end;
     }
-#endif 
+#endif
 
     size_t min = (size_t)buf_end % VERM_BOUNDARY;
     if (min) {
@@ -358,14 +358,14 @@ const u8 *rvermicelliExec(char c, char nocase, const u8 *buf,
         // unaligned load, then skip buf backward to the next aligned address.
         // There's some small overlap here, but we don't mind scanning it twice
         // if we can do it quickly, do we?
-        const u8 *ptr = nocase ? rvermUnalignNocase(chars, 
-                                                    buf_end - VERM_BOUNDARY, 
-                                                    0) 
-                               : rvermUnalign(chars, buf_end - VERM_BOUNDARY, 
-                                              0); 
- 
-        if (ptr) { 
-            return ptr; 
+        const u8 *ptr = nocase ? rvermUnalignNocase(chars,
+                                                    buf_end - VERM_BOUNDARY,
+                                                    0)
+                               : rvermUnalign(chars, buf_end - VERM_BOUNDARY,
+                                              0);
+
+        if (ptr) {
+            return ptr;
         }
 
         buf_end -= min;
@@ -396,20 +396,20 @@ const u8 *rnvermicelliExec(char c, char nocase, const u8 *buf,
                  nocase ? "nocase " : "", c, (size_t)(buf_end - buf));
     assert(buf < buf_end);
 
-    VERM_TYPE chars = VERM_SET_FN(c); /* nocase already uppercase */ 
- 
+    VERM_TYPE chars = VERM_SET_FN(c); /* nocase already uppercase */
+
     // Handle small scans.
-#ifdef HAVE_AVX512 
-    if (buf_end - buf <= VERM_BOUNDARY) { 
-        const u8 *ptr = nocase 
-                      ? rvermMiniNocase(chars, buf, buf_end, 1) 
-                      : rvermMini(chars, buf, buf_end, 1); 
-        if (ptr) { 
-            return ptr; 
-        } 
-        return buf - 1; 
-    } 
-#else 
+#ifdef HAVE_AVX512
+    if (buf_end - buf <= VERM_BOUNDARY) {
+        const u8 *ptr = nocase
+                      ? rvermMiniNocase(chars, buf, buf_end, 1)
+                      : rvermMini(chars, buf, buf_end, 1);
+        if (ptr) {
+            return ptr;
+        }
+        return buf - 1;
+    }
+#else
     if (buf_end - buf < VERM_BOUNDARY) {
         for (buf_end--; buf_end >= buf; buf_end--) {
             char cur = (char)*buf_end;
@@ -422,7 +422,7 @@ const u8 *rnvermicelliExec(char c, char nocase, const u8 *buf,
         }
         return buf_end;
     }
-#endif 
+#endif
 
     size_t min = (size_t)buf_end % VERM_BOUNDARY;
     if (min) {
@@ -430,14 +430,14 @@ const u8 *rnvermicelliExec(char c, char nocase, const u8 *buf,
         // unaligned load, then skip buf backward to the next aligned address.
         // There's some small overlap here, but we don't mind scanning it twice
         // if we can do it quickly, do we?
-        const u8 *ptr = nocase ? rvermUnalignNocase(chars, 
-                                                    buf_end - VERM_BOUNDARY, 
-                                                    1) 
-                               : rvermUnalign(chars, buf_end - VERM_BOUNDARY, 
-                                              1); 
- 
-        if (ptr) { 
-            return ptr; 
+        const u8 *ptr = nocase ? rvermUnalignNocase(chars,
+                                                    buf_end - VERM_BOUNDARY,
+                                                    1)
+                               : rvermUnalign(chars, buf_end - VERM_BOUNDARY,
+                                              1);
+
+        if (ptr) {
+            return ptr;
         }
 
         buf_end -= min;
@@ -470,32 +470,32 @@ const u8 *rvermicelliDoubleExec(char c1, char c2, char nocase, const u8 *buf,
     VERM_TYPE chars1 = VERM_SET_FN(c1); /* nocase already uppercase */
     VERM_TYPE chars2 = VERM_SET_FN(c2); /* nocase already uppercase */
 
-#ifdef HAVE_AVX512 
-    if (buf_end - buf <= VERM_BOUNDARY) { 
-        const u8 *ptr = nocase 
-                      ? rdvermMiniNocase(chars1, chars2, buf, buf_end) 
-                      : rdvermMini(chars1, chars2, buf, buf_end); 
- 
-        if (ptr) { 
-            return ptr; 
-        } 
- 
-        // check for partial match at end ??? 
-        return buf - 1; 
-    } 
-#endif 
- 
-    assert((buf_end - buf) >= VERM_BOUNDARY); 
-    size_t min = (size_t)buf_end % VERM_BOUNDARY; 
+#ifdef HAVE_AVX512
+    if (buf_end - buf <= VERM_BOUNDARY) {
+        const u8 *ptr = nocase
+                      ? rdvermMiniNocase(chars1, chars2, buf, buf_end)
+                      : rdvermMini(chars1, chars2, buf, buf_end);
+
+        if (ptr) {
+            return ptr;
+        }
+
+        // check for partial match at end ???
+        return buf - 1;
+    }
+#endif
+
+    assert((buf_end - buf) >= VERM_BOUNDARY);
+    size_t min = (size_t)buf_end % VERM_BOUNDARY;
     if (min) {
         // input not aligned, so we need to run one iteration with an unaligned
         // load, then skip buf forward to the next aligned address. There's
         // some small overlap here, but we don't mind scanning it twice if we
         // can do it quickly, do we?
-        const u8 *ptr = nocase ? rdvermPreconditionNocase(chars1, chars2, 
-                                                          buf_end - VERM_BOUNDARY) 
-                               : rdvermPrecondition(chars1, chars2, 
-                                                    buf_end - VERM_BOUNDARY); 
+        const u8 *ptr = nocase ? rdvermPreconditionNocase(chars1, chars2,
+                                                          buf_end - VERM_BOUNDARY)
+                               : rdvermPrecondition(chars1, chars2,
+                                                    buf_end - VERM_BOUNDARY);
 
         if (ptr) {
             return ptr;