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

1 files changed, 465 insertions, 465 deletions

diff --git a/contrib/libs/hyperscan/src/rose/rose_internal.h b/contrib/libs/hyperscan/src/rose/rose_internal.h
index 7bd6779c3d..dbbb43ee92 100644
--- a/contrib/libs/hyperscan/src/rose/rose_internal.h
+++ b/contrib/libs/hyperscan/src/rose/rose_internal.h
@@ -1,207 +1,207 @@
-/*
+/* 
  * Copyright (c) 2015-2019, Intel Corporation
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *  * Redistributions of source code must retain the above copyright notice,
- *    this list of conditions and the following disclaimer.
- *  * Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *  * Neither the name of Intel Corporation nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-
-/** \file
- * \brief Rose data structures.
- */
-
-#ifndef ROSE_INTERNAL_H
-#define ROSE_INTERNAL_H
-
-#include "ue2common.h"
-#include "rose_common.h"
-#include "util/scatter.h"
-
-#define ROSE_OFFSET_INVALID          0xffffffff
-
-// Group constants
-typedef u64a rose_group;
-
-// Delayed literal stuff
-#define DELAY_BITS                  5
-#define DELAY_SLOT_COUNT            (1U << DELAY_BITS)
-#define MAX_DELAY                   (DELAY_SLOT_COUNT - 1)
-#define DELAY_MASK                  (DELAY_SLOT_COUNT - 1)
-
-/* Allocation of Rose literal ids
- *
- * The rose literal id space is segmented:
- *
- * ---- 0
- * |  | 'Normal' undelayed literals in either e or f tables
- * |  |
- * |  |
- * |  |
- * ---- anchored_base_id
- * |  | literals from the a table
- * |  |
- * ---- delay_base_id
- * |  | Delayed version of normal literals
- * |  |
- * ---- literalCount
- */
-
-/* Rose Literal Sources
- *
+ * 
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions are met: 
+ * 
+ *  * Redistributions of source code must retain the above copyright notice, 
+ *    this list of conditions and the following disclaimer. 
+ *  * Redistributions in binary form must reproduce the above copyright 
+ *    notice, this list of conditions and the following disclaimer in the 
+ *    documentation and/or other materials provided with the distribution. 
+ *  * Neither the name of Intel Corporation nor the names of its contributors 
+ *    may be used to endorse or promote products derived from this software 
+ *    without specific prior written permission. 
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+ * POSSIBILITY OF SUCH DAMAGE. 
+ */ 
+ 
+/** \file 
+ * \brief Rose data structures. 
+ */ 
+ 
+#ifndef ROSE_INTERNAL_H 
+#define ROSE_INTERNAL_H 
+ 
+#include "ue2common.h" 
+#include "rose_common.h" 
+#include "util/scatter.h" 
+ 
+#define ROSE_OFFSET_INVALID          0xffffffff 
+ 
+// Group constants 
+typedef u64a rose_group; 
+ 
+// Delayed literal stuff 
+#define DELAY_BITS                  5 
+#define DELAY_SLOT_COUNT            (1U << DELAY_BITS) 
+#define MAX_DELAY                   (DELAY_SLOT_COUNT - 1) 
+#define DELAY_MASK                  (DELAY_SLOT_COUNT - 1) 
+ 
+/* Allocation of Rose literal ids 
+ * 
+ * The rose literal id space is segmented: 
+ * 
+ * ---- 0 
+ * |  | 'Normal' undelayed literals in either e or f tables 
+ * |  | 
+ * |  | 
+ * |  | 
+ * ---- anchored_base_id 
+ * |  | literals from the a table 
+ * |  | 
+ * ---- delay_base_id 
+ * |  | Delayed version of normal literals 
+ * |  | 
+ * ---- literalCount 
+ */ 
+ 
+/* Rose Literal Sources 
+ * 
  * Rose currently gets events (mainly roseProcessMatch calls) from a number of
  * sources:
- * 1) The floating table
- * 2) The anchored table
- * 3) Delayed literals
+ * 1) The floating table 
+ * 2) The anchored table 
+ * 3) Delayed literals 
  * 4) Suffix NFAs
  * 5) Literal masks
  * 5) End anchored table
  * 6) Prefix / Infix nfas
- *
- * Care is required to ensure that events appear to come into Rose in order
- * (or sufficiently ordered for Rose to cope). Generally the progress of the
- * floating table is considered the canonical position in the buffer.
- *
- * Anchored table:
- * The anchored table is run before the floating table as nothing in it can
- * depend on a floating literal. Order is achieved by two measures:
- * a) user matches^1 are logged and held until the floating matcher passes that
- *    point;
- * b) any floating role with an anchored predecessor has a history relationship
- *    to enforce the ordering.
- *
- * Delayed literals:
- * Delayed literal ordering is handled by delivering any pending delayed
- * literals before processing any floating match.
- *
- * Suffix:
- * Suffixes are always pure terminal roles. Prior to raising a match^2, pending
- * NFA queues are run to the current point (floating or delayed literal) as
- * appropriate.
- *
+ * 
+ * Care is required to ensure that events appear to come into Rose in order 
+ * (or sufficiently ordered for Rose to cope). Generally the progress of the 
+ * floating table is considered the canonical position in the buffer. 
+ * 
+ * Anchored table: 
+ * The anchored table is run before the floating table as nothing in it can 
+ * depend on a floating literal. Order is achieved by two measures: 
+ * a) user matches^1 are logged and held until the floating matcher passes that 
+ *    point; 
+ * b) any floating role with an anchored predecessor has a history relationship 
+ *    to enforce the ordering. 
+ * 
+ * Delayed literals: 
+ * Delayed literal ordering is handled by delivering any pending delayed 
+ * literals before processing any floating match. 
+ * 
+ * Suffix: 
+ * Suffixes are always pure terminal roles. Prior to raising a match^2, pending 
+ * NFA queues are run to the current point (floating or delayed literal) as 
+ * appropriate. 
+ * 
  * Literal Masks:
- * These are triggered from either floating literals or delayed literals and
- * inspect the data behind them. Matches are raised at the same location as the
- * trigger literal so there are no ordering issues. Masks are always pure
- * terminal roles.
- *
- * Lookaround:
- * These are tests run on receipt of a role that "look around" the match,
- * checking characters at nearby offsets against reachability masks. Each role
- * can have a list of these lookaround offset/reach pairs, ordered in offset
- * order, and any failure will prevent the role from being switched on. Offsets
- * are relative to the byte after a literal match, and can be negative.
- *
- * Prefix / Infix:
- * TODO: remember / discuss
- *
- * End anchored table:
- * All user matches occur at the last byte. We do this last, so no problems
- * (yippee)
- *
- * ^1 User matches which occur before any possible match from the other tables
- *    are not delayed.
- * ^2 Queues may also be run to the current location if a queue is full and
- *    needs to be emptied.
- * ^3 There is no need to catch up at the end of a block scan as it contains no
- *    terminals.
- */
-
-struct RoseCountingMiracle {
-    char shufti; /** 1: count shufti class; 0: count a single character */
-    u8 count; /** minimum number of occurrences for the counting
-               * miracle char to kill the leftfix. */
-    u8 c; /** character to look for if not shufti */
-    u8 poison; /** character not in the shufti mask */
-    m128 lo; /** shufti lo mask */
-    m128 hi; /** shufti hi mask */
-};
-
-struct LeftNfaInfo {
-    u32 maxQueueLen;
-    u32 maxLag; // maximum of successor roles' lag
-    u32 lagIndex; // iff lag != 0, index into leftfixLagTable
-    u32 stopTable; // stop table index, or ROSE_OFFSET_INVALID
-    u8 transient; /**< 0 if not transient, else max width of transient prefix */
-    char infix; /* TODO: make flags */
+ * These are triggered from either floating literals or delayed literals and 
+ * inspect the data behind them. Matches are raised at the same location as the 
+ * trigger literal so there are no ordering issues. Masks are always pure 
+ * terminal roles. 
+ * 
+ * Lookaround: 
+ * These are tests run on receipt of a role that "look around" the match, 
+ * checking characters at nearby offsets against reachability masks. Each role 
+ * can have a list of these lookaround offset/reach pairs, ordered in offset 
+ * order, and any failure will prevent the role from being switched on. Offsets 
+ * are relative to the byte after a literal match, and can be negative. 
+ * 
+ * Prefix / Infix: 
+ * TODO: remember / discuss 
+ * 
+ * End anchored table: 
+ * All user matches occur at the last byte. We do this last, so no problems 
+ * (yippee) 
+ * 
+ * ^1 User matches which occur before any possible match from the other tables 
+ *    are not delayed. 
+ * ^2 Queues may also be run to the current location if a queue is full and 
+ *    needs to be emptied. 
+ * ^3 There is no need to catch up at the end of a block scan as it contains no 
+ *    terminals. 
+ */ 
+ 
+struct RoseCountingMiracle { 
+    char shufti; /** 1: count shufti class; 0: count a single character */ 
+    u8 count; /** minimum number of occurrences for the counting 
+               * miracle char to kill the leftfix. */ 
+    u8 c; /** character to look for if not shufti */ 
+    u8 poison; /** character not in the shufti mask */ 
+    m128 lo; /** shufti lo mask */ 
+    m128 hi; /** shufti hi mask */ 
+}; 
+ 
+struct LeftNfaInfo { 
+    u32 maxQueueLen; 
+    u32 maxLag; // maximum of successor roles' lag 
+    u32 lagIndex; // iff lag != 0, index into leftfixLagTable 
+    u32 stopTable; // stop table index, or ROSE_OFFSET_INVALID 
+    u8 transient; /**< 0 if not transient, else max width of transient prefix */ 
+    char infix; /* TODO: make flags */ 
     char eager; /**< nfa should be run eagerly to first match or death */
-    char eod_check; /**< nfa is used by the event eod literal */
-    u32 countingMiracleOffset; /** if not 0, offset to RoseCountingMiracle. */
-    rose_group squash_mask; /* & mask applied when rose nfa dies */
-};
-
-struct NfaInfo {
-    u32 nfaOffset;
-    u32 stateOffset;
-    u32 fullStateOffset; /* offset in scratch, relative to ??? */
-    u32 ekeyListOffset; /* suffix, relative to base of rose, 0 if no ekeys */
-    u8 no_retrigger; /* TODO */
-    u8 in_sbmatcher;  /**< this outfix should not be run in small-block
-                       * execution, as it will be handled by the sbmatcher
-                       * HWLM table. */
-    u8 eod; /* suffix is triggered by the etable --> can only produce eod
-             * matches */
-};
-
-#define MAX_STORED_LEFTFIX_LAG 127 /* max leftfix lag that we can store in one
-                                    * whole byte (OWB) (streaming only). Other
-                                    * values in OWB are reserved for zombie
-                                    * status */
-#define OWB_ZOMBIE_ALWAYS_YES 128 /* nfa will always answer yes to any rose
-                                   * prefix checks */
-
+    char eod_check; /**< nfa is used by the event eod literal */ 
+    u32 countingMiracleOffset; /** if not 0, offset to RoseCountingMiracle. */ 
+    rose_group squash_mask; /* & mask applied when rose nfa dies */ 
+}; 
+ 
+struct NfaInfo { 
+    u32 nfaOffset; 
+    u32 stateOffset; 
+    u32 fullStateOffset; /* offset in scratch, relative to ??? */ 
+    u32 ekeyListOffset; /* suffix, relative to base of rose, 0 if no ekeys */ 
+    u8 no_retrigger; /* TODO */ 
+    u8 in_sbmatcher;  /**< this outfix should not be run in small-block 
+                       * execution, as it will be handled by the sbmatcher 
+                       * HWLM table. */ 
+    u8 eod; /* suffix is triggered by the etable --> can only produce eod 
+             * matches */ 
+}; 
+ 
+#define MAX_STORED_LEFTFIX_LAG 127 /* max leftfix lag that we can store in one 
+                                    * whole byte (OWB) (streaming only). Other 
+                                    * values in OWB are reserved for zombie 
+                                    * status */ 
+#define OWB_ZOMBIE_ALWAYS_YES 128 /* nfa will always answer yes to any rose 
+                                   * prefix checks */ 
+ 
 /* offset of the status flags in the stream state. */
 #define ROSE_STATE_OFFSET_STATUS_FLAGS 0
-
+ 
 /* offset of role mmbit in stream state (just after the status flag byte). */
 #define ROSE_STATE_OFFSET_ROLE_MMBIT   sizeof(u8)
-
-/**
- * \brief Rose state offsets.
- *
- * Stores pre-calculated offsets (in bytes) to MOST of the state structures
- * used by Rose, relative to the start of stream state.
- *
- * State not covered by this structure includes:
- *
+ 
+/** 
+ * \brief Rose state offsets. 
+ * 
+ * Stores pre-calculated offsets (in bytes) to MOST of the state structures 
+ * used by Rose, relative to the start of stream state. 
+ * 
+ * State not covered by this structure includes: 
+ * 
  * -# the first byte, containing the status bitmask
- * -# the role state multibit
- */
-struct RoseStateOffsets {
-    /** History buffer.
-     *
+ * -# the role state multibit 
+ */ 
+struct RoseStateOffsets { 
+    /** History buffer. 
+     * 
      * Max size of history is RoseEngine::historyRequired. */
-    u32 history;
-
+    u32 history; 
+ 
     /** Exhausted multibit.
-     *
+     * 
      * entry per exhaustible key (used by Highlander mode). If a bit is set,
-     * reports with that ekey should not be delivered to the user. */
-    u32 exhausted;
-
+     * reports with that ekey should not be delivered to the user. */ 
+    u32 exhausted; 
+ 
     /** size in bytes of exhausted multibit */
     u32 exhausted_size;
-
+ 
     /** Logical multibit.
      *
      * entry per logical key(operand/operator) (used by Logical Combination). */
@@ -218,46 +218,46 @@ struct RoseStateOffsets {
     /** size in bytes of combination multibit */
     u32 combVec_size;
 
-    /** Multibit for active suffix/outfix engines. */
-    u32 activeLeafArray;
-
+    /** Multibit for active suffix/outfix engines. */ 
+    u32 activeLeafArray; 
+ 
     /** Size of multibit for active suffix/outfix engines in bytes. */
     u32 activeLeafArray_size;
 
     /** Multibit for active leftfix (prefix/infix) engines. */
-    u32 activeLeftArray;
-
+    u32 activeLeftArray; 
+ 
     /** Size of multibit for active leftfix (prefix/infix) engines in bytes. */
-    u32 activeLeftArray_size;
-
-    /** Table of lag information (stored as one byte per engine) for active
-     * Rose leftfix engines. */
-    u32 leftfixLagTable;
-
-    /** State for anchored matchers (McClellan DFAs). */
-    u32 anchorState;
-
-    /** Packed Rose groups value. */
-    u32 groups;
-
-    /** Size of packed Rose groups value, in bytes. */
-    u32 groups_size;
-
+    u32 activeLeftArray_size; 
+ 
+    /** Table of lag information (stored as one byte per engine) for active 
+     * Rose leftfix engines. */ 
+    u32 leftfixLagTable; 
+ 
+    /** State for anchored matchers (McClellan DFAs). */ 
+    u32 anchorState; 
+ 
+    /** Packed Rose groups value. */ 
+    u32 groups; 
+ 
+    /** Size of packed Rose groups value, in bytes. */ 
+    u32 groups_size; 
+ 
     /** State for long literal support. */
     u32 longLitState;
-
+ 
     /** Size of the long literal state. */
     u32 longLitState_size;
 
-    /** Packed SOM location slots. */
-    u32 somLocation;
-
-    /** Multibit guarding SOM location slots. */
-    u32 somValid;
-
-    /** Multibit guarding SOM location slots. */
-    u32 somWritable;
-
+    /** Packed SOM location slots. */ 
+    u32 somLocation; 
+ 
+    /** Multibit guarding SOM location slots. */ 
+    u32 somValid; 
+ 
+    /** Multibit guarding SOM location slots. */ 
+    u32 somWritable; 
+ 
     /** Size of each of the somValid and somWritable multibits, in bytes. */
     u32 somMultibit_size;
 
@@ -265,11 +265,11 @@ struct RoseStateOffsets {
      * The NFA state region extends to end. */
     u32 nfaStateBegin;
 
-    /** Total size of Rose state, in bytes. */
-    u32 end;
-};
-
-struct RoseBoundaryReports {
+    /** Total size of Rose state, in bytes. */ 
+    u32 end; 
+}; 
+ 
+struct RoseBoundaryReports { 
     /** \brief 0 if no reports list, otherwise offset of program to run to
      * deliver reports at EOD. */
     u32 reportEodOffset;
@@ -281,35 +281,35 @@ struct RoseBoundaryReports {
     /** \brief 0 if no reports list, otherwise offset of program to run to
      * deliver reports if EOD is at offset 0. Superset of other programs. */
     u32 reportZeroEodOffset;
-};
-
-/* NFA Queue Assignment
- *
- * --- 0
- * (|) chained mpv (if present)
- *  #
- * --- outfixBeginQueue -
- *  | outfixes. enabled at offset 0.
- *  |
- *  #
- * --- outfixEndQueue -
- *  | suffixes. enabled by rose roles.
- *  |
- *  #
- * --- leftfixBeginQueue -
- *  | prefixes
- *  |
- *  #
- * --- ?
- *  | infixes
- *  |
- *  #
- */
-
-#define ROSE_RUNTIME_FULL_ROSE     0
-#define ROSE_RUNTIME_PURE_LITERAL  1
-#define ROSE_RUNTIME_SINGLE_OUTFIX 2
-
+}; 
+ 
+/* NFA Queue Assignment 
+ * 
+ * --- 0 
+ * (|) chained mpv (if present) 
+ *  # 
+ * --- outfixBeginQueue - 
+ *  | outfixes. enabled at offset 0. 
+ *  | 
+ *  # 
+ * --- outfixEndQueue - 
+ *  | suffixes. enabled by rose roles. 
+ *  | 
+ *  # 
+ * --- leftfixBeginQueue - 
+ *  | prefixes 
+ *  | 
+ *  # 
+ * --- ? 
+ *  | infixes 
+ *  | 
+ *  # 
+ */ 
+ 
+#define ROSE_RUNTIME_FULL_ROSE     0 
+#define ROSE_RUNTIME_PURE_LITERAL  1 
+#define ROSE_RUNTIME_SINGLE_OUTFIX 2 
+ 
 /**
  * \brief Runtime structure header for Rose.
  *
@@ -323,67 +323,67 @@ struct RoseBoundaryReports {
  *   -# array of NFA offsets, one per queue
  *   -# array of state offsets, one per queue (+)
  *
- *  (+) stateOffset array note: Offsets in the array are either into the stream
- *  state (normal case) or into the tstate region of scratch (for transient rose
- *  nfas). Rose nfa info table can distinguish the cases.
- */
-struct RoseEngine {
+ *  (+) stateOffset array note: Offsets in the array are either into the stream 
+ *  state (normal case) or into the tstate region of scratch (for transient rose 
+ *  nfas). Rose nfa info table can distinguish the cases. 
+ */ 
+struct RoseEngine { 
     u8  pureLiteral; /* Indicator of pure literal API */
-    u8  noFloatingRoots; /* only need to run the anchored table if something
-                          * matched in the anchored table */
-    u8  requiresEodCheck; /* stuff happens at eod time */
-    u8  hasOutfixesInSmallBlock; /**< has at least one outfix that must run even
-                                    in small block scans. */
-    u8  runtimeImpl; /**< can we just run the floating table or a single outfix?
-                      * or do we need a full rose? */
-    u8  mpvTriggeredByLeaf; /**< need to check (suf|out)fixes for mpv trigger */
-    u8  canExhaust; /**< every pattern has an exhaustion key */
-    u8  hasSom; /**< has at least one pattern which tracks SOM. */
-    u8  somHorizon; /**< width in bytes of SOM offset storage (governed by
-                        SOM precision) */
-    u32 mode; /**< scanning mode, one of HS_MODE_{BLOCK,STREAM,VECTORED} */
-    u32 historyRequired; /**< max amount of history required for streaming */
-    u32 ekeyCount; /**< number of exhaustion keys */
+    u8  noFloatingRoots; /* only need to run the anchored table if something 
+                          * matched in the anchored table */ 
+    u8  requiresEodCheck; /* stuff happens at eod time */ 
+    u8  hasOutfixesInSmallBlock; /**< has at least one outfix that must run even 
+                                    in small block scans. */ 
+    u8  runtimeImpl; /**< can we just run the floating table or a single outfix? 
+                      * or do we need a full rose? */ 
+    u8  mpvTriggeredByLeaf; /**< need to check (suf|out)fixes for mpv trigger */ 
+    u8  canExhaust; /**< every pattern has an exhaustion key */ 
+    u8  hasSom; /**< has at least one pattern which tracks SOM. */ 
+    u8  somHorizon; /**< width in bytes of SOM offset storage (governed by 
+                        SOM precision) */ 
+    u32 mode; /**< scanning mode, one of HS_MODE_{BLOCK,STREAM,VECTORED} */ 
+    u32 historyRequired; /**< max amount of history required for streaming */ 
+    u32 ekeyCount; /**< number of exhaustion keys */ 
     u32 lkeyCount; /**< number of logical keys */
     u32 lopCount; /**< number of logical ops */
     u32 ckeyCount; /**< number of combination keys */
     u32 logicalTreeOffset; /**< offset to mapping from lkey to LogicalOp */
     u32 combInfoMapOffset; /**< offset to mapping from ckey to combInfo */
-    u32 dkeyCount; /**< number of dedupe keys */
+    u32 dkeyCount; /**< number of dedupe keys */ 
     u32 dkeyLogSize; /**< size of fatbit for storing dkey log (bytes) */
-    u32 invDkeyOffset; /**< offset to table mapping from dkeys to the external
-                         *  report ids */
-    u32 somLocationCount; /**< number of som locations required */
+    u32 invDkeyOffset; /**< offset to table mapping from dkeys to the external 
+                         *  report ids */ 
+    u32 somLocationCount; /**< number of som locations required */ 
     u32 somLocationFatbitSize; /**< size of SOM location fatbit (bytes) */
-    u32 rolesWithStateCount; // number of roles with entries in state bitset
-    u32 stateSize; /* size of the state bitset
-                    * WARNING: not the size of the rose state */
-    u32 anchorStateSize; /* size of the state for the anchor dfas */
-    u32 tStateSize; /* total size of the state for transient rose nfas */
-    u32 scratchStateSize; /**< uncompressed state req'd for NFAs in scratch;
-                           * used for sizing scratch only. */
-    u32 smallWriteOffset; /**< offset of small-write matcher */
-    u32 amatcherOffset; // offset of the anchored literal matcher (bytes)
-    u32 ematcherOffset; // offset of the eod-anchored literal matcher (bytes)
-    u32 fmatcherOffset; // offset of the floating literal matcher (bytes)
+    u32 rolesWithStateCount; // number of roles with entries in state bitset 
+    u32 stateSize; /* size of the state bitset 
+                    * WARNING: not the size of the rose state */ 
+    u32 anchorStateSize; /* size of the state for the anchor dfas */ 
+    u32 tStateSize; /* total size of the state for transient rose nfas */ 
+    u32 scratchStateSize; /**< uncompressed state req'd for NFAs in scratch; 
+                           * used for sizing scratch only. */ 
+    u32 smallWriteOffset; /**< offset of small-write matcher */ 
+    u32 amatcherOffset; // offset of the anchored literal matcher (bytes) 
+    u32 ematcherOffset; // offset of the eod-anchored literal matcher (bytes) 
+    u32 fmatcherOffset; // offset of the floating literal matcher (bytes) 
     u32 drmatcherOffset; // offset of the delayed rebuild table (bytes)
-    u32 sbmatcherOffset; // offset of the small-block literal matcher (bytes)
+    u32 sbmatcherOffset; // offset of the small-block literal matcher (bytes) 
     u32 longLitTableOffset; // offset of the long literal table
-    u32 amatcherMinWidth; /**< minimum number of bytes required for a pattern
-                           * involved with the anchored table to produce a full
-                           * match. */
-    u32 fmatcherMinWidth; /**< minimum number of bytes required for a pattern
-                           * involved with the floating table to produce a full
-                           * match. */
-    u32 eodmatcherMinWidth; /**< minimum number of bytes required for a pattern
-                               * involved with the eod table to produce a full
-                               * match. */
-    u32 amatcherMaxBiAnchoredWidth; /**< maximum number of bytes that can still
-                                     * produce a match for a pattern involved
-                                     * with the anchored table. */
-    u32 fmatcherMaxBiAnchoredWidth; /**< maximum number of bytes that can still
-                                     * produce a match for a pattern involved
-                                     * with the anchored table. */
+    u32 amatcherMinWidth; /**< minimum number of bytes required for a pattern 
+                           * involved with the anchored table to produce a full 
+                           * match. */ 
+    u32 fmatcherMinWidth; /**< minimum number of bytes required for a pattern 
+                           * involved with the floating table to produce a full 
+                           * match. */ 
+    u32 eodmatcherMinWidth; /**< minimum number of bytes required for a pattern 
+                               * involved with the eod table to produce a full 
+                               * match. */ 
+    u32 amatcherMaxBiAnchoredWidth; /**< maximum number of bytes that can still 
+                                     * produce a match for a pattern involved 
+                                     * with the anchored table. */ 
+    u32 fmatcherMaxBiAnchoredWidth; /**< maximum number of bytes that can still 
+                                     * produce a match for a pattern involved 
+                                     * with the anchored table. */ 
 
     /**
      * \brief Offset of u32 array of program offsets for reports used by
@@ -407,11 +407,11 @@ struct RoseEngine {
      */
     u32 anchoredProgramOffset;
 
-    u32 activeArrayCount; //number of nfas tracked in the active array
-    u32 activeLeftCount; //number of nfas tracked in the active rose array
-    u32 queueCount;      /**< number of nfa queues */
+    u32 activeArrayCount; //number of nfas tracked in the active array 
+    u32 activeLeftCount; //number of nfas tracked in the active rose array 
+    u32 queueCount;      /**< number of nfa queues */ 
     u32 activeQueueArraySize; //!< size of fatbit for active queues (bytes)
-
+ 
     u32 eagerIterOffset; /**< offset to sparse iter for eager prefixes or 0 if
                           * none */
 
@@ -422,72 +422,72 @@ struct RoseEngine {
     /** \brief Size of the handled keys fatbit in scratch (bytes). */
     u32 handledKeyFatbitSize;
 
-    u32 leftOffset;
-    u32 roseCount;
-
+    u32 leftOffset; 
+    u32 roseCount; 
+ 
     u32 eodProgramOffset; //!< EOD program, otherwise 0.
     u32 flushCombProgramOffset; /**< FlushCombination program, otherwise 0 */
     u32 lastFlushCombProgramOffset; /**< LastFlushCombination program,
                                      * otherwise 0 */
-
-    u32 lastByteHistoryIterOffset; // if non-zero
-
-    /** \brief Minimum number of bytes required to match. */
-    u32 minWidth;
-
-    /** \brief Minimum number of bytes required to match, excluding boundary
-     * reports. */
-    u32 minWidthExcludingBoundaries;
-
-    u32 maxBiAnchoredWidth; /* ROSE_BOUND_INF if any non bianchored patterns
-                             * present */
-    u32 anchoredDistance; // region to run the anchored table over
-    u32 anchoredMinDistance; /* start of region to run anchored table over */
-    u32 floatingDistance; /* end of region to run the floating table over
-                             ROSE_BOUND_INF if not bounded */
-    u32 floatingMinDistance; /* start of region to run floating table over */
-    u32 smallBlockDistance; /* end of region to run the floating table over
-                               ROSE_BOUND_INF if not bounded */
-    u32 floatingMinLiteralMatchOffset; /* the minimum offset that we can get a
-                                        * 'valid' match from the floating
-                                        * table */
-    u32 nfaInfoOffset; /* offset to the nfa info offset array */
-    rose_group initialGroups;
+ 
+    u32 lastByteHistoryIterOffset; // if non-zero 
+ 
+    /** \brief Minimum number of bytes required to match. */ 
+    u32 minWidth; 
+ 
+    /** \brief Minimum number of bytes required to match, excluding boundary 
+     * reports. */ 
+    u32 minWidthExcludingBoundaries; 
+ 
+    u32 maxBiAnchoredWidth; /* ROSE_BOUND_INF if any non bianchored patterns 
+                             * present */ 
+    u32 anchoredDistance; // region to run the anchored table over 
+    u32 anchoredMinDistance; /* start of region to run anchored table over */ 
+    u32 floatingDistance; /* end of region to run the floating table over 
+                             ROSE_BOUND_INF if not bounded */ 
+    u32 floatingMinDistance; /* start of region to run floating table over */ 
+    u32 smallBlockDistance; /* end of region to run the floating table over 
+                               ROSE_BOUND_INF if not bounded */ 
+    u32 floatingMinLiteralMatchOffset; /* the minimum offset that we can get a 
+                                        * 'valid' match from the floating 
+                                        * table */ 
+    u32 nfaInfoOffset; /* offset to the nfa info offset array */ 
+    rose_group initialGroups; 
     rose_group floating_group_mask; /* groups that are used by the ftable */
-    u32 size; // (bytes)
-    u32 delay_count; /* number of delayed literal ids. */
+    u32 size; // (bytes) 
+    u32 delay_count; /* number of delayed literal ids. */ 
     u32 delay_fatbit_size; //!< size of each delay fatbit in scratch (bytes)
-    u32 anchored_count; /* number of anchored literal ids */
+    u32 anchored_count; /* number of anchored literal ids */ 
     u32 anchored_fatbit_size; //!< size of each anch fatbit in scratch (bytes)
-    u32 maxFloatingDelayedMatch; /* max offset that a delayed literal can
-                                  * usefully be reported */
-    u32 delayRebuildLength; /* length of the history region which needs to be
-                             * rescanned when we are doing a delayed literal
-                             * rebuild scan. */
-    struct RoseStateOffsets stateOffsets;
-    struct RoseBoundaryReports boundary;
-    u32 totalNumLiterals; /* total number of literals including dr */
-    u32 asize; /* size of the atable */
-    u32 outfixBeginQueue; /* first outfix queue */
-    u32 outfixEndQueue; /* one past the last outfix queue */
-    u32 leftfixBeginQueue; /* first prefix/infix queue */
-    u32 initMpvNfa; /* (allegedly chained) mpv to force on at init */
-    u32 rosePrefixCount; /* number of rose prefixes */
-    u32 activeLeftIterOffset; /* mmbit_sparse_iter over non-transient roses */
-    u32 ematcherRegionSize; /* max region size to pass to ematcher */
-    u32 somRevCount; /**< number of som reverse nfas */
-    u32 somRevOffsetOffset; /**< offset to array of offsets to som rev nfas */
+    u32 maxFloatingDelayedMatch; /* max offset that a delayed literal can 
+                                  * usefully be reported */ 
+    u32 delayRebuildLength; /* length of the history region which needs to be 
+                             * rescanned when we are doing a delayed literal 
+                             * rebuild scan. */ 
+    struct RoseStateOffsets stateOffsets; 
+    struct RoseBoundaryReports boundary; 
+    u32 totalNumLiterals; /* total number of literals including dr */ 
+    u32 asize; /* size of the atable */ 
+    u32 outfixBeginQueue; /* first outfix queue */ 
+    u32 outfixEndQueue; /* one past the last outfix queue */ 
+    u32 leftfixBeginQueue; /* first prefix/infix queue */ 
+    u32 initMpvNfa; /* (allegedly chained) mpv to force on at init */ 
+    u32 rosePrefixCount; /* number of rose prefixes */ 
+    u32 activeLeftIterOffset; /* mmbit_sparse_iter over non-transient roses */ 
+    u32 ematcherRegionSize; /* max region size to pass to ematcher */ 
+    u32 somRevCount; /**< number of som reverse nfas */ 
+    u32 somRevOffsetOffset; /**< offset to array of offsets to som rev nfas */ 
     u32 longLitStreamState; // size in bytes
-
-    struct scatter_full_plan state_init;
-};
-
-struct ALIGN_CL_DIRECTIVE anchored_matcher_info {
-    u32 next_offset; /* relative to this, 0 for end */
-    u32 state_offset; /* relative to anchorState */
-    u32 anchoredMinDistance; /* start of region to run anchored table over */
-};
-
+ 
+    struct scatter_full_plan state_init; 
+}; 
+ 
+struct ALIGN_CL_DIRECTIVE anchored_matcher_info { 
+    u32 next_offset; /* relative to this, 0 for end */ 
+    u32 state_offset; /* relative to anchorState */ 
+    u32 anchoredMinDistance; /* start of region to run anchored table over */ 
+}; 
+ 
 /**
  * \brief Long literal subtable for a particular mode (caseful or nocase).
  */
@@ -554,106 +554,106 @@ struct RoseLongLitHashEntry {
     u32 str_len;
 };
 
-static really_inline
-const struct anchored_matcher_info *getALiteralMatcher(
-        const struct RoseEngine *t) {
-    if (!t->amatcherOffset) {
-        return NULL;
-    }
-
-    const char *lt = (const char *)t + t->amatcherOffset;
-    assert(ISALIGNED_CL(lt));
-    return (const struct anchored_matcher_info *)lt;
-}
-
-struct HWLM;
-
-static really_inline
-const struct HWLM *getFLiteralMatcher(const struct RoseEngine *t) {
-    if (!t->fmatcherOffset) {
-        return NULL;
-    }
-
-    const char *lt = (const char *)t + t->fmatcherOffset;
-    assert(ISALIGNED_CL(lt));
-    return (const struct HWLM *)lt;
-}
-
-static really_inline
-const void *getSBLiteralMatcher(const struct RoseEngine *t) {
-    if (!t->sbmatcherOffset) {
-        return NULL;
-    }
-
-    const char *matcher = (const char *)t + t->sbmatcherOffset;
-    assert(ISALIGNED_N(matcher, 8));
-    return matcher;
-}
-
-static really_inline
-const struct LeftNfaInfo *getLeftTable(const struct RoseEngine *t) {
-    const struct LeftNfaInfo *r
-        = (const struct LeftNfaInfo *)((const char *)t + t->leftOffset);
-    assert(ISALIGNED_N(r, 4));
-    return r;
-}
-
-struct mmbit_sparse_iter; // forward decl
-
-static really_inline
-const struct mmbit_sparse_iter *getActiveLeftIter(const struct RoseEngine *t) {
-    assert(t->activeLeftIterOffset);
-    const struct mmbit_sparse_iter *it = (const struct mmbit_sparse_iter *)
-            ((const char *)t + t->activeLeftIterOffset);
-    assert(ISALIGNED_N(it, 4));
-    return it;
-}
-
-static really_inline
-const struct NfaInfo *getNfaInfoByQueue(const struct RoseEngine *t, u32 qi) {
-    const struct NfaInfo *infos
-        = (const struct NfaInfo *)((const char *)t + t->nfaInfoOffset);
-    assert(ISALIGNED_N(infos, sizeof(u32)));
-
-    return &infos[qi];
-}
-
-static really_inline
-const struct NFA *getNfaByInfo(const struct RoseEngine *t,
-                               const struct NfaInfo *info) {
-    return (const struct NFA *)((const char *)t + info->nfaOffset);
-}
-
-static really_inline
-const struct NFA *getNfaByQueue(const struct RoseEngine *t, u32 qi) {
-    const struct NfaInfo *info = getNfaInfoByQueue(t, qi);
-    return getNfaByInfo(t, info);
-}
-
-static really_inline
-u32 queueToLeftIndex(const struct RoseEngine *t, u32 qi) {
-    assert(qi >= t->leftfixBeginQueue);
-    return qi - t->leftfixBeginQueue;
-}
-
-static really_inline
-const struct LeftNfaInfo *getLeftInfoByQueue(const struct RoseEngine *t,
-                                             u32 qi) {
-    const struct LeftNfaInfo *infos = getLeftTable(t);
-    return &infos[queueToLeftIndex(t, qi)];
-}
-
-struct SmallWriteEngine;
-
-static really_inline
-const struct SmallWriteEngine *getSmallWrite(const struct RoseEngine *t) {
-    if (!t->smallWriteOffset) {
-        return NULL;
-    }
-
-    const struct SmallWriteEngine *smwr =
-        (const struct SmallWriteEngine *)((const char *)t + t->smallWriteOffset);
-    return smwr;
-}
-
-#endif // ROSE_INTERNAL_H
+static really_inline 
+const struct anchored_matcher_info *getALiteralMatcher( 
+        const struct RoseEngine *t) { 
+    if (!t->amatcherOffset) { 
+        return NULL; 
+    } 
+ 
+    const char *lt = (const char *)t + t->amatcherOffset; 
+    assert(ISALIGNED_CL(lt)); 
+    return (const struct anchored_matcher_info *)lt; 
+} 
+ 
+struct HWLM; 
+ 
+static really_inline 
+const struct HWLM *getFLiteralMatcher(const struct RoseEngine *t) { 
+    if (!t->fmatcherOffset) { 
+        return NULL; 
+    } 
+ 
+    const char *lt = (const char *)t + t->fmatcherOffset; 
+    assert(ISALIGNED_CL(lt)); 
+    return (const struct HWLM *)lt; 
+} 
+ 
+static really_inline 
+const void *getSBLiteralMatcher(const struct RoseEngine *t) { 
+    if (!t->sbmatcherOffset) { 
+        return NULL; 
+    } 
+ 
+    const char *matcher = (const char *)t + t->sbmatcherOffset; 
+    assert(ISALIGNED_N(matcher, 8)); 
+    return matcher; 
+} 
+ 
+static really_inline 
+const struct LeftNfaInfo *getLeftTable(const struct RoseEngine *t) { 
+    const struct LeftNfaInfo *r 
+        = (const struct LeftNfaInfo *)((const char *)t + t->leftOffset); 
+    assert(ISALIGNED_N(r, 4)); 
+    return r; 
+} 
+ 
+struct mmbit_sparse_iter; // forward decl 
+ 
+static really_inline 
+const struct mmbit_sparse_iter *getActiveLeftIter(const struct RoseEngine *t) { 
+    assert(t->activeLeftIterOffset); 
+    const struct mmbit_sparse_iter *it = (const struct mmbit_sparse_iter *) 
+            ((const char *)t + t->activeLeftIterOffset); 
+    assert(ISALIGNED_N(it, 4)); 
+    return it; 
+} 
+ 
+static really_inline 
+const struct NfaInfo *getNfaInfoByQueue(const struct RoseEngine *t, u32 qi) { 
+    const struct NfaInfo *infos 
+        = (const struct NfaInfo *)((const char *)t + t->nfaInfoOffset); 
+    assert(ISALIGNED_N(infos, sizeof(u32))); 
+ 
+    return &infos[qi]; 
+} 
+ 
+static really_inline 
+const struct NFA *getNfaByInfo(const struct RoseEngine *t, 
+                               const struct NfaInfo *info) { 
+    return (const struct NFA *)((const char *)t + info->nfaOffset); 
+} 
+ 
+static really_inline 
+const struct NFA *getNfaByQueue(const struct RoseEngine *t, u32 qi) { 
+    const struct NfaInfo *info = getNfaInfoByQueue(t, qi); 
+    return getNfaByInfo(t, info); 
+} 
+ 
+static really_inline 
+u32 queueToLeftIndex(const struct RoseEngine *t, u32 qi) { 
+    assert(qi >= t->leftfixBeginQueue); 
+    return qi - t->leftfixBeginQueue; 
+} 
+ 
+static really_inline 
+const struct LeftNfaInfo *getLeftInfoByQueue(const struct RoseEngine *t, 
+                                             u32 qi) { 
+    const struct LeftNfaInfo *infos = getLeftTable(t); 
+    return &infos[queueToLeftIndex(t, qi)]; 
+} 
+ 
+struct SmallWriteEngine; 
+ 
+static really_inline 
+const struct SmallWriteEngine *getSmallWrite(const struct RoseEngine *t) { 
+    if (!t->smallWriteOffset) { 
+        return NULL; 
+    } 
+ 
+    const struct SmallWriteEngine *smwr = 
+        (const struct SmallWriteEngine *)((const char *)t + t->smallWriteOffset); 
+    return smwr; 
+} 
+ 
+#endif // ROSE_INTERNAL_H