| /external/regex-re2/re2/ |
| prog.cc | 10 #include "re2/prog.h"
17 void Prog::Inst::InitAlt(uint32 out, uint32 out1) {
23 void Prog::Inst::InitByteRange(int lo, int hi, int foldcase, uint32 out) {
31 void Prog::Inst::InitCapture(int cap, uint32 out) {
37 void Prog::Inst::InitEmptyWidth(EmptyOp empty, uint32 out) {
43 void Prog::Inst::InitMatch(int32 id) {
49 void Prog::Inst::InitNop(uint32 out) {
54 void Prog::Inst::InitFail() {
59 string Prog::Inst::Dump() {
93 Prog::Prog(
[all...] |
| compile.cc | 5 // Compile regular expression to Prog.
7 // Prog and Inst are defined in prog.h.
11 #include "re2/prog.h"
38 static void Patch(Prog::Inst *inst0, PatchList l, uint32 v);
41 static PatchList Deref(Prog::Inst *inst0, PatchList l);
44 static PatchList Append(Prog::Inst *inst0, PatchList l1, PatchList l2);
57 PatchList PatchList::Deref(Prog::Inst* inst0, PatchList l) {
58 Prog::Inst* ip = &inst0[l.p>>1];
67 void PatchList::Patch(Prog::Inst *inst0, PatchList l, uint32 val)
1115 Prog* prog = c.Finish(); local
[all...] |
| set.h | 46 re2::Prog* prog_;
|
| prog.h | 78 class Prog {
80 Prog();
81 ~Prog();
98 int id(Prog* p) { return this - p->inst_; }
108 bool greedy(Prog *p) {
168 friend class Prog;
223 // Record that at some point in the prog, the bytes in the range
247 // Execution engines. They all search for the regexp (run the prog)
332 // Compiles a collection of regexps to Prog. Each regexp will have
334 static Prog* CompileSet(const RE2::Options& options, RE2::Anchor anchor
[all...] |
| set.cc | 9 #include "re2/prog.h"
90 prog_ = Prog::CompileSet(options_, anchor_, re);
101 bool ret = prog_->SearchDFA(text, text, Prog::kAnchored,
102 Prog::kManyMatch, NULL, &failed, v);
|
| bitstate.cc | 7 // Prog::SearchBitState is a regular expression search with submatch
10 // text) * (length of prog) bits, to make sure it never explores the
20 #include "re2/prog.h"
33 explicit BitState(Prog* prog);
49 Prog* prog_; // program being run
71 BitState::BitState(Prog* prog)
72 : prog_(prog),
170 Prog::Inst* ip = prog_->inst(id)
[all...] |
| dfa.cc | 24 #include "re2/prog.h"
57 DFA(Prog* prog, Prog::MatchKind kind, int64 max_mem);
60 Prog::MatchKind kind() { return kind_; }
205 Prog::MatchKind kind,
314 Prog* prog_; // The regular expression program to run.
315 Prog::MatchKind kind_; // The kind of DFA.
407 DFA::DFA(Prog* prog, Prog::MatchKind kind, int64 max_mem
[all...] |
| nfa.cc | 7 // Prog::SearchNFA, an NFA search.
27 #include "re2/prog.h"
36 NFA(Prog* prog);
109 Prog* prog_; // underlying program
128 NFA::NFA(Prog* prog) {
129 prog_ = prog;
130 start_ = prog->start();
193 // Each inst in prog can be processed at most once
[all...] |
| re2.cc | 19 #include "re2/prog.h"
186 // Two thirds of the memory goes to the forward Prog,
187 // one third to the reverse prog, because the forward
188 // Prog has two DFAs but the reverse prog has one.
207 re2::Prog* RE2::ReverseProg() const {
568 Prog::Anchor anchor = Prog::kUnanchored;
569 Prog::MatchKind kind = Prog::kFirstMatch
[all...] |
| onepass.cc | 7 // Prog::SearchOnePass is an efficient implementation of
58 #include "re2/prog.h"
146 // Bits 0-5 are the empty-width flags from prog.h.
159 static const int kEmptyShift = 6; // number of empty flags in prog.h
172 // Check, at compile time, that prog.h agrees with math above.
178 COMPILE_ASSERT(kMaxCap == Prog::kMaxOnePassCapture*2,
183 uint32 satisfied = Prog::EmptyFlags(context, p);
207 bool Prog::SearchOnePass(const StringPiece& text,
378 bool Prog::IsOnePass() {
430 Prog::Inst* ip = inst(id)
[all...] |
| regexp.h | 78 // Prog, described in prog.h
217 // Compiled form; see prog.h
218 class Prog;
407 // Compile to Prog. See prog.h
408 // Reverse prog expects to be run over text backward.
409 // Construction and execution of prog will
412 Prog* CompileToProg(int64 max_mem);
413 Prog* CompileToReverseProg(int64 max_mem)
[all...] |
| re2.h | 193 class Prog;
493 // to hold the compiled form of the regexp (the Prog) and
495 // of Prog instructions and DFA states: 10,000 for both.
496 // In RE2, those limits would translate to about 240 KB per Prog
499 // Each RE2 has two Progs (one forward, one reverse), and each Prog
512 // Progs and then the DFAs: two thirds to the forward Prog
513 // and one third to the reverse Prog. The forward Prog gives half
514 // of what it has left over to each of its DFAs. The reverse Prog
684 re2::Prog* ReverseProg() const
[all...] |
| /external/clang/lib/Driver/ |
| Compilation.cpp | 142 llvm::sys::Path Prog(C.getExecutable());
179 llvm::sys::Program::ExecuteAndWait(Prog, Argv,
|
| /external/clang/tools/scan-build/ |
| scan-build | 26 my $Prog = "scan-build";
52 print BOLD, MAGENTA "$Prog: @_";
56 print "$Prog: @_";
70 print BOLD, RED "$Prog: ";
75 print "$Prog: ", @_;
147 # Strip the prefix '$Prog-' if we are dumping files to /tmp.
149 next if (!($f =~ /^$Prog-(.+)/));
187 $NewDir = "$Dir/$Prog-$DateString-$RunNumber";
978 USAGE: $Prog [options] <build command> [build options]
[all...] |
| /external/llvm/tools/bugpoint/ |
| Miscompilation.cpp | 616 Module *Prog = BD.getProgram();
617 for (Module::iterator I = Prog->begin(), E = Prog->end(); I != E; ++I)
[all...] |
