Changeset 6170
- Timestamp:
- Oct 2, 2018, 10:46:20 AM (5 months ago)
- Location:
- icGREP/icgrep-devel/icgrep
- Files:
-
- 15 edited
Legend:
- Unmodified
- Added
- Removed
-
icGREP/icgrep-devel/icgrep/UCD/CaseFolding.cpp
r5782 r6170 1 /*1 /* 2 2 * Copyright (c) 2014 International Characters, Inc. 3 3 * This software is licensed to the public under the Open Software License 3.0. -
icGREP/icgrep-devel/icgrep/re/casing.cpp
r6163 r6170 17 17 #include <llvm/Support/Casting.h> // for dyn_cast, isa 18 18 #include <llvm/Support/ErrorHandling.h> 19 #include <re/re_ utility.h>19 #include <re/re_toolchain.h> 20 20 21 21 using namespace llvm; … … 29 29 RE * transformGroup(Group * g) override; 30 30 31 ResolveCaseInsensitiveMode(const bool globallyCaseInsensitive) : inCaseInsensitiveMode(globallyCaseInsensitive) { } 31 ResolveCaseInsensitiveMode(const bool globallyCaseInsensitive) : 32 RE_Transformer("CaseInsensitize"), inCaseInsensitiveMode(globallyCaseInsensitive) { } 32 33 33 34 private: … … 71 72 RE * resolveCaseInsensitiveMode(RE * re, const bool globallyCaseInsensitive) { 72 73 ResolveCaseInsensitiveMode R(globallyCaseInsensitive); 73 return R.transform (re);74 return R.transformRE(re); 74 75 } 75 76 -
icGREP/icgrep-devel/icgrep/re/exclude_CC.cpp
r6161 r6170 19 19 #include <re/re_intersect.h> 20 20 #include <re/re_assertion.h> 21 #include <re/re_ utility.h>21 #include <re/re_toolchain.h> 22 22 #include <llvm/Support/Casting.h> 23 23 #include <llvm/Support/ErrorHandling.h> … … 29 29 class CC_Remover : public RE_Transformer { 30 30 public: 31 CC_Remover(CC * toExclude) : RE_Transformer( ), mExcludedCC(toExclude) {}31 CC_Remover(CC * toExclude) : RE_Transformer("Exclude"), mExcludedCC(toExclude) {} 32 32 RE * transformCC (CC * cc) override; 33 33 RE * transformName (Name * name) override; … … 62 62 63 63 RE * exclude_CC(RE * re, CC * cc) { 64 return CC_Remover(cc).transform (re);64 return CC_Remover(cc).transformRE(re); 65 65 } 66 66 } -
icGREP/icgrep-devel/icgrep/re/printer_re.cpp
r6169 r6170 47 47 retVal += re_cc->canonicalName(); 48 48 retVal += "\" "; 49 50 for (const auto & i : *re_cc) {51 retVal += "[";52 retVal += std::to_string(lo_codepoint(i));53 if (hi_codepoint(i) != lo_codepoint(i))54 retVal += "-" + std::to_string(hi_codepoint(i));55 retVal += "]";56 }57 retVal += "/" + re_cc->getAlphabet()->getName();58 49 } else if (const Name* re_name = dyn_cast<const Name>(re)) { 59 50 retVal = "Name \""; -
icGREP/icgrep-devel/icgrep/re/re_analysis.cpp
r6160 r6170 501 501 if (const CC * cc = dyn_cast<CC>(re)) { 502 502 if (cc->getAlphabet() == &cc::Unicode) { 503 gatherTests(UTF8_Transformer().transform (re));503 gatherTests(UTF8_Transformer().transformRE(re)); 504 504 } else { 505 505 for (const auto range : *cc) { -
icGREP/icgrep-devel/icgrep/re/re_compiler.cpp
r6160 r6170 129 129 return makeMarker(FinalMatchUnit, pb.createAnd(nextPos, pb.createInFile(mCCCompiler.compileCC(cc, pb)))); 130 130 } else if (a == &cc::Unicode) { 131 MarkerType m = compile(UTF8_Transformer().transform (cc), pb);131 MarkerType m = compile(UTF8_Transformer().transformRE(cc), pb); 132 132 if (isByteLength(cc)) { 133 133 if (marker.pos == FinalMatchUnit) { -
icGREP/icgrep-devel/icgrep/re/re_local.cpp
r6160 r6170 10 10 #include <re/re_analysis.h> 11 11 #include <re/re_nullable.h> 12 #include <re/re_ utility.h>12 #include <re/re_toolchain.h> 13 13 #include <boost/container/flat_map.hpp> 14 14 #include <boost/range/adaptor/reversed.hpp> -
icGREP/icgrep-devel/icgrep/re/re_multiplex.cpp
r6167 r6170 12 12 #include <re/re_memoizer.hpp> 13 13 #include <re/printer_re.h> 14 #include <re/re_toolchain.h> 14 15 #include <UCD/ucd_compiler.hpp> 15 16 #include <UCD/resolve_properties.h> … … 30 31 class CC_multiplexer : public RE_Transformer { 31 32 public: 32 CC_multiplexer(cc::MultiplexedAlphabet * mpx) : RE_Transformer(), mMultiplexedAlphabet(mpx) {} 33 CC_multiplexer(cc::MultiplexedAlphabet * mpx) : 34 RE_Transformer("Multiplex_" + mpx->getName()), mMultiplexedAlphabet(mpx) {} 33 35 RE * transformCC(CC *) override; 34 36 RE * transformName(Name *) override; … … 58 60 59 61 RE * transformCCs(cc::MultiplexedAlphabet * mpx, RE * re) { 60 return CC_multiplexer(mpx).transform (re);62 return CC_multiplexer(mpx).transformRE(re); 61 63 } 62 64 -
icGREP/icgrep-devel/icgrep/re/re_name_resolve.cpp
r6161 r6170 15 15 #include <re/re_end.h> 16 16 #include <re/re_any.h> 17 #include <re/re_ utility.h>17 #include <re/re_toolchain.h> 18 18 #include <re/re_memoizer.hpp> 19 19 #include <UCD/resolve_properties.h> … … 30 30 class UnicodeNameResolver : public RE_Transformer { 31 31 public: 32 UnicodeNameResolver() : RE_Transformer( ) {}32 UnicodeNameResolver() : RE_Transformer("UnicodeNames") {} 33 33 RE * transformName(Name * name) override; 34 34 private: … … 57 57 58 58 RE * resolveUnicodeNames(RE * re) { 59 return UnicodeNameResolver().transform (re);59 return UnicodeNameResolver().transformRE(re); 60 60 } 61 61 … … 100 100 101 101 RE * resolveAnchors(RE * r, RE * breakRE) { 102 return AnchorResolution(breakRE).transform (r);102 return AnchorResolution(breakRE).transformRE(r); 103 103 } 104 104 -
icGREP/icgrep-devel/icgrep/re/re_star_normal.h
r6160 r6170 2 2 #define RE_STAR_NORMAL_H 3 3 4 #include <re/re_ utility.h>4 #include <re/re_toolchain.h> 5 5 6 6 namespace re { … … 20 20 21 21 class RE_Star_Normal : public RE_Transformer { 22 23 22 public: 23 RE_Star_Normal() : RE_Transformer("StarNormal") {} 24 24 RE * transformRep(Rep * rep) override; 25 25 }; -
icGREP/icgrep-devel/icgrep/re/re_toolchain.cpp
r6161 r6170 8 8 #include <grep_interface.h> 9 9 #include <re/re_toolchain.h> 10 #include <re/re_any.h> 11 #include <re/re_name.h> 12 #include <re/re_cc.h> 13 #include <re/re_start.h> 14 #include <re/re_end.h> 15 #include <re/re_alt.h> 16 #include <re/re_seq.h> 17 #include <re/re_diff.h> 18 #include <re/re_intersect.h> 19 #include <re/re_group.h> 20 #include <re/re_range.h> 21 #include <re/re_assertion.h> 10 22 #include <cc/cc_compiler.h> // for CC_Compiler 11 23 #include <llvm/Support/CommandLine.h> // for clEnumVal, clEnumValEnd, Optio... … … 72 84 } 73 85 r = re::resolveUnicodeNames(r); 74 if (PrintOptions.isSet(ShowAllREs)) {75 errs() << "resolveUnicodeNames:\n" << Printer_RE::PrintRE(r) << '\n';76 }77 86 r = resolveCaseInsensitiveMode(r, globallyCaseInsensitive); 78 if (PrintOptions.isSet(ShowAllREs)) {79 errs() << "resolveCaseInsensitiveMode:\n" << Printer_RE::PrintRE(r) << '\n';80 }81 87 return r; 82 88 } … … 101 107 errs() << "RemoveNullableSuffix:\n" << Printer_RE::PrintRE(r) << '\n'; 102 108 } 103 r = RE_Star_Normal().transform(r); 104 if (PrintOptions.isSet(ShowAllREs) || PrintOptions.isSet(ShowSimplifiedREs)) { 105 //Print to the terminal the AST that was transformed to the star normal form. 106 errs() << "Star_Normal_Form:\n" << Printer_RE::PrintRE(r) << '\n'; 107 } 109 r = RE_Star_Normal().transformRE(r); 108 110 if (codegen::OptLevel > 1) { 109 111 r = RE_Minimizer::minimize(r); … … 121 123 return r; 122 124 } 123 124 } 125 RE * RE_Transformer::transformRE(RE * re) { 126 RE * initialRE = re; 127 RE * finalRE = transform(re); 128 if (PrintOptions.isSet(ShowAllREs) && (initialRE != finalRE) && (mTransformationName != "")) { 129 errs() << mTransformationName << ":\n" << Printer_RE::PrintRE(finalRE) << '\n'; 130 } 131 return finalRE; 132 } 133 134 RE * RE_Transformer::transform(RE * re) { 135 if (llvm::isa<CC>(re)) return transformCC(llvm::cast<CC>(re)); 136 else if (llvm::isa<Start>(re)) return transformStart(llvm::cast<Start>(re)); 137 else if (llvm::isa<End>(re)) return transformEnd(llvm::cast<End>(re)); 138 else if (llvm::isa<Name>(re)) return transformName(llvm::cast<Name>(re)); 139 else if (llvm::isa<Seq>(re)) return transformSeq(llvm::cast<Seq>(re)); 140 else if (llvm::isa<Alt>(re)) return transformAlt(llvm::cast<Alt>(re)); 141 else if (llvm::isa<Rep>(re)) return transformRep(llvm::cast<Rep>(re)); 142 else if (llvm::isa<Intersect>(re)) return transformIntersect(llvm::cast<Intersect>(re)); 143 else if (llvm::isa<Diff>(re)) return transformDiff(llvm::cast<Diff>(re)); 144 else if (llvm::isa<Range>(re)) return transformRange(llvm::cast<Range>(re)); 145 else if (llvm::isa<Group>(re)) return transformGroup(llvm::cast<Group>(re)); 146 else if (llvm::isa<Assertion>(re)) return transformAssertion(llvm::cast<Assertion>(re)); 147 else { 148 llvm_unreachable("Unknown RE type"); 149 return nullptr; 150 } 151 } 152 153 RE * RE_Transformer::transformName(Name * nm) { 154 if (mNameTransform == NameTransformationMode::None) return nm; 155 RE * d = nm->getDefinition(); 156 if (d) return transform(d); 157 UndefinedNameError(nm); 158 return nullptr; 159 } 160 161 RE * RE_Transformer::transformCC(CC * cc) { 162 return cc; 163 } 164 165 RE * RE_Transformer::transformStart(Start * s) { 166 return s; 167 } 168 169 RE * RE_Transformer::transformEnd(End * e) { 170 return e; 171 } 172 173 RE * RE_Transformer::transformSeq(Seq * seq) { 174 std::vector<RE *> elems; 175 elems.reserve(seq->size()); 176 bool any_changed = false; 177 for (RE * e : *seq) { 178 RE * e1 = transform(e); 179 if (e1 != e) any_changed = true; 180 elems.push_back(e1); 181 } 182 if (!any_changed) return seq; 183 return makeSeq(elems.begin(), elems.end()); 184 } 185 186 RE * RE_Transformer::transformAlt(Alt * alt) { 187 std::vector<RE *> elems; 188 elems.reserve(alt->size()); 189 bool any_changed = false; 190 for (RE * e : *alt) { 191 RE * e1 = transform(e); 192 if (e1 != e) any_changed = true; 193 elems.push_back(e1); 194 } 195 if (!any_changed) return alt; 196 return makeAlt(elems.begin(), elems.end()); 197 } 198 199 RE * RE_Transformer::transformRep(Rep * r) { 200 RE * x0 = r->getRE(); 201 RE * x = transform(x0); 202 if (x == x0) { 203 return r; 204 } else { 205 return makeRep(x, r->getLB(), r->getUB()); 206 } 207 } 208 209 RE * RE_Transformer::transformIntersect(Intersect * ix) { 210 RE * x0 = ix->getLH(); 211 RE * y0 = ix->getRH(); 212 RE * x = transform(x0); 213 RE * y = transform(y0); 214 if ((x == x0) && (y == y0)) { 215 return ix; 216 } else { 217 return makeIntersect(x, y); 218 } 219 } 220 221 RE * RE_Transformer::transformDiff(Diff * d) { 222 RE * x0 = d->getLH(); 223 RE * y0 = d->getRH(); 224 RE * x = transform(x0); 225 RE * y = transform(y0); 226 if ((x == x0) && (y == y0)) { 227 return d; 228 } else { 229 return makeDiff(x, y); 230 } 231 } 232 233 RE * RE_Transformer::transformRange(Range * rg) { 234 RE * x0 = rg->getLo(); 235 RE * y0 = rg->getHi(); 236 RE * x = transform(x0); 237 RE * y = transform(y0); 238 if ((x == x0) && (y == y0)) { 239 return rg; 240 } else { 241 return makeRange(x, y); 242 } 243 } 244 245 RE * RE_Transformer::transformGroup(Group * g) { 246 RE * x0 = g->getRE(); 247 RE * x = transform(x0); 248 if (x == x0) { 249 return g; 250 } else { 251 return makeGroup(g->getMode(), x, g->getSense()); 252 } 253 } 254 255 RE * RE_Transformer::transformAssertion(Assertion * a) { 256 RE * x0 = a->getAsserted(); 257 RE * x = transform(x0); 258 if (x == x0) { 259 return a; 260 } else { 261 return makeAssertion(x, a->getKind(), a->getSense()); 262 } 263 } 264 265 } -
icGREP/icgrep-devel/icgrep/re/re_toolchain.h
r5945 r6170 7 7 #ifndef RE_TOOLCHAIN_H 8 8 #define RE_TOOLCHAIN_H 9 #include <string> 9 10 #include <llvm/Support/Compiler.h> 10 11 namespace llvm { namespace cl { class OptionCategory; } } 11 12 namespace pablo { class PabloKernel; class PabloAST; } 12 13 namespace re { class RE; class CC;} 14 namespace re { class Name; class Start; class End; class CC; class Seq; class Alt; 15 class Rep; class Intersect; class Diff; class Range; class Group; 16 class Assertion; 17 } 13 18 14 19 namespace re { … … 28 33 29 34 const llvm::cl::OptionCategory * LLVM_READONLY re_toolchain_flags(); 35 36 37 void UndefinedNameError (const Name * n); 38 39 enum class NameTransformationMode {None, TransformDefinition}; 40 41 class RE_Transformer { 42 public: 43 RE_Transformer(std::string transformationName = "", 44 NameTransformationMode m = NameTransformationMode::None) : 45 mTransformationName(transformationName), mNameTransform(m) {} 46 RE * transformRE(RE * r); 47 protected: 48 RE * transform(RE * r); 49 virtual RE * transformName(Name * n); 50 virtual RE * transformStart(Start * s); 51 virtual RE * transformEnd(End * e); 52 virtual RE * transformCC(CC * cc); 53 virtual RE * transformSeq(Seq * s); 54 virtual RE * transformAlt(Alt * a); 55 virtual RE * transformRep(Rep * rep); 56 virtual RE * transformIntersect(Intersect * e); 57 virtual RE * transformDiff(Diff * d); 58 virtual RE * transformRange(Range * rg); 59 virtual RE * transformGroup(Group * g); 60 virtual RE * transformAssertion(Assertion * a); 61 62 std::string mTransformationName; 63 NameTransformationMode mNameTransform; 64 }; 30 65 31 66 RE * resolveModesAndExternalSymbols(RE * r, bool globallyCaseInsensitive = false); -
icGREP/icgrep-devel/icgrep/re/re_utility.cpp
r6160 r6170 72 72 } 73 73 74 75 RE * RE_Transformer::transform(RE * re) {76 if (llvm::isa<CC>(re)) return transformCC(llvm::cast<CC>(re));77 else if (llvm::isa<Start>(re)) return transformStart(llvm::cast<Start>(re));78 else if (llvm::isa<End>(re)) return transformEnd(llvm::cast<End>(re));79 else if (llvm::isa<Name>(re)) return transformName(llvm::cast<Name>(re));80 else if (llvm::isa<Seq>(re)) return transformSeq(llvm::cast<Seq>(re));81 else if (llvm::isa<Alt>(re)) return transformAlt(llvm::cast<Alt>(re));82 else if (llvm::isa<Rep>(re)) return transformRep(llvm::cast<Rep>(re));83 else if (llvm::isa<Intersect>(re)) return transformIntersect(llvm::cast<Intersect>(re));84 else if (llvm::isa<Diff>(re)) return transformDiff(llvm::cast<Diff>(re));85 else if (llvm::isa<Range>(re)) return transformRange(llvm::cast<Range>(re));86 else if (llvm::isa<Group>(re)) return transformGroup(llvm::cast<Group>(re));87 else if (llvm::isa<Assertion>(re)) return transformAssertion(llvm::cast<Assertion>(re));88 else {89 llvm_unreachable("Unknown RE type");90 return nullptr;91 }92 74 } 93 94 RE * RE_Transformer::transformName(Name * nm) {95 if (mNameTransform == NameTransformationMode::None) return nm;96 RE * d = nm->getDefinition();97 if (d) return transform(d);98 UndefinedNameError(nm);99 return nullptr;100 }101 102 RE * RE_Transformer::transformCC(CC * cc) {103 return cc;104 }105 106 RE * RE_Transformer::transformStart(Start * s) {107 return s;108 }109 110 RE * RE_Transformer::transformEnd(End * e) {111 return e;112 }113 114 RE * RE_Transformer::transformSeq(Seq * seq) {115 std::vector<RE *> elems;116 elems.reserve(seq->size());117 bool any_changed = false;118 for (RE * e : *seq) {119 RE * e1 = transform(e);120 if (e1 != e) any_changed = true;121 elems.push_back(e1);122 }123 if (!any_changed) return seq;124 return makeSeq(elems.begin(), elems.end());125 }126 127 RE * RE_Transformer::transformAlt(Alt * alt) {128 std::vector<RE *> elems;129 elems.reserve(alt->size());130 bool any_changed = false;131 for (RE * e : *alt) {132 RE * e1 = transform(e);133 if (e1 != e) any_changed = true;134 elems.push_back(e1);135 }136 if (!any_changed) return alt;137 return makeAlt(elems.begin(), elems.end());138 }139 140 RE * RE_Transformer::transformRep(Rep * r) {141 RE * x0 = r->getRE();142 RE * x = transform(x0);143 if (x == x0) {144 return r;145 } else {146 return makeRep(x, r->getLB(), r->getUB());147 }148 }149 150 RE * RE_Transformer::transformIntersect(Intersect * ix) {151 RE * x0 = ix->getLH();152 RE * y0 = ix->getRH();153 RE * x = transform(x0);154 RE * y = transform(y0);155 if ((x == x0) && (y == y0)) {156 return ix;157 } else {158 return makeIntersect(x, y);159 }160 }161 162 RE * RE_Transformer::transformDiff(Diff * d) {163 RE * x0 = d->getLH();164 RE * y0 = d->getRH();165 RE * x = transform(x0);166 RE * y = transform(y0);167 if ((x == x0) && (y == y0)) {168 return d;169 } else {170 return makeDiff(x, y);171 }172 }173 174 RE * RE_Transformer::transformRange(Range * rg) {175 RE * x0 = rg->getLo();176 RE * y0 = rg->getHi();177 RE * x = transform(x0);178 RE * y = transform(y0);179 if ((x == x0) && (y == y0)) {180 return rg;181 } else {182 return makeRange(x, y);183 }184 }185 186 RE * RE_Transformer::transformGroup(Group * g) {187 RE * x0 = g->getRE();188 RE * x = transform(x0);189 if (x == x0) {190 return g;191 } else {192 return makeGroup(g->getMode(), x, g->getSense());193 }194 }195 196 RE * RE_Transformer::transformAssertion(Assertion * a) {197 RE * x0 = a->getAsserted();198 RE * x = transform(x0);199 if (x == x0) {200 return a;201 } else {202 return makeAssertion(x, a->getKind(), a->getSense());203 }204 }205 206 } -
icGREP/icgrep-devel/icgrep/re/re_utility.h
r6160 r6170 8 8 #define RE_UTILITY_H 9 9 10 namespace re { class RE; } 11 namespace re { class Name; class Start; class End; class CC; class Seq; class Alt; 12 class Rep; class Intersect; class Diff; class Range; class Group; 13 class Assertion; 14 } 10 namespace re { class RE; class Name;} 15 11 16 12 namespace re { … … 27 23 RE * makeUnicodeBreak(); 28 24 29 void UndefinedNameError (const Name * n);30 31 enum class NameTransformationMode {None, TransformDefinition};32 33 class RE_Transformer {34 public:35 RE_Transformer(NameTransformationMode m = NameTransformationMode::None) : mNameTransform(m) {}36 RE * transform(RE * r);37 virtual RE * transformName(Name * n);38 virtual RE * transformStart(Start * s);39 virtual RE * transformEnd(End * e);40 virtual RE * transformCC(CC * cc);41 virtual RE * transformSeq(Seq * s);42 virtual RE * transformAlt(Alt * a);43 virtual RE * transformRep(Rep * rep);44 virtual RE * transformIntersect(Intersect * e);45 virtual RE * transformDiff(Diff * d);46 virtual RE * transformRange(Range * rg);47 virtual RE * transformGroup(Group * g);48 virtual RE * transformAssertion(Assertion * a);49 protected:50 NameTransformationMode mNameTransform;51 };52 53 25 } 54 26 #endif // RE_UTILITY_H -
icGREP/icgrep-devel/icgrep/re/to_utf8.h
r6160 r6170 9 9 10 10 #include <re/re_re.h> 11 #include <re/re_ utility.h>11 #include <re/re_toolchain.h> 12 12 13 13 namespace re { … … 16 16 class UTF8_Transformer : public RE_Transformer { 17 17 public: 18 UTF8_Transformer(NameTransformationMode m = NameTransformationMode::None) : RE_Transformer( m) {}18 UTF8_Transformer(NameTransformationMode m = NameTransformationMode::None) : RE_Transformer("ToUTF8", m) {} 19 19 RE * transformCC(CC * cc) override; 20 20 }; 21 21 22 22 inline RE * toUTF8(RE * r, bool convertName = false) { 23 return UTF8_Transformer(convertName ? NameTransformationMode::TransformDefinition : NameTransformationMode::None ).transform (r);}23 return UTF8_Transformer(convertName ? NameTransformationMode::TransformDefinition : NameTransformationMode::None ).transformRE(r);} 24 24 } 25 25 #endif // TO_UTF8_H
Note: See TracChangeset
for help on using the changeset viewer.