Changeset 4852


Ignore:
Timestamp:
Oct 24, 2015, 2:54:17 PM (2 years ago)
Author:
nmedfort
Message:

Bug fix for \N{..} + minor optimization changes.

Location:
icGREP/icgrep-devel/icgrep
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/pablo/optimizers/pablo_simplifier.cpp

    r4841 r4852  
    8080                        case 2: return block.createOr(block.createNot(stmt->getOperand(0)), stmt->getOperand(1));
    8181                    }
     82                case PabloAST::ClassTypeId::ScanThru:
     83                    if (i == 1) {
     84                        return block.createZeroes();
     85                    }
     86                    break;
     87                case PabloAST::ClassTypeId::MatchStar:
     88                    if (i == 0) {
     89                        return block.createOnes();
     90                    }
     91                    break;
    8292                default: break;
    8393            }
  • icGREP/icgrep-devel/icgrep/re/re_alt.h

    r4516 r4852  
    1010#include "re_re.h"
    1111#include "re_cc.h"
    12 #include <queue>
    1312
    1413namespace re {
     
    3534private:
    3635    template<typename iterator>
    37     void flatten(iterator begin, iterator end, std::queue<CC*> & ccQ) {
     36    void flatten(iterator begin, iterator end) {
    3837        for (auto i = begin; i != end; ++i) {
    39             if (Alt * alt = dyn_cast<Alt>(*i)) {
    40                 flatten(alt->begin(), alt->end(), ccQ);
    41                 continue;
     38            if (LLVM_UNLIKELY(isa<Alt>(*i))) {
     39                flatten<Alt::iterator>(cast<Alt>(*i)->begin(), cast<Alt>(*i)->end());
     40            } else {
     41                push_back(*i);
    4242            }
    43             else if (CC * cc = dyn_cast<CC>(*i)) {
    44                 ccQ.push(cc);
    45                 continue;
    46             }
    47             push_back(*i);
    4843        }
    4944    }
     
    6661template<typename iterator>
    6762RE * makeAlt(iterator begin, iterator end) {
    68     Alt * alt = makeAlt();
    69     std::queue<CC*> ccQ;
    70     alt->flatten(begin, end, ccQ);
    71     if (!ccQ.empty()) {
    72         while (ccQ.size() > 1) {
    73             CC * a = ccQ.front(); ccQ.pop();
    74             CC * b = ccQ.front(); ccQ.pop();
    75             ccQ.push(makeCC(a, b));
     63    if (LLVM_UNLIKELY(std::distance(begin, end) == 0)) {
     64        throw std::runtime_error("Alt objects cannot be empty!");
     65    } else if (std::distance(begin, end) == 1) {
     66        return *begin;
     67    } else {
     68        Alt * alt = makeAlt();
     69        alt->flatten(begin, end);
     70        if (alt->size() == 1) {
     71            return alt->front();
    7672        }
    77         alt->push_back(ccQ.front());
     73        return alt;
    7874    }
    79     if (alt->size() == 1) {
    80         return alt->back();
    81     }
    82     return alt;
    8375}
    8476
  • icGREP/icgrep-devel/icgrep/re/re_compiler.cpp

    r4850 r4852  
    264264
    265265    std::function<void(RE*)> gather = [&](RE * re) {
    266         if (Name * name = dyn_cast<Name>(re)) {
    267             if (visited.insert(name).second) {
    268                 if (isa<CC>(name->getDefinition())) {
    269                     nameMap.emplace(name, nullptr);
     266        if (isa<Name>(re)) {
     267            if (visited.insert(cast<Name>(re)).second) {
     268                if (isa<CC>(cast<Name>(re)->getDefinition())) {
     269                    nameMap.emplace(cast<Name>(re), nullptr);
    270270                } else {
    271                     gather(name->getDefinition());
     271                    gather(cast<Name>(re)->getDefinition());
    272272                }
    273273            }
    274         } else if (Seq * seq = dyn_cast<Seq>(re)) {
    275             for (auto re : *seq) {
     274        } else if (isa<Seq>(re)) {
     275            for (RE * re : *cast<Seq>(re)) {
    276276                gather(re);
    277277            }
    278         } else if (Alt * alt = dyn_cast<Alt>(re)) {
    279             for (auto re : *alt) {
     278        } else if (isa<Alt>(re)) {
     279            for (RE * re : *cast<Alt>(re)) {
    280280                gather(re);
    281281            }
    282         } else if (Rep * rep = dyn_cast<Rep>(re)) {
    283             gather(rep->getRE());
    284         } else if (Assertion * a = dyn_cast<Assertion>(re)) {
    285             gather(a->getAsserted());
    286         } else if (Diff * diff = dyn_cast<Diff>(re)) {
    287             gather(diff->getLH());
    288             gather(diff->getRH());
    289         } else if (Intersect * ix = dyn_cast<Intersect>(re)) {
    290             gather(ix->getLH());
    291             gather(ix->getRH());
    292         } else if (GraphemeBoundary * gb = dyn_cast<GraphemeBoundary>(re)) {
    293             if (gb->getExpression()) {
    294                 gather(gb->getExpression());
    295             }
    296             gather(gb->getBoundaryRule());
     282        } else if (isa<Rep>(re)) {
     283            gather(cast<Rep>(re)->getRE());
     284        } else if (isa<Assertion>(re)) {
     285            gather(cast<Assertion>(re)->getAsserted());
     286        } else if (isa<Diff>(re)) {
     287            gather(cast<Diff>(re)->getLH());
     288            gather(cast<Diff>(re)->getRH());
     289        } else if (isa<Intersect>(re)) {
     290            gather(cast<Intersect>(re)->getLH());
     291            gather(cast<Intersect>(re)->getRH());
     292        } else if (isa<GraphemeBoundary>(re)) {
     293            if (cast<GraphemeBoundary>(re)->getExpression()) {
     294                gather(cast<GraphemeBoundary>(re)->getExpression());
     295            }
     296            gather(cast<GraphemeBoundary>(re)->getBoundaryRule());
    297297        }
    298298    };
     
    378378
    379379MarkerType RE_Compiler::process(RE * re, MarkerType marker, PabloBuilder & pb) {
    380     if (Name * name = dyn_cast<Name>(re)) {
    381         return compileName(name, marker, pb);
    382     } else if (Seq* seq = dyn_cast<Seq>(re)) {
    383         return compileSeq(seq, marker, pb);
    384     } else if (Alt * alt = dyn_cast<Alt>(re)) {
    385         return compileAlt(alt, marker, pb);
    386     } else if (Rep * rep = dyn_cast<Rep>(re)) {
    387         return compileRep(rep, marker, pb);
    388     } else if (Assertion * a = dyn_cast<Assertion>(re)) {
    389         return compileAssertion(a, marker, pb);
     380    if (isa<Name>(re)) {
     381        return compileName(cast<Name>(re), marker, pb);
     382    } else if (isa<Seq>(re)) {
     383        return compileSeq(cast<Seq>(re), marker, pb);
     384    } else if (isa<Alt>(re)) {
     385        return compileAlt(cast<Alt>(re), marker, pb);
     386    } else if (isa<Rep>(re)) {
     387        return compileRep(cast<Rep>(re), marker, pb);
     388    } else if (isa<Assertion>(re)) {
     389        return compileAssertion(cast<Assertion>(re), marker, pb);
    390390    } else if (isa<Any>(re)) {
    391391        return compileAny(marker, pb);
    392     } else if (Diff * diff = dyn_cast<Diff>(re)) {
    393         return compileDiff(diff, marker, pb);
    394     } else if (Intersect * ix = dyn_cast<Intersect>(re)) {
    395         return compileIntersect(ix, marker, pb);
     392    } else if (isa<Diff>(re)) {
     393        return compileDiff(cast<Diff>(re), marker, pb);
     394    } else if (isa<Intersect>(re)) {
     395        return compileIntersect(cast<Intersect>(re), marker, pb);
    396396    } else if (isa<Start>(re)) {
    397397        return compileStart(marker, pb);
    398398    } else if (isa<End>(re)) {
    399399        return compileEnd(marker, pb);
    400     } else if (GraphemeBoundary * gb = dyn_cast<GraphemeBoundary>(re)) {
    401         return compileGraphemeBoundary(gb, marker, pb);
     400    } else if (isa<GraphemeBoundary>(re)) {
     401        return compileGraphemeBoundary(cast<GraphemeBoundary>(re), marker, pb);
    402402    }
    403403    throw std::runtime_error("RE Compiler failed to process " + Printer_RE::PrintRE(re));
  • icGREP/icgrep-devel/icgrep/re/re_parser.cpp

    r4841 r4852  
    2424#include <pablo/pablo_compiler.h>
    2525#include <do_grep.h>
    26 
    2726#include <sstream>
    2827#include <algorithm>
     
    9493            break;
    9594        }
    96         seq.push_back(extend_item(re));
    97     }
    98     //  Note: empty sequences are legal.
     95        re = extend_item(re);
     96        seq.push_back(re);
     97    }
    9998    return makeSeq(seq.begin(), seq.end());
    10099}
    101100
    102101RE * RE_Parser::parse_next_item() {
    103     if (mCursor.more()) {
     102    if (mCursor.more()) {       
    104103        switch (*mCursor) {
    105104            case '(':
     
    416415            }
    417416            ++mCursor;
     417            assert (re);
    418418            return re;
    419419        default:
     
    512512}
    513513
    514 RE * RE_Parser::parseNamePatternExpression(){
     514Name * RE_Parser::parseNamePatternExpression(){
    515515
    516516    ModeFlagSet outerFlags = fModeFlagSet;
     
    538538    try {
    539539        nameSearchIR = pablo_compiler.compile(nameSearchFunction);
    540         releaseSlabAllocatorMemory();
    541540    }
    542541    catch (std::runtime_error e) {
     
    550549    // Ensure everything is ready to go.
    551550    engine->finalizeObject();
    552    
    553     void * icgrep_init_carry_ptr = engine->getPointerToFunction(nameSearchIR->getParent()->getFunction("process_block_initialize_carries"));
    554     void * icgrep_MCptr = engine->getPointerToFunction(nameSearchIR);
    555    
    556     CC * result = nullptr;
     551       
     552    void * icgrep_MCptr = engine->getPointerToFunction(nameSearchIR);   
     553    CC * codepoints = nullptr;
    557554    if (icgrep_MCptr) {
     555        void * icgrep_init_carry_ptr = engine->getPointerToFunction(nameSearchIR->getParent()->getFunction("process_block_initialize_carries"));
    558556        GrepExecutor grepEngine(icgrep_init_carry_ptr, icgrep_MCptr);
    559557        grepEngine.setParseCodepointsOption();
    560558        grepEngine.doGrep("../Uname.txt");
    561         result = grepEngine.getParsedCodepoints();
     559        codepoints = grepEngine.getParsedCodepoints();
     560        assert (codepoints);
    562561    }
    563562    delete engine;
    564     return mMemoizer.memoize(result);
     563    if (codepoints) {
     564        Name * const result = mMemoizer.memoize(codepoints);
     565        assert (*cast<CC>(result->getDefinition()) == *codepoints);
     566        return result;
     567    }
     568    return nullptr;
    565569}
    566570
  • icGREP/icgrep-devel/icgrep/re/re_parser.h

    r4831 r4852  
    137137    RE * parsePropertyExpression();
    138138
    139     RE * parseNamePatternExpression();
     139    Name * parseNamePatternExpression();
    140140
    141141    RE * makeComplement(RE * s);
  • icGREP/icgrep-devel/icgrep/re/re_seq.h

    r4516 r4852  
    4444void Seq::flatten(itr begin, itr end) {
    4545    for (auto i = begin; i != end; ++i) {
    46         if (Seq * seq = dyn_cast<Seq>(*i)) {
    47             flatten<Seq::iterator>(seq->begin(), seq->end());
    48             continue;
     46        if (LLVM_UNLIKELY(isa<Seq>(*i))) {
     47            flatten<Seq::iterator>(cast<Seq>(*i)->begin(), cast<Seq>(*i)->end());
     48        } else {
     49            push_back(*i);
    4950        }
    50         push_back(*i);
    5151    }
    5252}
     
    5454template<typename itr>
    5555inline RE * makeSeq(itr begin, itr end) {
    56     Seq * seq = makeSeq();
    57     seq->flatten(begin, end);
    58     if (seq->size() == 1) {
    59         return seq->back();
     56    if (LLVM_UNLIKELY(std::distance(begin, end) == 0)) {
     57        return makeSeq();
     58    } else if (std::distance(begin, end) == 1) {
     59        return *begin;
     60    } else {
     61        Seq * seq = makeSeq();
     62        seq->flatten(begin, end);
     63        if (seq->size() == 1) {
     64            return seq->front();
     65        }
     66        return seq;
    6067    }
    61     return seq;
    6268}
    6369
Note: See TracChangeset for help on using the changeset viewer.