(pascal   03-Sep-16) 

1

: //===- FileCheck.cpp - Check that File's Contents match what is expected --===//

2

: //

3

: //                     The LLVM Compiler Infrastructure

4

: //

5

: // This file is distributed under the University of Illinois Open Source

6

: // License. See LICENSE.TXT for details.

7

: //

8

: //===----------------------------------------------------------------------===//

9

: //

10

: // FileCheck does a line-by line check of a file that validates whether it

11

: // contains the expected content.  This is useful for regression tests etc.

12

: //

13

: // This program exits with an error status of 2 on error, exit status of 0 if

14

: // the file matched the expected contents, and exit status of 1 if it did not

15

: // contain the expected contents.

16

: //

17

: //===----------------------------------------------------------------------===//

18

: 

19

: #include "llvm/ADT/SmallString.h"

20

: #include "llvm/ADT/StringExtras.h"

21

: #include "llvm/ADT/StringMap.h"

22

: #include "llvm/ADT/StringSet.h"

23

: #include "llvm/Support/CommandLine.h"

24

: #include "llvm/Support/MemoryBuffer.h"

25

: #include "llvm/Support/PrettyStackTrace.h"

26

: #include "llvm/Support/Regex.h"

27

: #include "llvm/Support/Signals.h"

28

: #include "llvm/Support/SourceMgr.h"

29

: #include "llvm/Support/raw_ostream.h"

30

: #include <algorithm>

31

: #include <cctype>

32

: #include <map>

33

: #include <string>

34

: #include <system_error>

35

: #include <vector>

36

: using namespace llvm;

37

: 

38

: static cl::opt<std::string>

39

: CheckFilename(cl::Positional, cl::desc("<check-file>"), cl::Required);

40

: 

41

: static cl::opt<std::string>

42

: InputFilename("input-file", cl::desc("File to check (defaults to stdin)"),

43

:               cl::init("-"), cl::value_desc("filename"));

44

: 

45

: static cl::list<std::string>

46

: CheckPrefixes("check-prefix",

47

:               cl::desc("Prefix to use from check file (defaults to 'CHECK')"));

48

: 

49

: static cl::opt<bool>

50

: NoCanonicalizeWhiteSpace("strict-whitespace",

51

:               cl::desc("Do not treat all horizontal whitespace as equivalent"));

52

: 

53

: static cl::list<std::string> ImplicitCheckNot(

54

:     "implicit-check-not",

55

:     cl::desc("Add an implicit negative check with this pattern to every\n"

56

:              "positive check. This can be used to ensure that no instances of\n"

57

:              "this pattern occur which are not matched by a positive pattern"),

58

:     cl::value_desc("pattern"));

59

: 

60

: static cl::opt<bool> AllowEmptyInput(

61

:     "allow-empty", cl::init(false),

62

:     cl::desc("Allow the input file to be empty. This is useful when making\n"

63

:              "checks that some error message does not occur, for example."));

64

: 

65

: typedef cl::list<std::string>::const_iterator prefix_iterator;

66

: 

67

: //===----------------------------------------------------------------------===//

68

: // Pattern Handling Code.

69

: //===----------------------------------------------------------------------===//

70

: 

71

: namespace Check {

72

:   enum CheckType {

73

:     CheckNone = 0,

74

:     CheckPlain,

75

:     CheckNext,

76

:     CheckSame,

77

:     CheckNot,

78

:     CheckDAG,

79

:     CheckLabel,

80

: 

81

:     /// MatchEOF - When set, this pattern only matches the end of file. This is

82

:     /// used for trailing CHECK-NOTs.

83

:     CheckEOF

84

:   };

85

: }

86

: 

87

: class Pattern {

88

:   SMLoc PatternLoc;

89

: 

90

:   Check::CheckType CheckTy;

91

: 

92

:   /// FixedStr - If non-empty, this pattern is a fixed string match with the

93

:   /// specified fixed string.

94

:   StringRef FixedStr;

95

: 

96

:   /// RegEx - If non-empty, this is a regex pattern.

97

:   std::string RegExStr;

98

: 

99

:   /// \brief Contains the number of line this pattern is in.

100

:   unsigned LineNumber;

101

: 

102

:   /// VariableUses - Entries in this vector map to uses of a variable in the

103

:   /// pattern, e.g. "foo[[bar]]baz".  In this case, the RegExStr will contain

104

:   /// "foobaz" and we'll get an entry in this vector that tells us to insert the

105

:   /// value of bar at offset 3.

106

:   std::vector<std::pair<StringRef, unsigned> > VariableUses;

107

: 

108

:   /// VariableDefs - Maps definitions of variables to their parenthesized

109

:   /// capture numbers.

110

:   /// E.g. for the pattern "foo[[bar:.*]]baz", VariableDefs will map "bar" to 1.

111

:   std::map<StringRef, unsigned> VariableDefs;

112

: 

113

: public:

114

: 

115

:   Pattern(Check::CheckType Ty)

116

:     : CheckTy(Ty) { }

117

: 

118

:   /// getLoc - Return the location in source code.

119

:   SMLoc getLoc() const { return PatternLoc; }

120

: 

121

:   /// ParsePattern - Parse the given string into the Pattern. Prefix provides

122

:   /// which prefix is being matched, SM provides the SourceMgr used for error

123

:   /// reports, and LineNumber is the line number in the input file from which

124

:   /// the pattern string was read.  Returns true in case of an error, false

125

:   /// otherwise.

126

:   bool ParsePattern(StringRef PatternStr,

127

:                     StringRef Prefix,

128

:                     SourceMgr &SM,

129

:                     unsigned LineNumber);

130

: 

131

:   /// Match - Match the pattern string against the input buffer Buffer.  This

132

:   /// returns the position that is matched or npos if there is no match.  If

133

:   /// there is a match, the size of the matched string is returned in MatchLen.

134

:   ///

135

:   /// The VariableTable StringMap provides the current values of filecheck

136

:   /// variables and is updated if this match defines new values.

137

:   size_t Match(StringRef Buffer, size_t &MatchLen,

138

:                StringMap<StringRef> &VariableTable) const;

139

: 

140

:   /// PrintFailureInfo - Print additional information about a failure to match

141

:   /// involving this pattern.

142

:   void PrintFailureInfo(const SourceMgr &SM, StringRef Buffer,

143

:                         const StringMap<StringRef> &VariableTable) const;

144

: 

145

:   bool hasVariable() const { return !(VariableUses.empty() &&

146

:                                       VariableDefs.empty()); }

147

: 

148

:   Check::CheckType getCheckTy() const { return CheckTy; }

149

: 

150

: private:

151

:   bool AddRegExToRegEx(StringRef RS, unsigned &CurParen, SourceMgr &SM);

152

:   void AddBackrefToRegEx(unsigned BackrefNum);

153

: 

154

:   /// ComputeMatchDistance - Compute an arbitrary estimate for the quality of

155

:   /// matching this pattern at the start of \arg Buffer; a distance of zero

156

:   /// should correspond to a perfect match.

157

:   unsigned ComputeMatchDistance(StringRef Buffer,

158

:                                const StringMap<StringRef> &VariableTable) const;

159

: 

160

:   /// \brief Evaluates expression and stores the result to \p Value.

161

:   /// \return true on success. false when the expression has invalid syntax.

162

:   bool EvaluateExpression(StringRef Expr, std::string &Value) const;

163

: 

164

:   /// \brief Finds the closing sequence of a regex variable usage or

165

:   /// definition. Str has to point in the beginning of the definition

166

:   /// (right after the opening sequence).

167

:   /// \return offset of the closing sequence within Str, or npos if it was not

168

:   /// found.

169

:   size_t FindRegexVarEnd(StringRef Str, SourceMgr &SM);

170

: };

171

: 

172

: 

173

: bool Pattern::ParsePattern(StringRef PatternStr,

174

:                            StringRef Prefix,

175

:                            SourceMgr &SM,

176

:                            unsigned LineNumber) {

177

:   this->LineNumber = LineNumber;

178

:   PatternLoc = SMLoc::getFromPointer(PatternStr.data());

179

: 

180

:   // Ignore trailing whitespace.

181

:   while (!PatternStr.empty() &&

182

:          (PatternStr.back() == ' ' || PatternStr.back() == '\t'))

183

:     PatternStr = PatternStr.substr(0, PatternStr.size()-1);

184

: 

185

:   // Check that there is something on the line.

186

:   if (PatternStr.empty()) {

187

:     SM.PrintMessage(PatternLoc, SourceMgr::DK_Error,

188

:                     "found empty check string with prefix '" +

189

:                     Prefix + ":'");

190

:     return true;

191

:   }

192

: 

193

:   // Check to see if this is a fixed string, or if it has regex pieces.

194

:   if (PatternStr.size() < 2 ||

195

:       (PatternStr.find("{{") == StringRef::npos &&

196

:        PatternStr.find("[[") == StringRef::npos)) {

197

:     FixedStr = PatternStr;

198

:     return false;

199

:   }

200

: 

201

:   // Paren value #0 is for the fully matched string.  Any new parenthesized

202

:   // values add from there.

203

:   unsigned CurParen = 1;

204

: 

205

:   // Otherwise, there is at least one regex piece.  Build up the regex pattern

206

:   // by escaping scary characters in fixed strings, building up one big regex.

207

:   while (!PatternStr.empty()) {

208

:     // RegEx matches.

209

:     if (PatternStr.startswith("{{")) {

210

:       // This is the start of a regex match.  Scan for the }}.

211

:       size_t End = PatternStr.find("}}");

212

:       if (End == StringRef::npos) {

213

:         SM.PrintMessage(SMLoc::getFromPointer(PatternStr.data()),

214

:                         SourceMgr::DK_Error,

215

:                         "found start of regex string with no end '}}'");

216

:         return true;

217

:       }

218

: 

219

:       // Enclose {{}} patterns in parens just like [[]] even though we're not

220

:       // capturing the result for any purpose.  This is required in case the

221

:       // expression contains an alternation like: CHECK:  abc{{x|z}}def.  We

222

:       // want this to turn into: "abc(x|z)def" not "abcx|zdef".

223

:       RegExStr += '(';

224

:       ++CurParen;

225

: 

226

:       if (AddRegExToRegEx(PatternStr.substr(2, End-2), CurParen, SM))

227

:         return true;

228

:       RegExStr += ')';

229

: 

230

:       PatternStr = PatternStr.substr(End+2);

231

:       continue;

232

:     }

233

: 

234

:     // Named RegEx matches.  These are of two forms: [[foo:.*]] which matches .*

235

:     // (or some other regex) and assigns it to the FileCheck variable 'foo'. The

236

:     // second form is [[foo]] which is a reference to foo.  The variable name

237

:     // itself must be of the form "[a-zA-Z_][0-9a-zA-Z_]*", otherwise we reject

238

:     // it.  This is to catch some common errors.

239

:     if (PatternStr.startswith("[[")) {

240

:       // Find the closing bracket pair ending the match.  End is going to be an

241

:       // offset relative to the beginning of the match string.

242

:       size_t End = FindRegexVarEnd(PatternStr.substr(2), SM);

243

: 

244

:       if (End == StringRef::npos) {

245

:         SM.PrintMessage(SMLoc::getFromPointer(PatternStr.data()),

246

:                         SourceMgr::DK_Error,

247

:                         "invalid named regex reference, no ]] found");

248

:         return true;

249

:       }

250

: 

251

:       StringRef MatchStr = PatternStr.substr(2, End);

252

:       PatternStr = PatternStr.substr(End+4);

253

: 

254

:       // Get the regex name (e.g. "foo").

255

:       size_t NameEnd = MatchStr.find(':');

256

:       StringRef Name = MatchStr.substr(0, NameEnd);

257

: 

258

:       if (Name.empty()) {

259

:         SM.PrintMessage(SMLoc::getFromPointer(Name.data()), SourceMgr::DK_Error,

260

:                         "invalid name in named regex: empty name");

261

:         return true;

262

:       }

263

: 

264

:       // Verify that the name/expression is well formed. FileCheck currently

265

:       // supports @LINE, @LINE+number, @LINE-number expressions. The check here

266

:       // is relaxed, more strict check is performed in \c EvaluateExpression.

267

:       bool IsExpression = false;

268

:       for (unsigned i = 0, e = Name.size(); i != e; ++i) {

269

:         if (i == 0 && Name[i] == '@') {

270

:           if (NameEnd != StringRef::npos) {

271

:             SM.PrintMessage(SMLoc::getFromPointer(Name.data()),

272

:                             SourceMgr::DK_Error,

273

:                             "invalid name in named regex definition");

274

:             return true;

275

:           }

276

:           IsExpression = true;

277

:           continue;

278

:         }

279

:         if (Name[i] != '_' && !isalnum(Name[i]) &&

280

:             (!IsExpression || (Name[i] != '+' && Name[i] != '-'))) {

281

:           SM.PrintMessage(SMLoc::getFromPointer(Name.data()+i),

282

:                           SourceMgr::DK_Error, "invalid name in named regex");

283

:           return true;

284

:         }

285

:       }

286

: 

287

:       // Name can't start with a digit.

288

:       if (isdigit(static_cast<unsigned char>(Name[0]))) {

289

:         SM.PrintMessage(SMLoc::getFromPointer(Name.data()), SourceMgr::DK_Error,

290

:                         "invalid name in named regex");

291

:         return true;

292

:       }

293

: 

294

:       // Handle [[foo]].

295

:       if (NameEnd == StringRef::npos) {

296

:         // Handle variables that were defined earlier on the same line by

297

:         // emitting a backreference.

298

:         if (VariableDefs.find(Name) != VariableDefs.end()) {

299

:           unsigned VarParenNum = VariableDefs[Name];

300

:           if (VarParenNum < 1 || VarParenNum > 9) {

301

:             SM.PrintMessage(SMLoc::getFromPointer(Name.data()),

302

:                             SourceMgr::DK_Error,

303

:                             "Can't back-reference more than 9 variables");

304

:             return true;

305

:           }

306

:           AddBackrefToRegEx(VarParenNum);

307

:         } else {

308

:           VariableUses.push_back(std::make_pair(Name, RegExStr.size()));

309

:         }

310

:         continue;

311

:       }

312

: 

313

:       // Handle [[foo:.*]].

314

:       VariableDefs[Name] = CurParen;

315

:       RegExStr += '(';

316

:       ++CurParen;

317

: 

318

:       if (AddRegExToRegEx(MatchStr.substr(NameEnd+1), CurParen, SM))

319

:         return true;

320

: 

321

:       RegExStr += ')';

322

:     }

323

: 

324

:     // Handle fixed string matches.

325

:     // Find the end, which is the start of the next regex.

326

:     size_t FixedMatchEnd = PatternStr.find("{{");

327

:     FixedMatchEnd = std::min(FixedMatchEnd, PatternStr.find("[["));

328

:     RegExStr += Regex::escape(PatternStr.substr(0, FixedMatchEnd));

329

:     PatternStr = PatternStr.substr(FixedMatchEnd);

330

:   }

331

: 

332

:   return false;

333

: }

334

: 

335

: bool Pattern::AddRegExToRegEx(StringRef RS, unsigned &CurParen,

336

:                               SourceMgr &SM) {

337

:   Regex R(RS);

338

:   std::string Error;

339

:   if (!R.isValid(Error)) {

340

:     SM.PrintMessage(SMLoc::getFromPointer(RS.data()), SourceMgr::DK_Error,

341

:                     "invalid regex: " + Error);

342

:     return true;

343

:   }

344

: 

345

:   RegExStr += RS.str();

346

:   CurParen += R.getNumMatches();

347

:   return false;

348

: }

349

: 

350

: void Pattern::AddBackrefToRegEx(unsigned BackrefNum) {

351

:   assert(BackrefNum >= 1 && BackrefNum <= 9 && "Invalid backref number");

352

:   std::string Backref = std::string("\\") +

353

:                         std::string(1, '0' + BackrefNum);

354

:   RegExStr += Backref;

355

: }

356

: 

357

: bool Pattern::EvaluateExpression(StringRef Expr, std::string &Value) const {

358

:   // The only supported expression is @LINE([\+-]\d+)?

359

:   if (!Expr.startswith("@LINE"))

360

:     return false;

361

:   Expr = Expr.substr(StringRef("@LINE").size());

362

:   int Offset = 0;

363

:   if (!Expr.empty()) {

364

:     if (Expr[0] == '+')

365

:       Expr = Expr.substr(1);

366

:     else if (Expr[0] != '-')

367

:       return false;

368

:     if (Expr.getAsInteger(10, Offset))

369

:       return false;

370

:   }

371

:   Value = llvm::itostr(LineNumber + Offset);

372

:   return true;

373

: }

374

: 

375

: /// Match - Match the pattern string against the input buffer Buffer.  This

376

: /// returns the position that is matched or npos if there is no match.  If

377

: /// there is a match, the size of the matched string is returned in MatchLen.

378

: size_t Pattern::Match(StringRef Buffer, size_t &MatchLen,

379

:                       StringMap<StringRef> &VariableTable) const {

380

:   // If this is the EOF pattern, match it immediately.

381

:   if (CheckTy == Check::CheckEOF) {

382

:     MatchLen = 0;

383

:     return Buffer.size();

384

:   }

385

: 

386

:   // If this is a fixed string pattern, just match it now.

387

:   if (!FixedStr.empty()) {

388

:     MatchLen = FixedStr.size();

389

:     return Buffer.find(FixedStr);

390

:   }

391

: 

392

:   // Regex match.

393

: 

394

:   // If there are variable uses, we need to create a temporary string with the

395

:   // actual value.

396

:   StringRef RegExToMatch = RegExStr;

397

:   std::string TmpStr;

398

:   if (!VariableUses.empty()) {

399

:     TmpStr = RegExStr;

400

: 

401

:     unsigned InsertOffset = 0;

402

:     for (const auto &VariableUse : VariableUses) {

403

:       std::string Value;

404

: 

405

:       if (VariableUse.first[0] == '@') {

406

:         if (!EvaluateExpression(VariableUse.first, Value))

407

:           return StringRef::npos;

408

:       } else {

409

:         StringMap<StringRef>::iterator it =

410

:             VariableTable.find(VariableUse.first);

411

:         // If the variable is undefined, return an error.

412

:         if (it == VariableTable.end())

413

:           return StringRef::npos;

414

: 

415

:         // Look up the value and escape it so that we can put it into the regex.

416

:         Value += Regex::escape(it->second);

417

:       }

418

: 

419

:       // Plop it into the regex at the adjusted offset.

420

:       TmpStr.insert(TmpStr.begin() + VariableUse.second + InsertOffset,

421

:                     Value.begin(), Value.end());

422

:       InsertOffset += Value.size();

423

:     }

424

: 

425

:     // Match the newly constructed regex.

426

:     RegExToMatch = TmpStr;

427

:   }

428

: 

429

: 

430

:   SmallVector<StringRef, 4> MatchInfo;

431

:   if (!Regex(RegExToMatch, Regex::Newline).match(Buffer, &MatchInfo))

432

:     return StringRef::npos;

433

: 

434

:   // Successful regex match.

435

:   assert(!MatchInfo.empty() && "Didn't get any match");

436

:   StringRef FullMatch = MatchInfo[0];

437

: 

438

:   // If this defines any variables, remember their values.

439

:   for (const auto &VariableDef : VariableDefs) {

440

:     assert(VariableDef.second < MatchInfo.size() && "Internal paren error");

441

:     VariableTable[VariableDef.first] = MatchInfo[VariableDef.second];

442

:   }

443

: 

444

:   MatchLen = FullMatch.size();

445

:   return FullMatch.data()-Buffer.data();

446

: }

447

: 

448

: unsigned Pattern::ComputeMatchDistance(StringRef Buffer,

449

:                               const StringMap<StringRef> &VariableTable) const {

450

:   // Just compute the number of matching characters. For regular expressions, we

451

:   // just compare against the regex itself and hope for the best.

452

:   //

453

:   // FIXME: One easy improvement here is have the regex lib generate a single

454

:   // example regular expression which matches, and use that as the example

455

:   // string.

456

:   StringRef ExampleString(FixedStr);

457

:   if (ExampleString.empty())

458

:     ExampleString = RegExStr;

459

: 

460

:   // Only compare up to the first line in the buffer, or the string size.

461

:   StringRef BufferPrefix = Buffer.substr(0, ExampleString.size());

462

:   BufferPrefix = BufferPrefix.split('\n').first;

463

:   return BufferPrefix.edit_distance(ExampleString);

464

: }

465

: 

466

: void Pattern::PrintFailureInfo(const SourceMgr &SM, StringRef Buffer,

467

:                                const StringMap<StringRef> &VariableTable) const{

468

:   // If this was a regular expression using variables, print the current

469

:   // variable values.

470

:   if (!VariableUses.empty()) {

471

:     for (const auto &VariableUse : VariableUses) {

472

:       SmallString<256> Msg;

473

:       raw_svector_ostream OS(Msg);

474

:       StringRef Var = VariableUse.first;

475

:       if (Var[0] == '@') {

476

:         std::string Value;

477

:         if (EvaluateExpression(Var, Value)) {

478

:           OS << "with expression \"";

479

:           OS.write_escaped(Var) << "\" equal to \"";

480

:           OS.write_escaped(Value) << "\"";

481

:         } else {

482

:           OS << "uses incorrect expression \"";

483

:           OS.write_escaped(Var) << "\"";

484

:         }

485

:       } else {

486

:         StringMap<StringRef>::const_iterator it = VariableTable.find(Var);

487

: 

488

:         // Check for undefined variable references.

489

:         if (it == VariableTable.end()) {

490

:           OS << "uses undefined variable \"";

491

:           OS.write_escaped(Var) << "\"";

492

:         } else {

493

:           OS << "with variable \"";

494

:           OS.write_escaped(Var) << "\" equal to \"";

495

:           OS.write_escaped(it->second) << "\"";

496

:         }

497

:       }

498

: 

499

:       SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Note,

500

:                       OS.str());

501

:     }

502

:   }

503

: 

504

:   // Attempt to find the closest/best fuzzy match.  Usually an error happens

505

:   // because some string in the output didn't exactly match. In these cases, we

506

:   // would like to show the user a best guess at what "should have" matched, to

507

:   // save them having to actually check the input manually.

508

:   size_t NumLinesForward = 0;

509

:   size_t Best = StringRef::npos;

510

:   double BestQuality = 0;

511

: 

512

:   // Use an arbitrary 4k limit on how far we will search.

513

:   for (size_t i = 0, e = std::min(size_t(4096), Buffer.size()); i != e; ++i) {

514

:     if (Buffer[i] == '\n')

515

:       ++NumLinesForward;

516

: 

517

:     // Patterns have leading whitespace stripped, so skip whitespace when

518

:     // looking for something which looks like a pattern.

519

:     if (Buffer[i] == ' ' || Buffer[i] == '\t')

520

:       continue;

521

: 

522

:     // Compute the "quality" of this match as an arbitrary combination of the

523

:     // match distance and the number of lines skipped to get to this match.

524

:     unsigned Distance = ComputeMatchDistance(Buffer.substr(i), VariableTable);

525

:     double Quality = Distance + (NumLinesForward / 100.);

526

: 

527

:     if (Quality < BestQuality || Best == StringRef::npos) {

528

:       Best = i;

529

:       BestQuality = Quality;

530

:     }

531

:   }

532

: 

533

:   // Print the "possible intended match here" line if we found something

534

:   // reasonable and not equal to what we showed in the "scanning from here"

535

:   // line.

536

:   if (Best && Best != StringRef::npos && BestQuality < 50) {

537

:       SM.PrintMessage(SMLoc::getFromPointer(Buffer.data() + Best),

538

:                       SourceMgr::DK_Note, "possible intended match here");

539

: 

540

:     // FIXME: If we wanted to be really friendly we would show why the match

541

:     // failed, as it can be hard to spot simple one character differences.

542

:   }

543

: }

544

: 

545

: size_t Pattern::FindRegexVarEnd(StringRef Str, SourceMgr &SM) {

546

:   // Offset keeps track of the current offset within the input Str

547

:   size_t Offset = 0;

548

:   // [...] Nesting depth

549

:   size_t BracketDepth = 0;

550

: 

551

:   while (!Str.empty()) {

552

:     if (Str.startswith("]]") && BracketDepth == 0)

553

:       return Offset;

554

:     if (Str[0] == '\\') {

555

:       // Backslash escapes the next char within regexes, so skip them both.

556

:       Str = Str.substr(2);

557

:       Offset += 2;

558

:     } else {

559

:       switch (Str[0]) {

560

:         default:

561

:           break;

562

:         case '[':

563

:           BracketDepth++;

564

:           break;

565

:         case ']':

566

:           if (BracketDepth == 0) {

567

:             SM.PrintMessage(SMLoc::getFromPointer(Str.data()),

568

:                             SourceMgr::DK_Error,

569

:                             "missing closing \"]\" for regex variable");

570

:             exit(1);

571

:           }

572

:           BracketDepth--;

573

:           break;

574

:       }

575

:       Str = Str.substr(1);

576

:       Offset++;

577

:     }

578

:   }

579

: 

580

:   return StringRef::npos;

581

: }

582

: 

583

: 

584

: //===----------------------------------------------------------------------===//

585

: // Check Strings.

586

: //===----------------------------------------------------------------------===//

587

: 

588

: /// CheckString - This is a check that we found in the input file.

589

: struct CheckString {

590

:   /// Pat - The pattern to match.

591

:   Pattern Pat;

592

: 

593

:   /// Prefix - Which prefix name this check matched.

594

:   StringRef Prefix;

595

: 

596

:   /// Loc - The location in the match file that the check string was specified.

597

:   SMLoc Loc;

598

: 

599

:   /// CheckTy - Specify what kind of check this is. e.g. CHECK-NEXT: directive,

600

:   /// as opposed to a CHECK: directive.

601

:   Check::CheckType CheckTy;

602

: 

603

:   /// DagNotStrings - These are all of the strings that are disallowed from

604

:   /// occurring between this match string and the previous one (or start of

605

:   /// file).

606

:   std::vector<Pattern> DagNotStrings;

607

: 

608

: 

609

:   CheckString(const Pattern &P,

610

:               StringRef S,

611

:               SMLoc L,

612

:               Check::CheckType Ty)

613

:     : Pat(P), Prefix(S), Loc(L), CheckTy(Ty) {}

614

: