Ignore:
Timestamp:
Nov 6, 2016, 8:37:11 PM (3 years ago)
Author:
nmedfort
Message:

Initial work on adding types to PabloAST and mutable Var objects.

Location:
icGREP/icgrep-devel/icgrep/re
Files:
5 edited

Legend:

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

    r5189 r5202  
    5353
    5454void RE_Compiler::initializeRequiredStreams_utf16() {
    55     Assign * LF = mPB.createAssign("LF", mCCCompiler.compileCC(makeCC(0x000A)));
    56     PabloAST * CR = mCCCompiler.compileCC(makeCC(0x000D));
     55
     56
     57
     58    PabloAST * LF = mCCCompiler.compileCC("LF", makeCC(0x000A), mPB);
     59    PabloAST * CR = mCCCompiler.compileCC("CR", makeCC(0x000D), mPB);
    5760    PabloAST * LF_VT_FF_CR = mCCCompiler.compileCC(makeCC(0x000A, 0x000D));
    58     Assign * NEL = mPB.createAssign("NEL", mCCCompiler.compileCC(makeCC(0x0085)));
    59     Assign * LS_PS = mPB.createAssign("LS_PS", mCCCompiler.compileCC(makeCC(0x2028, 0x2029)));
    60     Assign * NEL_LS_PS = mPB.createAssign("NEL_LS_PS", mPB.createOr(NEL, LS_PS));
     61    PabloAST * NEL = mCCCompiler.compileCC("NEL", makeCC(0x0085), mPB);
     62    PabloAST * LS_PS = mCCCompiler.compileCC("LS_PS", makeCC(0x2028, 0x2029), mPB);
     63    PabloAST * NEL_LS_PS = mPB.createOr(NEL, LS_PS, "NEL_LS_PS");
    6164
    6265    PabloAST * cr1 = mPB.createAdvance(CR, 1, "cr1");
    63     Assign * acrlf = mPB.createAssign("crlf", mPB.createAnd(cr1, LF));
    64     mCRLF = acrlf;
     66    mCRLF = mPB.createAnd(cr1, LF, "crlf");
    6567
    6668    PabloAST * hi_surrogate = mCCCompiler.compileCC(makeCC(0xD800, 0xDBFF));
     
    7072
    7173    PabloAST * invalidTemp = mPB.createAdvance(u16hi_hi_surrogate, 1, "InvalidTemp");
    72     Assign * u16invalid = mPB.createAssign("u16invalid", mPB.createXor(invalidTemp, u16hi_lo_surrogate));//errors.Unicode=pablo.Advance(u16hi_hi_surrogate) ^ u16hi_lo_surrogate
    73     Assign * u16valid = mPB.createAssign("u16valid", mPB.createNot(u16invalid));
     74    PabloAST * u16invalid = mPB.createXor(invalidTemp, u16hi_lo_surrogate, "u16invalid");
     75    // errors.Unicode=pablo.Advance(u16hi_hi_surrogate) ^ u16hi_lo_surrogate
     76    PabloAST * u16valid = mPB.createNot(u16invalid, "u16valid");
    7477
    7578    PabloAST * u16single_temp = mPB.createOr(mCCCompiler.compileCC(makeCC(0x0000, 0xD7FF)), mCCCompiler.compileCC(makeCC(0xE000, 0xFFFF)));
    7679    PabloAST * u16single = mPB.createAnd(u16single_temp, mPB.createNot(u16invalid));
    7780   
    78     mNonFinal = mPB.createAssign("nonfinal", mPB.createAnd(hi_surrogate, u16valid));
     81    mNonFinal = mPB.createAnd(hi_surrogate, u16valid, "nonfinal");
    7982    mFinal = mPB.createNot(mPB.createOr(mNonFinal, u16invalid), "final");
    8083    mInitial = mPB.createOr(u16single, hi_surrogate, "initial");
     
    8689    mLineBreak = mPB.createOr(lb, unterminatedLineAtEOF);
    8790    mAny = mPB.createNot(lb, "any");
    88     if (!mCountOnly) mFunction.setResult(1, mPB.createAssign("lf", mLineBreak));
    89     return;
    9091}
    9192void RE_Compiler::initializeRequiredStreams_utf8() {
    92     Assign * LF = mPB.createAssign("LF", mCCCompiler.compileCC(makeCC(0x0A)));
     93    PabloAST * LF = mCCCompiler.compileCC("LF", makeCC(0x0A), mPB);
    9394    PabloAST * CR = mCCCompiler.compileCC(makeCC(0x0D));
    9495    PabloAST * LF_VT_FF_CR = mCCCompiler.compileCC(makeCC(0x0A, 0x0D));
    9596
     97    Zeroes * const zero = mPB.createZeroes();
     98    Var * crlf = mPB.createVar("crlf", zero);
    9699    PabloBuilder crb = PabloBuilder::Create(mPB);
    97100    PabloAST * cr1 = crb.createAdvance(CR, 1, "cr1");
    98     Assign * acrlf = crb.createAssign("crlf", crb.createAnd(cr1, LF));
    99     mPB.createIf(CR, {acrlf}, crb);
    100     mCRLF = acrlf;
     101    crb.createAssign(crlf, crb.createAnd(cr1, LF));
     102    mPB.createIf(CR, crb);
     103
     104    mCRLF = crlf;
     105
     106    Var * u8invalid = mPB.createVar("u8invalid", zero);
     107    Var * valid_pfx = mPB.createVar("valid_pfx", zero);
     108    Var * nonFinal = mPB.createVar("nonfinal", zero);
     109    Var * NEL_LS_PS = mPB.createVar("NEL_LS_PS", zero);
    101110
    102111    PabloAST * u8pfx = mCCCompiler.compileCC(makeCC(0xC0, 0xFF));
    103112    PabloBuilder it = PabloBuilder::Create(mPB);
     113    mPB.createIf(u8pfx, it);
     114
     115    mNonFinal = nonFinal;
     116
    104117    PabloAST * u8pfx2 = mCCCompiler.compileCC(makeCC(0xC2, 0xDF), it);
    105118    PabloAST * u8pfx3 = mCCCompiler.compileCC(makeCC(0xE0, 0xEF), it);
    106119    PabloAST * u8pfx4 = mCCCompiler.compileCC(makeCC(0xF0, 0xF4), it);
    107     Assign * u8suffix = it.createAssign("u8suffix", mCCCompiler.compileCC(makeCC(0x80, 0xBF)));
     120    PabloAST * u8suffix = mCCCompiler.compileCC("u8suffix", makeCC(0x80, 0xBF), it);
    108121
    109122    //
    110123    // Two-byte sequences
     124    Var * u8scope22 = it.createVar("u8scope22", zero);
     125    Var * NEL = it.createVar("NEL", zero);
    111126    PabloBuilder it2 = PabloBuilder::Create(it);
    112     Assign * u8scope22 = it2.createAssign("u8scope22", it2.createAdvance(u8pfx2, 1));
    113     Assign * NEL = it2.createAssign("NEL", it2.createAnd(it2.createAdvance(mCCCompiler.compileCC(makeCC(0xC2), it2), 1), mCCCompiler.compileCC(makeCC(0x85), it2)));
    114     it.createIf(u8pfx2, {u8scope22, NEL}, it2);
     127    it2.createAssign(u8scope22, it2.createAdvance(u8pfx2, 1));
     128    it2.createAssign(NEL, it2.createAnd(it2.createAdvance(mCCCompiler.compileCC(makeCC(0xC2), it2), 1), mCCCompiler.compileCC(makeCC(0x85), it2)));
     129    it.createIf(u8pfx2, it2);
    115130
    116131    //
    117132    // Three-byte sequences
     133    Var * u8scope32 = it.createVar("u8scope32", zero);
     134    Var * u8scope3X = it.createVar("u8scope3X", zero);
     135    Var * LS_PS = it.createVar("LS_PS", zero);
     136    Var * EX_invalid = it.createVar("EX_invalid", zero);
     137
    118138    PabloBuilder it3 = PabloBuilder::Create(it);
    119     Assign * u8scope32 = it3.createAssign("u8scope32", it3.createAdvance(u8pfx3, 1));
     139    it.createIf(u8pfx3, it3);
     140
     141    it3.createAssign(u8scope32, it3.createAdvance(u8pfx3, 1));
    120142    PabloAST * u8scope33 = it3.createAdvance(u8pfx3, 2);
    121     Assign * u8scope3X = it3.createAssign("u8scope3X", it3.createOr(u8scope32, u8scope33));
     143    it3.createAssign(u8scope3X, it3.createOr(u8scope32, u8scope33));
    122144    PabloAST * E2_80 = it3.createAnd(it3.createAdvance(mCCCompiler.compileCC(makeCC(0xE2), it3), 1), mCCCompiler.compileCC(makeCC(0x80), it3));
    123     Assign * LS_PS = it3.createAssign("LS_PS", it3.createAnd(it3.createAdvance(E2_80, 1), mCCCompiler.compileCC(makeCC(0xA8,0xA9), it3)));
     145    it3.createAssign(LS_PS, it3.createAnd(it3.createAdvance(E2_80, 1), mCCCompiler.compileCC(makeCC(0xA8,0xA9), it3)));
    124146    PabloAST * E0_invalid = it3.createAnd(it3.createAdvance(mCCCompiler.compileCC(makeCC(0xE0), it3), 1), mCCCompiler.compileCC(makeCC(0x80, 0x9F), it3));
    125147    PabloAST * ED_invalid = it3.createAnd(it3.createAdvance(mCCCompiler.compileCC(makeCC(0xED), it3), 1), mCCCompiler.compileCC(makeCC(0xA0, 0xBF), it3));
    126     Assign * EX_invalid = it3.createAssign("EX_invalid", it3.createOr(E0_invalid, ED_invalid));
    127     it.createIf(u8pfx3, {u8scope32, u8scope3X, LS_PS, EX_invalid}, it3);
     148    it3.createAssign(EX_invalid, it3.createOr(E0_invalid, ED_invalid));
     149
     150    it.createAssign(NEL_LS_PS, it.createOr(NEL, LS_PS));
    128151
    129152    //
    130153    // Four-byte sequences
     154    Var * u8scope4nonfinal = it.createVar("u8scope4nonfinal", zero);
     155    Var * u8scope4X = it.createVar("u8scope4X", zero);
     156    Var * FX_invalid = it.createVar("FX_invalid", zero);
    131157    PabloBuilder it4 = PabloBuilder::Create(it);
     158    it.createIf(u8pfx4, it4);
    132159    PabloAST * u8scope42 = it4.createAdvance(u8pfx4, 1, "u8scope42");
    133160    PabloAST * u8scope43 = it4.createAdvance(u8scope42, 1, "u8scope43");
    134161    PabloAST * u8scope44 = it4.createAdvance(u8scope43, 1, "u8scope44");
    135     Assign * u8scope4nonfinal = it4.createAssign("u8scope4nonfinal", it4.createOr(u8scope42, u8scope43));
    136     Assign * u8scope4X = it4.createAssign("u8scope4X", it4.createOr(u8scope4nonfinal, u8scope44));
     162    it4.createAssign(u8scope4nonfinal, it4.createOr(u8scope42, u8scope43));
     163    it4.createAssign(u8scope4X, it4.createOr(u8scope4nonfinal, u8scope44));
    137164    PabloAST * F0_invalid = it4.createAnd(it4.createAdvance(mCCCompiler.compileCC(makeCC(0xF0), it4), 1), mCCCompiler.compileCC(makeCC(0x80, 0x8F), it4));
    138165    PabloAST * F4_invalid = it4.createAnd(it4.createAdvance(mCCCompiler.compileCC(makeCC(0xF4), it4), 1), mCCCompiler.compileCC(makeCC(0x90, 0xBF), it4));
    139     Assign * FX_invalid = it4.createAssign("FX_invalid", it4.createOr(F0_invalid, F4_invalid));
    140     it.createIf(u8pfx4, {u8scope4nonfinal, u8scope4X, FX_invalid}, it4);
     166    it4.createAssign(FX_invalid, it4.createOr(F0_invalid, F4_invalid));
    141167
    142168    //
     
    150176    PabloAST * EF_invalid = it.createOr(EX_invalid, FX_invalid);
    151177    PabloAST * pfx_invalid = it.createXor(u8pfx, legalpfx);
    152     Assign * u8invalid = it.createAssign("u8invalid", it.createOr(pfx_invalid, it.createOr(mismatch, EF_invalid)));
    153     Assign * u8valid = it.createAssign("u8valid", it.createNot(u8invalid));
     178    it.createAssign(u8invalid, it.createOr(pfx_invalid, it.createOr(mismatch, EF_invalid)));
     179    PabloAST * u8valid = it.createNot(u8invalid, "u8valid");
    154180    //
    155181    //
    156182
    157     Assign * valid_pfx = it.createAssign("valid_pfx", it.createAnd(u8pfx, u8valid));
    158     mNonFinal = it.createAssign("nonfinal", it.createAnd(it.createOr(it.createOr(u8pfx, u8scope32), u8scope4nonfinal), u8valid));
    159 
    160     Assign * NEL_LS_PS = it.createAssign("NEL_LS_PS", it.createOr(NEL, LS_PS));
    161     mPB.createIf(u8pfx, {u8invalid, valid_pfx, mNonFinal, NEL_LS_PS}, it);
     183    it.createAssign(valid_pfx, it.createAnd(u8pfx, u8valid));
     184    it.createAssign(mNonFinal, it.createAnd(it.createOr(it.createOr(u8pfx, u8scope32), u8scope4nonfinal), u8valid));
     185
    162186
    163187    PabloAST * LB_chars = mPB.createOr(LF_VT_FF_CR, NEL_LS_PS);
     
    170194    mLineBreak = mPB.createOr(lb, unterminatedLineAtEOF);
    171195    mAny = mPB.createNot(lb, "any");
    172     if (!mCountOnly) mFunction.setResult(1, mPB.createAssign("lf", mLineBreak));
    173196}
    174197
     
    177200    Name * ZeroWidth = nullptr;
    178201    UCD::UCDCompiler::NameMap nameMap;
    179     std::unordered_set<Name *> visited;
    180202    nameMap = resolveNames(re, ZeroWidth);
    181203   
     
    211233        match_follow = mPB.createNot(match_follow);
    212234    }
    213     Assign * matches = mPB.createAssign("matches", mPB.createAnd(match_follow, mLineBreak));
     235    PabloAST * matches = mPB.createAnd(match_follow, mLineBreak, "matches");
    214236    if (mCountOnly) {
    215         mFunction.setResultCount(mPB.createCount("matchedLineCount", matches));
    216     }
    217     else {
    218         mFunction.setResult(0, matches);
     237        Var * const output = mFunction.addResult("matchedLineCount", getScalarTy(64));
     238        PabloBuilder nestedCount = PabloBuilder::Create(mPB);
     239        mPB.createIf(matches, nestedCount);
     240        nestedCount.createAssign(output, nestedCount.createCount(matches));
     241    } else {
     242        Var * const output = mFunction.addResult("output", getStreamTy(1, 2));
     243        mPB.createAssign(mPB.createExtract(output, mPB.getInteger(0)), matches);
     244        mPB.createAssign(mPB.createExtract(output, mPB.getInteger(1)), mLineBreak);
    219245    }
    220246}
     
    309335
    310336MarkerType RE_Compiler::compileSeqTail(Seq::iterator current, Seq::iterator end, int matchLenSoFar, MarkerType marker, PabloBuilder & pb) {
    311     if (current == end) return marker;
    312     if (matchLenSoFar < IfInsertionGap) {
     337    if (current == end) {
     338        return marker;
     339    } else if (matchLenSoFar < IfInsertionGap) {
    313340        RE * r = *current;
    314341        marker = process(r, marker, pb);
     
    316343        return compileSeqTail(current, end, matchLenSoFar + minMatchLength(r), marker, pb);
    317344    } else {
     345        Var * m = pb.createVar("m", pb.createZeroes());
    318346        PabloBuilder nested = PabloBuilder::Create(pb);
    319347        MarkerType m1 = compileSeqTail(current, end, 0, marker, nested);
    320         Assign * m1a = nested.createAssign("m", markerVar(m1));
    321         pb.createIf(markerVar(marker), {m1a}, nested);
    322         return makeMarker(m1.pos, m1a);
     348        nested.createAssign(m, markerVar(m1));
     349        pb.createIf(markerVar(marker), nested);
     350        return makeMarker(m1.pos, m);
    323351    }
    324352}
     
    467495    }
    468496    if (lb == 1) return marker;
     497    Var * m = pb.createVar("m", pb.createZeroes());
    469498    PabloBuilder nested = PabloBuilder::Create(pb);
    470499    MarkerType m1 = processLowerBound(repeated, lb - 1, marker, nested);
    471     Assign * m1a = nested.createAssign("m", markerVar(m1));
    472     pb.createIf(markerVar(marker), {m1a}, nested);
    473     return makeMarker(m1.pos, m1a);
     500    nested.createAssign(m, markerVar(m1));
     501    pb.createIf(markerVar(marker), nested);
     502    return makeMarker(m1.pos, m);
    474503}
    475504   
     
    495524    }
    496525    if (ub == 1) return marker;
     526    Var * m1a = pb.createVar("m", pb.createZeroes());
    497527    PabloBuilder nested = PabloBuilder::Create(pb);
    498528    MarkerType m1 = processBoundedRep(repeated, ub - 1, marker, nested);
    499     Assign * m1a = nested.createAssign("m", markerVar(m1));
    500     pb.createIf(markerVar(marker), {m1a}, nested);
     529    nested.createAssign(m1a, markerVar(m1));
     530    pb.createIf(markerVar(marker), nested);
    501531    return makeMarker(m1.pos, m1a);
    502532}
     
    525555        return makeMarker(MarkerPosition::FinalPostPositionUnit, pb.createAnd(mstar, final, "unbounded"));
    526556    } else if (mStarDepth > 0){
    527         PabloBuilder * outerb = pb.getParent();
    528         Assign * starPending = outerb->createAssign("pending", outerb->createZeroes());
    529         Assign * starAccum = outerb->createAssign("accum", outerb->createZeroes());
     557        PabloBuilder * const outer = pb.getParent();
     558        Var * starPending = outer->createVar("pending", outer->createZeroes());
     559        Var * starAccum = outer->createVar("accum", outer->createZeroes());
    530560        mStarDepth++;
    531561        PabloAST * m1 = pb.createOr(base, starPending);
     
    534564        result = AdvanceMarker(result, MarkerPosition::FinalPostPositionUnit, pb);
    535565        PabloAST * loopComputation = markerVar(result);
    536         Next * nextPending = pb.createNext(starPending, pb.createAnd(loopComputation, pb.createNot(m2)));
    537         Next * nextStarAccum = pb.createNext(starAccum, pb.createOr(loopComputation, m2));
    538         mWhileTest = pb.createOr(mWhileTest, nextPending);
    539         mLoopVariants.push_back(nextPending);
    540         mLoopVariants.push_back(nextStarAccum);
    541         mStarDepth--;
    542         return makeMarker(markerPos(result), pb.createAssign("unbounded", pb.createOr(base, nextStarAccum)));
     566        pb.createAssign(starPending, pb.createAnd(loopComputation, pb.createNot(m2)));
     567        pb.createAssign(starAccum, pb.createOr(loopComputation, m2));
     568        mWhileTest = pb.createOr(mWhileTest, starPending);
     569        mStarDepth--;     
     570        return makeMarker(markerPos(result), pb.createOr(base, starAccum, "unbounded"));
    543571    } else {
    544         Assign * whileTest = pb.createAssign("test", base);
    545         Assign * whilePending = pb.createAssign("pending", base);
    546         Assign * whileAccum = pb.createAssign("accum", base);
     572        Var * whileTest = pb.createVar("test", base);
     573        Var * whilePending = pb.createVar("pending", base);
     574        Var * whileAccum = pb.createVar("accum", base);
    547575        mWhileTest = pb.createZeroes();
    548576        PabloBuilder wb = PabloBuilder::Create(pb);
     
    551579        result = AdvanceMarker(result, MarkerPosition::FinalPostPositionUnit, wb);
    552580        PabloAST * loopComputation = markerVar(result);
    553         Next * nextWhilePending = wb.createNext(whilePending, wb.createAnd(loopComputation, wb.createNot(whileAccum)));
    554         Next * nextWhileAccum = wb.createNext(whileAccum, wb.createOr(loopComputation, whileAccum));
    555         Next * nextWhileTest = wb.createNext(whileTest, wb.createOr(mWhileTest, nextWhilePending));
    556         mLoopVariants.push_back(nextWhilePending);
    557         mLoopVariants.push_back(nextWhileAccum);
    558         mLoopVariants.push_back(nextWhileTest);
    559         pb.createWhile(nextWhileTest, mLoopVariants, wb);
     581        wb.createAssign(whilePending, wb.createAnd(loopComputation, wb.createNot(whileAccum)));
     582        wb.createAssign(whileAccum, wb.createOr(loopComputation, whileAccum));
     583        wb.createAssign(whileTest, wb.createOr(mWhileTest, whilePending));
     584        pb.createWhile(whileTest, wb);
    560585        mStarDepth--;
    561         mLoopVariants.clear();
    562         return makeMarker(markerPos(result), pb.createAssign("unbounded", nextWhileAccum));
     586        return makeMarker(markerPos(result), whileAccum);
    563587    }
    564588}
     
    617641, mWhileTest(nullptr)
    618642, mStarDepth(0)
    619 , mLoopVariants()
    620 , mPB(ccCompiler.getBuilder().getPabloBlock(), ccCompiler.getBuilder())
    621 , mFunction(function)
    622 {
     643, mPB(ccCompiler.getBuilder())
     644, mFunction(function) {
    623645
    624646}
  • icGREP/icgrep-devel/icgrep/re/re_compiler.h

    r5189 r5202  
    100100    pablo::PabloAST *                               mGraphemeBoundaryRule;
    101101    pablo::PabloAST *                               mInitial;
    102     pablo::Assign *                                 mNonFinal;   
     102    pablo::PabloAST *                               mNonFinal;
    103103    pablo::PabloAST *                               mFinal;
    104104    pablo::PabloAST *                               mWhileTest;
    105105    int                                             mStarDepth;
    106     std::vector<pablo::Next *>                      mLoopVariants; // <- rethink name
    107     pablo::PabloBuilder                             mPB;
     106    pablo::PabloBuilder &                           mPB;
    108107    std::unordered_map<Name *, MarkerType>          mCompiledName;
    109108    pablo::PabloFunction &                          mFunction;
  • icGREP/icgrep-devel/icgrep/re/re_name.h

    r5091 r5202  
    4646    friend Name * makeZeroWidth(const std::string & name, RE * zerowidth);
    4747    friend Name * makeName(CC * const cc);
    48     friend Name * makeName(const std::string &, const Type);
    49     friend Name * makeName(const std::string &, const std::string &, const Type);
    50     Name(const char * nameSpace, const length_t namespaceLength, const char * name, const length_t nameLength, const Type type, RE * defn)
     48    friend Name * makeName(const std::string &, Type);
     49    friend Name * makeName(const std::string &, const std::string &, Type);
     50    Name(const char * nameSpace, const length_t namespaceLength, const char * name, const length_t nameLength, Type type, RE * defn)
    5151    : RE(ClassTypeId::Name)
    5252    , mNamespaceLength(namespaceLength)
     
    7373    const length_t      mNameLength;
    7474    const char * const  mName;
    75     const Type          mType;
     75    Type          mType;
    7676    RE *                mDefinition;
    7777};
  • icGREP/icgrep-devel/icgrep/re/re_toolchain.cpp

    r5162 r5202  
    2828static cl::OptionCategory RegexOptions("Regex Toolchain Options",
    2929                                              "These options control the regular expression transformation and compilation.");
    30 const cl::OptionCategory * re_toolchain_flags() {return &RegexOptions;};
     30const cl::OptionCategory * re_toolchain_flags() {
     31    return &RegexOptions;
     32}
    3133
    3234static cl::bits<RE_PrintFlags>
     
    9395}
    9496   
    95 PabloFunction * re2pablo_compiler(const unsigned encodingBits, RE * re_ast, bool CountOnly) {
    96     PabloFunction * function = PabloFunction::Create("process_block", encodingBits, CountOnly ? 0 : 2);
     97PabloFunction * re2pablo_compiler(const unsigned encodingBits, RE * re_ast, const bool CountOnly) {
     98    PabloFunction * function = PabloFunction::Create("process_block");
    9799    cc::CC_Compiler cc_compiler(*function, encodingBits);
    98100    re::RE_Compiler re_compiler(*function, cc_compiler, CountOnly);
     
    102104    return function;
    103105}
     106
    104107}
  • icGREP/icgrep-devel/icgrep/re/re_toolchain.h

    r5137 r5202  
    3131RE * regular_expression_passes(RE * re_ast);
    3232
    33 pablo::PabloFunction * re2pablo_compiler(const unsigned encodingBits, RE * re_ast, bool CountOnly = false);
     33pablo::PabloFunction * re2pablo_compiler(const unsigned encodingBits, RE * re_ast, const bool CountOnly = false);
    3434   
    3535}
Note: See TracChangeset for help on using the changeset viewer.