Update re2

third_party/re2/re2/onepass.cc

 // Copyright 2008 The RE2 Authors.  All Rights Reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // Tested by search_test.cc.
 //
 // Prog::SearchOnePass is an efficient implementation of
 // regular expression search with submatch tracking for
 // what I call "one-pass regular expressions".  (An alternate
 // name might be "backtracking-free regular expressions".)
@@ skipping 35 matching lines @@
 // One-pass regular expressions get used a lot when RE is
 // used for parsing simple strings, so it pays off to
 // notice them and handle them efficiently.
 //
 // See also Anne Brüggemann-Klein and Derick Wood,
 // "One-unambiguous regular languages", Information and Computation 142(2).
 
 #include <string.h>
 #include <map>
 #include "util/util.h"
-#include "util/arena.h"
 #include "util/sparse_set.h"
 #include "re2/prog.h"
 #include "re2/stringpiece.h"
 
 namespace re2 {
 
 static const int Debug = 0;
 
 // The key insight behind this implementation is that the
 // non-determinism in an NFA for a one-pass regular expression
@@ skipping 52 matching lines @@
 // To execute a one-pass regular expression program, we can build
 // a DFA (no non-determinism) that has at most as many states as
 // the NFA (compare this to the possibly exponential number of states
 // in the general case).  Each state records, for each possible
 // input byte, the next state along with the conditions required
 // before entering that state -- empty-width flags that must be true
 // and capture operations that must be performed.  It also records
 // whether a set of conditions required to finish a match at that
 // point in the input rather than process the next byte.
 
-// A state in the one-pass NFA (aka DFA) - just an array of actions.
-struct OneState;
-
 // A state in the one-pass NFA - just an array of actions indexed
 // by the bytemap_[] of the next input byte.  (The bytemap
 // maps next input bytes into equivalence classes, to reduce
 // the memory footprint.)
 struct OneState {
   uint32 matchcond;   // conditions to match right now.
   uint32 action[1];
 };
 
 // The uint32 conditions in the action are a combination of
@@ skipping 186 matching lines @@
         matchcap[i] = cap[i];
       matchcap[1] = p;
       matched = true;
     }
   }
 
 done:
   if (!matched)
     return false;
   for (int i = 0; i < nmatch; i++)
-    match[i].set(matchcap[2*i], matchcap[2*i+1] - matchcap[2*i]);
+    match[i].set(matchcap[2*i],
+                 static_cast<int>(matchcap[2*i+1] - matchcap[2*i]));
   return true;
 }
 
 
 // Analysis to determine whether a given regexp program is one-pass.
 
 // If ip is not on workq, adds ip to work queue and returns true.
 // If ip is already on work queue, does nothing and returns false.
 // If ip is NULL, does nothing and returns true (pretends to add it).
 typedef SparseSet Instq;
@@ skipping 256 matching lines @@
   return true;
 
 fail:
   delete[] stack;
   delete[] nodebyid;
   delete[] nodes;
   return false;
 }
 
 }  // namespace re2