mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-25 00:29:20 +00:00
appropriate unit tests. This change in itself is not expected to affect any functionality at this point, but it will serve as a stepping stone to improve FileCheck's variable matching capabilities. Luckily, our regex implementation already supports backreferences, although a bit of hacking is required to enable it. It supports both Basic Regular Expressions (BREs) and Extended Regular Expressions (EREs), without supporting backrefs for EREs, following POSIX strictly in this respect. And EREs is what we actually use (rightly). This is contrary to many implementations (including the default on Linux) of POSIX regexes, that do allow backrefs in EREs. Adding backref support to our EREs is a very simple change in the regcomp parsing code. I fail to think of significant cases where it would clash with existing things, and can bring more versatility to the regexes we write. There's always the danger of a backref in a specially crafted regex causing exponential matching times, but since we mainly use them for testing purposes I don't think it's a big problem. [it can also be placed behind a flag specific to FileCheck, if needed]. For more details, see: * http://lists.cs.uiuc.edu/pipermail/llvmdev/2012-November/055840.html * http://lists.cs.uiuc.edu/pipermail/llvm-commits/Week-of-Mon-20121126/156878.html git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@168802 91177308-0d34-0410-b5e6-96231b3b80d8
171 lines
4.6 KiB
C++
171 lines
4.6 KiB
C++
//===-- Regex.cpp - Regular Expression matcher implementation -------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements a POSIX regular expression matcher.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Support/Regex.h"
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
#include "llvm/ADT/SmallVector.h"
|
|
#include "regex_impl.h"
|
|
#include <string>
|
|
using namespace llvm;
|
|
|
|
Regex::Regex(StringRef regex, unsigned Flags) {
|
|
unsigned flags = 0;
|
|
preg = new llvm_regex();
|
|
preg->re_endp = regex.end();
|
|
if (Flags & IgnoreCase)
|
|
flags |= REG_ICASE;
|
|
if (Flags & Newline)
|
|
flags |= REG_NEWLINE;
|
|
if (!(Flags & BasicRegex))
|
|
flags |= REG_EXTENDED;
|
|
error = llvm_regcomp(preg, regex.data(), flags|REG_PEND);
|
|
}
|
|
|
|
Regex::~Regex() {
|
|
llvm_regfree(preg);
|
|
delete preg;
|
|
}
|
|
|
|
bool Regex::isValid(std::string &Error) {
|
|
if (!error)
|
|
return true;
|
|
|
|
size_t len = llvm_regerror(error, preg, NULL, 0);
|
|
|
|
Error.resize(len);
|
|
llvm_regerror(error, preg, &Error[0], len);
|
|
return false;
|
|
}
|
|
|
|
/// getNumMatches - In a valid regex, return the number of parenthesized
|
|
/// matches it contains.
|
|
unsigned Regex::getNumMatches() const {
|
|
return preg->re_nsub;
|
|
}
|
|
|
|
bool Regex::match(StringRef String, SmallVectorImpl<StringRef> *Matches){
|
|
unsigned nmatch = Matches ? preg->re_nsub+1 : 0;
|
|
|
|
// pmatch needs to have at least one element.
|
|
SmallVector<llvm_regmatch_t, 8> pm;
|
|
pm.resize(nmatch > 0 ? nmatch : 1);
|
|
pm[0].rm_so = 0;
|
|
pm[0].rm_eo = String.size();
|
|
|
|
int rc = llvm_regexec(preg, String.data(), nmatch, pm.data(), REG_STARTEND);
|
|
|
|
if (rc == REG_NOMATCH)
|
|
return false;
|
|
if (rc != 0) {
|
|
// regexec can fail due to invalid pattern or running out of memory.
|
|
error = rc;
|
|
return false;
|
|
}
|
|
|
|
// There was a match.
|
|
|
|
if (Matches) { // match position requested
|
|
Matches->clear();
|
|
|
|
for (unsigned i = 0; i != nmatch; ++i) {
|
|
if (pm[i].rm_so == -1) {
|
|
// this group didn't match
|
|
Matches->push_back(StringRef());
|
|
continue;
|
|
}
|
|
assert(pm[i].rm_eo >= pm[i].rm_so);
|
|
Matches->push_back(StringRef(String.data()+pm[i].rm_so,
|
|
pm[i].rm_eo-pm[i].rm_so));
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
std::string Regex::sub(StringRef Repl, StringRef String,
|
|
std::string *Error) {
|
|
SmallVector<StringRef, 8> Matches;
|
|
|
|
// Reset error, if given.
|
|
if (Error && !Error->empty()) *Error = "";
|
|
|
|
// Return the input if there was no match.
|
|
if (!match(String, &Matches))
|
|
return String;
|
|
|
|
// Otherwise splice in the replacement string, starting with the prefix before
|
|
// the match.
|
|
std::string Res(String.begin(), Matches[0].begin());
|
|
|
|
// Then the replacement string, honoring possible substitutions.
|
|
while (!Repl.empty()) {
|
|
// Skip to the next escape.
|
|
std::pair<StringRef, StringRef> Split = Repl.split('\\');
|
|
|
|
// Add the skipped substring.
|
|
Res += Split.first;
|
|
|
|
// Check for terminimation and trailing backslash.
|
|
if (Split.second.empty()) {
|
|
if (Repl.size() != Split.first.size() &&
|
|
Error && Error->empty())
|
|
*Error = "replacement string contained trailing backslash";
|
|
break;
|
|
}
|
|
|
|
// Otherwise update the replacement string and interpret escapes.
|
|
Repl = Split.second;
|
|
|
|
// FIXME: We should have a StringExtras function for mapping C99 escapes.
|
|
switch (Repl[0]) {
|
|
// Treat all unrecognized characters as self-quoting.
|
|
default:
|
|
Res += Repl[0];
|
|
Repl = Repl.substr(1);
|
|
break;
|
|
|
|
// Single character escapes.
|
|
case 't':
|
|
Res += '\t';
|
|
Repl = Repl.substr(1);
|
|
break;
|
|
case 'n':
|
|
Res += '\n';
|
|
Repl = Repl.substr(1);
|
|
break;
|
|
|
|
// Decimal escapes are backreferences.
|
|
case '0': case '1': case '2': case '3': case '4':
|
|
case '5': case '6': case '7': case '8': case '9': {
|
|
// Extract the backreference number.
|
|
StringRef Ref = Repl.slice(0, Repl.find_first_not_of("0123456789"));
|
|
Repl = Repl.substr(Ref.size());
|
|
|
|
unsigned RefValue;
|
|
if (!Ref.getAsInteger(10, RefValue) &&
|
|
RefValue < Matches.size())
|
|
Res += Matches[RefValue];
|
|
else if (Error && Error->empty())
|
|
*Error = "invalid backreference string '" + Ref.str() + "'";
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// And finally the suffix.
|
|
Res += StringRef(Matches[0].end(), String.end() - Matches[0].end());
|
|
|
|
return Res;
|
|
}
|