Ignore:
Timestamp:
Oct 2, 2018, 10:46:20 AM (9 months ago)
Author:
cameron
Message:

RE Transformation names and printing

File:
1 edited

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/re/re_toolchain.cpp

    r6161 r6170  
    88#include <grep_interface.h>
    99#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>
    1022#include <cc/cc_compiler.h>            // for CC_Compiler
    1123#include <llvm/Support/CommandLine.h>  // for clEnumVal, clEnumValEnd, Optio...
     
    7284    }
    7385    r = re::resolveUnicodeNames(r);
    74     if (PrintOptions.isSet(ShowAllREs)) {
    75         errs() << "resolveUnicodeNames:\n" << Printer_RE::PrintRE(r) << '\n';
    76     }
    7786    r = resolveCaseInsensitiveMode(r, globallyCaseInsensitive);
    78     if (PrintOptions.isSet(ShowAllREs)) {
    79         errs() << "resolveCaseInsensitiveMode:\n" << Printer_RE::PrintRE(r) << '\n';
    80     }
    8187    return r;
    8288}
     
    101107        errs() << "RemoveNullableSuffix:\n" << Printer_RE::PrintRE(r) << '\n';
    102108    }
    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);
    108110    if (codegen::OptLevel > 1) {
    109111        r = RE_Minimizer::minimize(r);
     
    121123    return r;
    122124}
    123 
    124 }
     125RE * 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
     134RE * 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
     153RE * 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
     161RE * RE_Transformer::transformCC(CC * cc) {
     162    return cc;
     163}
     164
     165RE * RE_Transformer::transformStart(Start * s) {
     166    return s;
     167}
     168
     169RE * RE_Transformer::transformEnd(End * e) {
     170    return e;
     171}
     172
     173RE * 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
     186RE * 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
     199RE * 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
     209RE * 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
     221RE * 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
     233RE * 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
     245RE * 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
     255RE * 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}
Note: See TracChangeset for help on using the changeset viewer.