Ignore:
Timestamp:
Oct 4, 2014, 8:40:23 AM (5 years ago)
Author:
nmedfort
Message:

Minor revisions

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

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/CMakeLists.txt

    r4207 r4209  
    193193  SET(ENABLE_AVX_1 "/arch:AVX1")
    194194  SET(ENABLE_AVX_2 "/arch:AVX2")
    195 ELSE() # using Clang, GCC, Intel C++, etc
     195ELSE() # using Clang, GCC, Intel C++, etc 
    196196  SET(ENABLE_SSE1 "-msse")
    197197  SET(ENABLE_SSE2 "-msse2")
     
    199199  SET(ENABLE_SSE4_1 "-msse4.1")
    200200  SET(ENABLE_SSE4_2 "-msse4.2")
    201   SET(ENABLE_AVX_1 "-mavx")
    202   SET(ENABLE_AVX_2 "-mavx2")   
     201  IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
     202    SET(ENABLE_AVX_1 "-mavx -fabi-version=6")
     203    SET(ENABLE_AVX_2 "-mavx2 -fabi-version=6") 
     204  ELSE()
     205    SET(ENABLE_AVX_1 "-mavx")
     206    SET(ENABLE_AVX_2 "-mavx2")
     207  ENDIF()
    203208ENDIF()
    204209
     
    235240endif(${LLVM_PACKAGE_VERSION} MATCHES "3.4")
    236241
    237 if (BLOCK_SIZE_256)
    238   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_S2P_AVX2 -DBLOCK_SIZE=256 -march=core-avx2 -mavx2 -m64 -fabi-version=6")
    239 endif()
     242IF (BLOCK_SIZE_256)
     243  IF("${SIMD_SUPPORT_FOUND}" STREQUAL "${ENABLE_AVX_2}")
     244    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUSE_S2P_AVX2 -DBLOCK_SIZE=256 -march=core-avx2 -m64")
     245  ELSE()
     246    MESSAGE(FATAL_ERROR "AVX2 is required for BLOCK_SIZE=256")
     247  ENDIF()
     248ENDIF()
    240249
    241250SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS} -O3 -DNDEBUG")
  • icGREP/icgrep-devel/icgrep/cc/cc_compiler.cpp

    r4207 r4209  
    4646namespace cc {
    4747
    48 CC_Compiler::CC_Compiler(const UTF_Encoding encoding, const std::string basis_pattern, const std::string gensym_pattern)
    49 {
    50     mEncoding = encoding;
    51     mEncoding.setBasisPattern(basis_pattern);
    52     mGenSym_Template = gensym_pattern;
    53     mGenSymCounter = 0;
    54 
    55  
     48CC_Compiler::CC_Compiler(const Encoding encoding, const std::string basis_pattern, const std::string gensym_pattern)
     49: mEncoding(encoding)
     50, mGenSymPattern(gensym_pattern)
     51, mGenSymCounter(0)
     52, mBasisPattern(basis_pattern)
     53{
    5654    for (int i = 0; i < mEncoding.getBits(); i++)
    5755    {
     
    7371{   
    7472    //Add the new mapping to the list of pablo statements:
    75     mStmtsl.push_back(make_assign(varname, expr->pablo_expr));
     73    mStmtsl.push_back(makeAssign(varname, expr->pablo_expr));
    7674
    7775    //Add the new mapping to the common expression map:
     
    7977    Expression* mapped_value = new Expression();
    8078    mapped_value->expr_string = varname;
    81     mapped_value->pablo_expr = make_var(varname);
     79    mapped_value->pablo_expr = makeVar(varname);
    8280
    8381    std::pair<MapIterator, bool> ret = mCommon_Expression_Map.insert(make_pair(key_value, mapped_value));
     
    9290    }
    9391    else {
    94         return add_assignment(mGenSym_Template + std::to_string(++mGenSymCounter), expr);
     92        return add_assignment(mGenSymPattern + std::to_string(++mGenSymCounter), expr);
    9593    }
    9694}
     
    9997{
    10098    return mStmtsl;
    101 }
    102 
    103 
    104 
    105 std::string CC_Compiler::compile1(CC * cc)
    106 {
    107   cc2pablos(cc);
    108   return cc->getName();
    10999}
    110100
     
    141131PabloE* CC_Compiler::bit_pattern_expr(int pattern, int selected_bits)
    142132{
    143     if (selected_bits == 0) return make_all(1);
     133    if (selected_bits == 0) return makeAll(1);
    144134
    145135    std::vector<PabloE*> bit_terms;
     
    153143            if ((pattern & test_bit) == 0)
    154144            {
    155                 bit_terms.push_back(make_not(make_bitv(bit_no)));
     145                bit_terms.push_back(makeNot(make_bitv(bit_no)));
    156146            }
    157147            else
     
    162152        else
    163153        {
    164             bit_terms.push_back(make_all(1));
     154            bit_terms.push_back(makeAll(1));
    165155        }
    166156        selected_bits &= ~test_bit;
     
    174164        for (unsigned long i = 0; i < (bit_terms.size()/2); i++)
    175165        {
    176             new_terms.push_back(make_and(bit_terms[(2 * i) + 1], bit_terms[2 * i]));
     166            new_terms.push_back(makeAnd(bit_terms[(2 * i) + 1], bit_terms[2 * i]));
    177167        }
    178168        if (bit_terms.size() % 2 == 1)
     
    180170            new_terms.push_back(bit_terms[bit_terms.size() -1]);
    181171        }
    182         std::vector<PabloE*>::iterator it;
    183172        bit_terms.assign(new_terms.begin(), new_terms.end());
    184173    }
     
    213202    PabloE* hi_test = LE_Range(diff_count - 1, n2 & mask1);
    214203
    215     return make_and(common, make_sel(make_bitv(diff_count - 1), hi_test, lo_test));
     204    return makeAnd(common, makeSel(make_bitv(diff_count - 1), hi_test, lo_test));
    216205}
    217206
     
    219208    if (N == 0)
    220209    {
    221         return make_all(1); //Return a true literal.
     210        return makeAll(1); //Return a true literal.
    222211    }
    223212    else if (((N % 2) == 0) && ((n >> (N - 2)) == 0))
    224213    {
    225         return make_or(make_or(make_bitv(N - 1), make_bitv(N - 2)), GE_Range(N - 2, n));
     214        return makeOr(makeOr(make_bitv(N - 1), make_bitv(N - 2)), GE_Range(N - 2, n));
    226215    }
    227216    else if (((N % 2) == 0) && ((n >> (N - 2)) == 3))
    228217    {
    229         return make_and(make_and(make_bitv(N - 1), make_bitv(N - 2)), GE_Range(N - 2, n - (3 << (N - 2))));
     218        return makeAnd(makeAnd(make_bitv(N - 1), make_bitv(N - 2)), GE_Range(N - 2, n - (3 << (N - 2))));
    230219    }
    231220    else if (N >= 1)
     
    241230              the value of GE_range(N-1), lo_range) is required.
    242231            */
    243             return make_or(make_bitv(N-1), lo_range);
     232            return makeOr(make_bitv(N-1), lo_range);
    244233        }
    245234        else
     
    249238              in the target for >= and GE_range(N-1, lo_bits) must also be true.
    250239            */
    251             return make_and(make_bitv(N-1), lo_range);
     240            return makeAnd(make_bitv(N-1), lo_range);
    252241        }
    253242    }
     
    262251    */
    263252    if ((n + 1) == (1 << N)) {
    264         return make_all(1); //True.
     253        return makeAll(1); //True.
    265254    }
    266255    else {
    267         return make_not(GE_Range(N, n + 1));
     256        return makeNot(GE_Range(N, n + 1));
    268257    }
    269258}
     
    271260PabloE* CC_Compiler::charset_expr(const CC * cc) {
    272261    if (cc->empty()) {
    273         return make_all(0);
     262        return makeAll(0);
    274263    }
    275264    if (cc->size() > 2) {
     
    300289                PabloE * bit0 = make_bitv(0);
    301290                if ((lo & 1) == 0) {
    302                     bit0 = make_not(bit0);
     291                    bit0 = makeNot(bit0);
    303292                }
    304                 return make_and(expr, bit0);
     293                return makeAnd(expr, bit0);
    305294            }
    306295        }
     
    309298    for (const CharSetItem & item : *cc) {
    310299        PabloE * temp = char_or_range_expr(item.lo_codepoint, item.hi_codepoint);
    311         expr = (expr == nullptr) ? temp : make_or(expr, temp);
     300        expr = (expr == nullptr) ? temp : makeOr(expr, temp);
    312301    }
    313302    return expr;
     
    338327        {
    339328            retExpr->expr_string = "All(1)";
    340             retExpr->pablo_expr = make_all(1);
     329            retExpr->pablo_expr = makeAll(1);
    341330        }
    342331        else if (all->getValue() == 0)
    343332        {
    344333            retExpr->expr_string = "All(0)";
    345             retExpr->pablo_expr = make_all(0);
     334            retExpr->pablo_expr = makeAll(0);
    346335        }
    347336    }
     
    349338    {
    350339            retExpr->expr_string = var->getVar();
    351             retExpr->pablo_expr = make_var(var->getVar());
     340            retExpr->pablo_expr = makeVar(var->getVar());
    352341    }
    353342    else if (Not * pe_not = dyn_cast<Not>(expr))
     
    355344        Expression* ret = expr_to_variable(expr2pabloe(pe_not->getExpr()));
    356345        retExpr->expr_string =  "~" + ret->expr_string;
    357         retExpr->pablo_expr = make_not(ret->pablo_expr);
     346        retExpr->pablo_expr = makeNot(ret->pablo_expr);
    358347    }
    359348    else if(Or * pe_or = dyn_cast<Or>(expr))
     
    362351        Expression* ret2 = expr_to_variable(expr2pabloe(pe_or->getExpr2()));
    363352        retExpr->expr_string = "(" + ret1->expr_string + "|" + ret2->expr_string + ")";
    364         retExpr->pablo_expr = make_or(ret1->pablo_expr, ret2->pablo_expr);
     353        retExpr->pablo_expr = makeOr(ret1->pablo_expr, ret2->pablo_expr);
    365354    }
    366355    else if (Xor * pe_xor = dyn_cast<Xor>(expr))
     
    369358        Expression* ret2 = expr_to_variable(expr2pabloe(pe_xor->getExpr2()));
    370359        retExpr->expr_string = "(" + ret1->expr_string + "^" + ret2->expr_string + ")";
    371         retExpr->pablo_expr = make_xor(ret1->pablo_expr, ret2->pablo_expr);
     360        retExpr->pablo_expr = makeXor(ret1->pablo_expr, ret2->pablo_expr);
    372361    }
    373362    else if (And * pe_and = dyn_cast<And>(expr))
     
    378367            Expression* ret2 = expr_to_variable(expr2pabloe(pe_and->getExpr2()));
    379368            retExpr->expr_string = "(" + ret2->expr_string + "&~" + ret1->expr_string + ")";
    380             retExpr->pablo_expr = make_and(ret2->pablo_expr, make_not(ret1->pablo_expr));
     369            retExpr->pablo_expr = makeAnd(ret2->pablo_expr, makeNot(ret1->pablo_expr));
    381370        }
    382371        else if (Not * pe_not = dyn_cast<Not>(pe_and->getExpr2()))
     
    385374            Expression* ret2 = expr_to_variable(expr2pabloe(pe_not->getExpr()));
    386375            retExpr->expr_string = "(" + ret1->expr_string  + "&~" + ret2->expr_string + ")";
    387             retExpr->pablo_expr = make_and(ret1->pablo_expr, make_not(ret2->pablo_expr));
     376            retExpr->pablo_expr = makeAnd(ret1->pablo_expr, makeNot(ret2->pablo_expr));
    388377        }
    389378        else
     
    392381            Expression* ret2 = expr_to_variable(expr2pabloe(pe_and->getExpr2()));
    393382            retExpr->expr_string = "(" + ret1->expr_string + "&" + ret2->expr_string + ")";
    394             retExpr->pablo_expr = make_and(ret1->pablo_expr, ret2->pablo_expr);
     383            retExpr->pablo_expr = makeAnd(ret1->pablo_expr, ret2->pablo_expr);
    395384        }
    396385    }
     
    402391        retExpr->expr_string = "((" + ret_sel->expr_string + "&" + ret_true->expr_string + ")|(~("
    403392            + ret_sel->expr_string + ")&" + ret_false->expr_string + ")";
    404         retExpr->pablo_expr = make_sel(ret_sel->pablo_expr, ret_true->pablo_expr, ret_false->pablo_expr);
     393        retExpr->pablo_expr = makeSel(ret_sel->pablo_expr, ret_true->pablo_expr, ret_false->pablo_expr);
    405394    }
    406395
     
    415404std::string CC_Compiler::bit_var(int n)
    416405{
    417     return  mEncoding.getBasisPattern(0) + std::to_string(n);
     406    return  mBasisPattern + std::to_string(n);
    418407}
    419408
    420409PabloE* CC_Compiler::make_bitv(int n)
    421410{
    422     return make_var(bit_var((mEncoding.getBits() - 1) - n));
     411    return makeVar(bit_var((mEncoding.getBits() - 1) - n));
    423412}
    424413
  • icGREP/icgrep-devel/icgrep/cc/cc_compiler.h

    r4207 r4209  
    3030    typedef std::list<pablo::PabloE *>          List;
    3131public:
    32     CC_Compiler(const UTF_Encoding encoding, const std::string basis_pattern, const std::string gensym_pattern);
    33     std::string compile1(re::CC* cc);
     32    CC_Compiler(const Encoding encoding, const std::string basis_pattern = "basis", const std::string gensym_pattern = "temp");
    3433    void compile_from_map(const REMap & re_map);
    3534    List get_compiled();
     35
     36    const std::string getBasisPattern() const {
     37        return mBasisPattern;
     38    }
     39
    3640private:
    3741    void process_re_map(const REMap &re_map);
     
    5357    Expression* expr_to_variable(Expression* cgo);
    5458
    55     UTF_Encoding mEncoding;
    56     std::string mGenSym_Template;
    57     int mGenSymCounter;
    58     List mStmtsl;
    59     ExpressionMap mCommon_Expression_Map;
     59
     60    Encoding                    mEncoding;
     61    const std::string           mBasisPattern;
     62    const std::string           mGenSymPattern;
     63    int                         mGenSymCounter;
     64    List                        mStmtsl;
     65    ExpressionMap               mCommon_Expression_Map;
    6066};
    6167
  • icGREP/icgrep-devel/icgrep/compiler.cpp

    r4203 r4209  
    4040namespace icgrep {
    4141
    42 LLVM_Gen_RetVal compile(bool show_compile_time, bool ascii_only, std::string basis_pattern, std::string gensym_pattern, UTF_Encoding encoding, std::string input_string)
     42LLVM_Gen_RetVal compile(bool show_compile_time, Encoding encoding, std::string input_string)
    4343{
    44     CC_Compiler cc_compiler(encoding, basis_pattern, gensym_pattern);
    45 
    4644    RE * re_ast = nullptr;
    4745    try
     
    6159
    6260    //Add the UTF encoding.
    63     if (!ascii_only)
     61    if (encoding.getType() == Encoding::Type::UTF_8)
    6462    {
    65         if (encoding.getName().compare("UTF-8") == 0)
    66         {
    67             re_ast = UTF8_Encoder::toUTF8(re_ast);
    68         }
    69         else
    70         {
    71             std::cerr << "Invalid encoding!" << std::endl;
    72             exit(1);
    73         }
     63        re_ast = UTF8_Encoder::toUTF8(re_ast);
    7464    }
    7565
     
    134124    name_map.insert(make_pair("UTF8-Prefix4", cc_name));
    135125
     126
     127    CC_Compiler cc_compiler(encoding);
    136128    cc_compiler.compile_from_map(re_map);
    137129    auto cc_stmtsl = cc_compiler.get_compiled();
     
    156148    #endif
    157149
    158     LLVM_Generator irgen(name_map, basis_pattern, encoding.getBits());
     150    LLVM_Generator irgen(name_map, cc_compiler.getBasisPattern(), encoding.getBits());
    159151
    160152    unsigned long long cycles = 0;
  • icGREP/icgrep-devel/icgrep/compiler.h

    r4197 r4209  
    1414namespace icgrep {
    1515
    16 LLVM_Gen_RetVal compile(bool show_compile_time, bool ascii_only, std::string basis_pattern, std::string gensym_pattern, UTF_Encoding encoding, std::string input_string);
     16LLVM_Gen_RetVal compile(bool show_compile_time, Encoding encoding, std::string input_string);
    1717
    1818}
  • icGREP/icgrep-devel/icgrep/icgrep-devel.files

    r4198 r4209  
    178178pablo/pablo_routines.cpp
    179179pablo/pablo_routines.h
     180re/printer_re.cpp
     181re/printer_re.h
     182pablo/pablo_compiler.cpp
     183pablo/pablo_compiler.h
     184pablo/codegenstate.cpp
     185pablo/codegenstate.h
  • icGREP/icgrep-devel/icgrep/icgrep.cpp

    r4197 r4209  
    225225    }
    226226
    227     UTF_Encoding encoding;
    228     encoding.setName("UTF-8");
    229     encoding.setBits(8);
    230     encoding.setMask(0xFF);
    231 
     227    Encoding encoding(ascii_only_option ? Encoding::Type::ASCII : Encoding::Type::UTF_8, 8);
    232228    if (compile_time_option)
    233229    {
     
    235231        timer = getElapsedTime();
    236232    }
    237     LLVM_Gen_RetVal llvm_codegen = icgrep::compile(compile_time_option,
    238                                                    ascii_only_option,
    239                                                    "basis_bits.bit_",
    240                                                    "temp",
    241                                                    encoding ,
    242                                                    (regex_from_file_option ? fileregex : inregex));
     233    LLVM_Gen_RetVal llvm_codegen = icgrep::compile(compile_time_option, encoding, (regex_from_file_option ? fileregex : inregex));
    243234
    244235    if (compile_time_option)
  • icGREP/icgrep-devel/icgrep/pablo/codegenstate.h

    r4207 r4209  
    3131namespace pablo {
    3232
    33 struct CodeGenState{
     33struct CodeGenState {
     34
     35//    PabloE * createAll(const bool value);
     36//    PabloE * createAdvance(PabloE * expr);
     37//    PabloE * createNot(PabloE * expr);
     38//    PabloE * createCall(const std::string name);
     39//    PabloE * createVar(const std::string name);
     40//    PabloE * createCharClass(const std::string name);
     41//    PabloE * createAssign(const std::string name, PabloE * expr);
     42//    PabloE * createAnd(PabloE * expr1, PabloE * expr2);
     43//    PabloE * createOr(PabloE * expr1, PabloE * expr2);
     44//    PabloE * createXor(PabloE * expr1, PabloE * expr2);
     45//    PabloE * createMatchStar(PabloE * expr1, PabloE * expr2);
     46//    PabloE * createScanThru(PabloE * from, PabloE * thru);
     47
     48
    3449
    3550//    struct ExpressionTable {
     
    3752//            switch(inst->getClassTypeId()) {
    3853//                // UNARY
    39 //                case All:
    40 //                case Advance:
    41 //                case Call:
    42 //                case Not:
    43 //                case Var:
    44 //                case Assign:
    45 //                case CharClass: // ***
     54//                case All:       // bool
     55//                case Advance:   // pe
     56//                case Not:       // pe
     57
     58//                case Call:      // string
     59//                case Var:       // string
     60//                case CharClass: // string
    4661//                // BINARY
    47 //                case And:
    48 //                case Or:
    49 //                case Xor:
     62//                case Assign:    // string, pe
    5063
    51 //                case MatchStar:
    52 //                case ScanThru:
    53 //                case If:
    54 //                case While:
     64//                case And:       // pe, pe
     65//                case Or:        // pe, pe
     66//                case Xor:       // pe, pe
     67//                case MatchStar: // pe, pe
     68//                case ScanThru:  // pe, pe
     69
     70//                case If:        // pe, pe list
     71//                case While:     // pe, pe list
    5572//                // TERNARY
    56 //                case Sel:
     73//                case Sel:       // pe, pe, pe
    5774//            }
    5875
     
    7996//            }
    8097//        private:
    81 //            std::map<Key, PabloE *>                                     _map;
     98//            std::unordered_map<Key, PabloE *>                           _map;
    8299//        };
    83100//        ExpressionMap<const PabloE *>                                   _unary;
     
    85102//        ExpressionMap<const PabloE *, const PabloE *, const PabloE *>   _ternary;
    86103//    };
     104
     105
     106
    87107
    88108    std::list<PabloE *>  stmtsl;
  • icGREP/icgrep-devel/icgrep/pablo/pe_advance.h

    r4200 r4209  
    1313
    1414class Advance : public PabloE {
    15     friend Advance * make_advance(PabloE * expr);
     15    friend Advance * makeAdvance(PabloE * expr);
    1616public:
    1717    static inline bool classof(const PabloE * e) {
     
    3838};
    3939
    40 inline Advance * make_advance(PabloE * expr) {
     40inline Advance * makeAdvance(PabloE * expr) {
    4141    return new Advance(expr);
    4242}
  • icGREP/icgrep-devel/icgrep/pablo/pe_all.h

    r4200 r4209  
    1313
    1414class All : public PabloE {
    15     friend All * make_all(bool value);
     15    friend All * makeAll(bool value);
    1616public:
    1717    static inline bool classof(const PabloE * e) {
     
    2121        return false;
    2222    }
    23 
    2423    virtual ~All() {
    2524
    2625    }
    27 
    2826    inline bool getValue() const {
    2927        return mValue;
     28    }
     29    inline bool operator==(const All & other) const {
     30        return mValue == other.mValue;
     31    }
     32    virtual bool operator==(const PabloE & other) const {
     33        return (isa<All>(other)) ? mValue == cast<All>(other).mValue : false;
    3034    }
    3135protected:
     
    4044};
    4145
    42 inline All * make_all(bool value) {
     46inline All * makeAll(bool value) {
    4347    return new All(value);
    4448}
  • icGREP/icgrep-devel/icgrep/pablo/pe_and.cpp

    r4200 r4209  
    1212namespace pablo {
    1313
    14 PabloE * make_and(PabloE * expr1, PabloE *expr2) {
     14PabloE * makeAnd(PabloE * expr1, PabloE *expr2) {
    1515    if (All * all = dyn_cast<All>(expr1)) {
    1616        if (all->getValue()) {
     
    1818        }
    1919        else {
    20             return make_all(0);
     20            return makeAll(0);
    2121        }
    2222    }
     
    2626        }
    2727        else {
    28             return make_all(0);
     28            return makeAll(0);
    2929        }
    3030    }
     
    3434    else if (Not * pe_not_e1 = dyn_cast<Not>(expr1)) {
    3535        if (Not * pe_not_e2 = dyn_cast<Not>(expr2)) {
    36             return make_not(make_or(pe_not_e1->getExpr(), pe_not_e2->getExpr()));
     36            return makeNot(makeOr(pe_not_e1->getExpr(), pe_not_e2->getExpr()));
    3737        }
    3838        else if (equals(pe_not_e1->getExpr(), expr2)) {
    39             return make_all(0);
     39            return makeAll(0);
    4040        }
    4141    }
    4242    else if (Not * pe_not_e2 = dyn_cast<Not>(expr2)) {
    4343        if (equals(expr1, pe_not_e2->getExpr())) {
    44             return make_all(0);
     44            return makeAll(0);
    4545        }
    4646    }
  • icGREP/icgrep-devel/icgrep/pablo/pe_and.h

    r4200 r4209  
    1313
    1414class And : public PabloE {
    15     friend PabloE * make_and(PabloE *, PabloE *);
     15    friend PabloE * makeAnd(PabloE *, PabloE *);
    1616public:
    1717    static inline bool classof(const PabloE * e) {
     
    4444};
    4545
    46 PabloE * make_and(PabloE * expr1, PabloE * expr2);
     46PabloE * makeAnd(PabloE * expr1, PabloE * expr2);
    4747
    4848}
  • icGREP/icgrep-devel/icgrep/pablo/pe_call.h

    r4200 r4209  
    88
    99class Call : public PabloE {
    10     friend Call * make_call(const std::string callee);
     10    friend Call * makeCall(const std::string callee);
    1111public:
    1212    static inline bool classof(const PabloE * e) {
     
    3333};
    3434
    35 inline Call * make_call(const std::string callee) {
     35inline Call * makeCall(const std::string callee) {
    3636    return new Call(callee);
    3737}
  • icGREP/icgrep-devel/icgrep/pablo/pe_charclass.h

    r4200 r4209  
    1414
    1515class CharClass : public PabloE {
    16     friend CharClass * make_charclass(const std::string cc);
     16    friend CharClass * makeCharClass(const std::string cc);
    1717public:
    1818    static inline bool classof(const PabloE * e) {
     
    3939};
    4040
    41 inline CharClass * make_charclass(const std::string cc) {
     41inline CharClass * makeCharClass(const std::string cc) {
    4242    return new CharClass(cc);
    4343}
  • icGREP/icgrep-devel/icgrep/pablo/pe_matchstar.h

    r4200 r4209  
    1313
    1414class MatchStar : public PabloE {
     15    friend MatchStar * makeMatchStar(PabloE *, PabloE *);
    1516public:
    1617    static inline bool classof(const PabloE * e) {
     
    2021        return false;
    2122    }
    22     MatchStar(PabloE * expr1, PabloE * expr2)
    23     : PabloE(ClassTypeId::MatchStar)
    24     , mExpr1(expr1)
    25     , mExpr2(expr2)
    26     {
    27 
    28     }
    29 
    3023    virtual ~MatchStar() {
    3124        delete mExpr1;
     
    4033        return mExpr2;
    4134    }
     35protected:
     36    MatchStar(PabloE * expr1, PabloE * expr2)
     37    : PabloE(ClassTypeId::MatchStar)
     38    , mExpr1(expr1)
     39    , mExpr2(expr2)
     40    {
    4241
     42    }
    4343private:
    4444    PabloE * const mExpr1;
    4545    PabloE * const mExpr2;
    4646};
     47
     48inline MatchStar * makeMatchStar(PabloE * expr1, PabloE * expr2) {
     49    return new MatchStar(expr1, expr2);
     50}
    4751
    4852}
  • icGREP/icgrep-devel/icgrep/pablo/pe_not.cpp

    r4200 r4209  
    1010namespace pablo {
    1111
    12 PabloE * make_not(PabloE * expr) {
     12PabloE * makeNot(PabloE * expr) {
    1313    if (All * all = dyn_cast<All>(expr)) {
    14         return make_all(!all->getValue());
     14        return makeAll(!all->getValue());
    1515    }
    1616    else if (Not * pe_not = dyn_cast<Not>(expr)) {
  • icGREP/icgrep-devel/icgrep/pablo/pe_not.h

    r4200 r4209  
    1313
    1414class Not : public PabloE {
    15     friend PabloE * make_not(PabloE *);
     15    friend PabloE * makeNot(PabloE *);
    1616public:
    1717    static inline bool classof(const PabloE * e) {
     
    3939};
    4040
    41 PabloE * make_not(PabloE * expr);
     41PabloE * makeNot(PabloE * expr);
    4242
    4343}
  • icGREP/icgrep-devel/icgrep/pablo/pe_or.cpp

    r4200 r4209  
    1212namespace pablo {
    1313
    14 PabloE * make_or(PabloE * expr1, PabloE * expr2) {
     14PabloE * makeOr(PabloE * expr1, PabloE * expr2) {
    1515    if (All * all = dyn_cast<All>(expr1)) {
    1616        if (all->getValue() == 1) {
     
    3131    else if (Not * not1 = dyn_cast<Not>(expr1)) {
    3232        // ¬a√b = ¬¬(¬a√b) = ¬(a ∧ ¬b)
    33         return make_not(make_and(not1->getExpr(), make_not(expr2)));
     33        return makeNot(makeAnd(not1->getExpr(), makeNot(expr2)));
    3434    }
    3535    else if (Not * not2 = dyn_cast<Not>(expr2)) {
    3636        // a√¬b = ¬¬(¬b√a) = ¬(b ∧ ¬a)
    37         return make_not(make_and(not2->getExpr(), make_not(expr1)));
     37        return makeNot(makeAnd(not2->getExpr(), makeNot(expr1)));
    3838    }
    3939    else if (equals(expr1, expr2)) {
     
    4949            //(e.g., union of [a-z] and [A-Z].
    5050            if (equals(expr1a, expr2a)) {
    51                 return make_and(expr1a, make_or(expr1b, expr2b));
     51                return makeAnd(expr1a, makeOr(expr1b, expr2b));
    5252            }
    5353            else if (equals(expr1b, expr2b)) {
    54                 return make_and(expr1b, make_or(expr1a, expr2a));
     54                return makeAnd(expr1b, makeOr(expr1a, expr2a));
    5555            }
    5656            else if (equals(expr1a, expr2b)) {
    57                 return make_and(expr1a, make_or(expr1b, expr2a));
     57                return makeAnd(expr1a, makeOr(expr1b, expr2a));
    5858            }
    5959            else if (equals(expr1b, expr2a)) {
    60                 return make_and(expr1b, make_or(expr1a, expr2b));
     60                return makeAnd(expr1b, makeOr(expr1a, expr2b));
    6161            }
    6262        }
  • icGREP/icgrep-devel/icgrep/pablo/pe_or.h

    r4200 r4209  
    1313
    1414class Or : public PabloE {
    15     friend PabloE * make_or(PabloE *, PabloE *);
     15    friend PabloE * makeOr(PabloE *, PabloE *);
    1616public:
    1717    static inline bool classof(const PabloE * e) {
     
    4646};
    4747
    48 PabloE * make_or(PabloE * expr1, PabloE * expr2);
     48PabloE * makeOr(PabloE * expr1, PabloE * expr2);
    4949
    5050}
  • icGREP/icgrep-devel/icgrep/pablo/pe_scanthru.h

    r4206 r4209  
    1313
    1414class ScanThru : public  PabloE {
    15     friend PabloE * make_scanthru(PabloE *, PabloE *);
     15    friend PabloE * makeScanThru(PabloE *, PabloE *);
    1616public:
    1717    static inline bool classof(const PabloE * e) {
     
    4646};
    4747
    48 inline PabloE * make_scanthru(PabloE * from, PabloE * thru) {
     48inline PabloE * makeScanThru(PabloE * from, PabloE * thru) {
    4949    return new ScanThru(from, thru);
    5050}
  • icGREP/icgrep-devel/icgrep/pablo/pe_sel.cpp

    r4200 r4209  
    1313namespace pablo {
    1414
    15 PabloE * make_sel(PabloE * if_expr, PabloE * t_expr, PabloE * f_expr) {
     15PabloE * makeSel(PabloE * if_expr, PabloE * t_expr, PabloE * f_expr) {
    1616    if (All * all_if_expr = dyn_cast<All>(if_expr)) {
    1717        if (all_if_expr->getValue()) {
     
    2424    else if (All * all_t_expr = dyn_cast<All>(t_expr)) {
    2525        if (all_t_expr->getValue()) {
    26             return make_or(if_expr, f_expr);
     26            return makeOr(if_expr, f_expr);
    2727        }
    2828        else {
    29             return make_and(make_not(if_expr), f_expr);
     29            return makeAnd(makeNot(if_expr), f_expr);
    3030        }
    3131    }
    3232    else if (All * all_f_expr = dyn_cast<All>(f_expr)) {
    3333        if (all_f_expr->getValue()) {
    34             return make_or(make_not(if_expr), t_expr);
     34            return makeOr(makeNot(if_expr), t_expr);
    3535        }
    3636        else {
    37             return make_and(if_expr, t_expr);
     37            return makeAnd(if_expr, t_expr);
    3838        }
    3939    }
  • icGREP/icgrep-devel/icgrep/pablo/pe_sel.h

    r4200 r4209  
    1313
    1414class Sel : public PabloE {
    15     friend PabloE * make_sel(PabloE *, PabloE *, PabloE *);
     15    friend PabloE * makeSel(PabloE *, PabloE *, PabloE *);
    1616public:
    1717    static inline bool classof(const PabloE * e) {
     
    5353};
    5454
    55 PabloE * make_sel(PabloE * if_expr, PabloE * t_expr, PabloE * f_expr);
     55PabloE * makeSel(PabloE * if_expr, PabloE * t_expr, PabloE * f_expr);
    5656
    5757}
  • icGREP/icgrep-devel/icgrep/pablo/pe_var.h

    r4200 r4209  
    1414
    1515class Var : public PabloE {
    16     friend Var * make_var(const std::string);
     16    friend Var * makeVar(const std::string);
    1717public:
    1818    static inline bool classof(const PabloE * e) {
     
    3939};
    4040
    41 inline Var * make_var(const std::string var) {
     41inline Var * makeVar(const std::string var) {
    4242    return new Var(var);
    4343}
  • icGREP/icgrep-devel/icgrep/pablo/pe_xor.cpp

    r4200 r4209  
    1111namespace pablo {
    1212
    13 PabloE * make_xor(PabloE * expr1, PabloE * expr2) {
     13PabloE * makeXor(PabloE * expr1, PabloE * expr2) {
    1414    if (All * all1 = dyn_cast<All>(expr1)) {
    1515        if (all1->getValue()) {
    16             return make_not(expr2);
     16            return makeNot(expr2);
    1717        }
    1818        else {
     
    2222    else if (All* all2 = dyn_cast<All>(expr2)) {
    2323        if (all2->getValue() == 1) {
    24             return make_not(expr1);
     24            return makeNot(expr1);
    2525        }
    2626        else { //if (all_expr2->getNum() == 0)
     
    3030    else if (Not * not1 = dyn_cast<Not>(expr1)) {
    3131        if (Not * not2 = dyn_cast<Not>(expr2)) {
    32             return make_xor(not1->getExpr(), not2->getExpr());
     32            return makeXor(not1->getExpr(), not2->getExpr());
    3333        }
    3434    }
  • icGREP/icgrep-devel/icgrep/pablo/pe_xor.h

    r4200 r4209  
    1 /*
     1/*
    22 *  Copyright (c) 2014 International Characters.
    33 *  This software is licensed to the public under the Open Software License 3.0.
     
    1313
    1414class Xor : public PabloE {
    15     friend PabloE * make_xor(PabloE *, PabloE *);
     15    friend PabloE * makeXor(PabloE *, PabloE *);
    1616public:
    1717    static inline bool classof(const PabloE * e) {
     
    4444};
    4545
    46 PabloE * make_xor(PabloE * expr1, PabloE * expr2);
     46PabloE * makeXor(PabloE * expr1, PabloE * expr2);
    4747
    4848}
  • icGREP/icgrep-devel/icgrep/pablo/ps_assign.h

    r4200 r4209  
    1414
    1515class Assign : public PabloE {
    16     friend Assign * make_assign(const std::string, PabloE *);
     16    friend Assign * makeAssign(const std::string, PabloE *);
    1717public:
    1818    static inline bool classof(const PabloE * e) {
     
    4646};
    4747
    48 inline Assign * make_assign(const std::string marker, PabloE * expr) {
     48inline Assign * makeAssign(const std::string marker, PabloE * expr) {
    4949    return new Assign(marker, expr);
    5050}
  • icGREP/icgrep-devel/icgrep/pablo/ps_if.h

    r4206 r4209  
    1616public:
    1717    typedef std::list<PabloE*> List;
    18     friend If * make_if(PabloE * expr, List psl);
     18    friend If * makeIf(PabloE * expr, List psl);
    1919
    2020    static inline bool classof(const PabloE * e) {
     
    5454};
    5555
    56 inline If * make_if(PabloE * expr, If::List statements) {
     56inline If * makeIf(PabloE * expr, If::List statements) {
    5757    return new If(expr, statements);
    5858}
  • icGREP/icgrep-devel/icgrep/pablo/ps_while.h

    r4206 r4209  
    1515class While : public PabloE {   
    1616public:
     17    typedef std::list<PabloE*> List;
     18    friend While * makeWhile(PabloE * expr, List psl);
    1719
    1820    static inline bool classof(const PabloE * e) {
     
    2123    static inline bool classof(const void *) {
    2224        return false;
    23     }
    24 
    25     typedef std::list<PabloE*> List;
    26 
    27     While(PabloE* expr, List psl)
    28     : PabloE(ClassTypeId::While)
    29     , mExpr(expr)
    30     , mPSList(psl)
    31     {
    32 
    3325    }
    3426
     
    4739        return mPSList;
    4840    }
     41protected:
     42    While(PabloE * expr, List psl)
     43    : PabloE(ClassTypeId::While)
     44    , mExpr(expr)
     45    , mPSList(psl)
     46    {
     47
     48    }
    4949private:
    5050    PabloE * const  mExpr;
    5151    List            mPSList;
    5252};
     53
     54inline While * makeWhile(PabloE * cond, While::List statements) {
     55    return new While(cond, statements);
     56}
    5357
    5458}
  • icGREP/icgrep-devel/icgrep/re/re_compiler.cpp

    r4208 r4209  
    5757            if (seq->getType() == Seq::Type::Byte) {
    5858                std::string gs_retVal = symgen.get("start_marker");
    59                 cg_state.stmtsl.push_back(make_assign(gs_retVal, make_all(1)));
     59                cg_state.stmtsl.push_back(makeAssign(gs_retVal, makeAll(1)));
    6060                for (auto j = seq->begin();; ) {
    6161                    Name * name = dyn_cast<Name>(*j);
    6262                    assert (name);
    63                     auto * cc_mask = make_and(make_var(gs_retVal), make_charclass(name->getName()));
     63                    auto * cc_mask = makeAnd(makeVar(gs_retVal), makeCharClass(name->getName()));
    6464                    if (++j != seq->end()) {
    6565                        gs_retVal = symgen.get("marker");
    66                         cg_state.stmtsl.push_back(make_assign(gs_retVal, make_advance(cc_mask)));
     66                        cg_state.stmtsl.push_back(makeAssign(gs_retVal, makeAdvance(cc_mask)));
    6767                    }
    6868                    else {
    69                         cg_state.stmtsl.push_back(make_assign(seq->getName(), cc_mask));
     69                        cg_state.stmtsl.push_back(makeAssign(seq->getName(), cc_mask));
    7070                        break;
    7171                    }
     
    8383
    8484    std::string gs_m0 = symgen.get("start_marker");
    85     cg_state.stmtsl.push_back(make_assign(gs_m0, make_all(1)));
     85    cg_state.stmtsl.push_back(makeAssign(gs_m0, makeAll(1)));
    8686
    8787    if (hasUnicode(re)) {
     
    9090        std::string gs_initial = symgen.get("internal.initial");
    9191        m_name_map.insert(make_pair("internal.initial", gs_initial));
    92         PabloE * u8single = make_var(m_name_map.find("UTF8-SingleByte")->second);
    93         PabloE * u8pfx2 = make_var(m_name_map.find("UTF8-Prefix2")->second);
    94         PabloE * u8pfx3 = make_var(m_name_map.find("UTF8-Prefix3")->second);
    95         PabloE * u8pfx4 = make_var(m_name_map.find("UTF8-Prefix4")->second);
    96         PabloE * u8pfx = make_or(make_or(u8pfx2, u8pfx3), u8pfx4);
    97         cg_state.stmtsl.push_back(make_assign(gs_initial, make_or(u8pfx, u8single)));
     92        PabloE * u8single = makeVar(m_name_map.find("UTF8-SingleByte")->second);
     93        PabloE * u8pfx2 = makeVar(m_name_map.find("UTF8-Prefix2")->second);
     94        PabloE * u8pfx3 = makeVar(m_name_map.find("UTF8-Prefix3")->second);
     95        PabloE * u8pfx4 = makeVar(m_name_map.find("UTF8-Prefix4")->second);
     96        PabloE * u8pfx = makeOr(makeOr(u8pfx2, u8pfx3), u8pfx4);
     97        cg_state.stmtsl.push_back(makeAssign(gs_initial, makeOr(u8pfx, u8single)));
    9898        cg_state.newsym = gs_initial;
    9999
     
    106106        cg_state.stmtsl.push_back(make_assign(gs_nonfinal, make_all(0)));
    107107        #endif
    108         PabloE * u8scope32 = make_advance(u8pfx3);
    109         PabloE * u8scope42 = make_advance(u8pfx4);
    110         PabloE * u8scope43 = make_advance(u8scope42);
    111         PabloE * assign_non_final = make_assign(gs_nonfinal, make_or(make_or(u8pfx, u8scope32), make_or(u8scope42, u8scope43)));
     108        PabloE * u8scope32 = makeAdvance(u8pfx3);
     109        PabloE * u8scope42 = makeAdvance(u8pfx4);
     110        PabloE * u8scope43 = makeAdvance(u8scope42);
     111        PabloE * assign_non_final = makeAssign(gs_nonfinal, makeOr(makeOr(u8pfx, u8scope32), makeOr(u8scope42, u8scope43)));
    112112        #ifdef USE_IF_FOR_NONFINAL
    113113        std::list<PabloE *> * if_body = new std::list<PabloE *> ();
     
    125125    //These three lines are specifically for grep.
    126126    std::string gs_retVal = symgen.get("marker");
    127     cg_state.stmtsl.push_back(make_assign(gs_retVal, make_and(new MatchStar(make_var(cg_state.newsym),
    128         make_not(make_var(m_name_map.find("LineFeed")->second))), make_var(m_name_map.find("LineFeed")->second))));
     127    cg_state.stmtsl.push_back(makeAssign(gs_retVal, makeAnd(makeMatchStar(makeVar(cg_state.newsym),
     128        makeNot(makeVar(m_name_map.find("LineFeed")->second))), makeVar(m_name_map.find("LineFeed")->second))));
    129129    cg_state.newsym = gs_retVal;
    130130
     
    147147    else if (isa<Start>(re)) {
    148148        std::string gs_retVal = symgen.get("sol");
    149         cg_state.stmtsl.push_back(make_assign(gs_retVal, make_and(make_var(cg_state.newsym), make_not(make_advance(make_not(make_charclass(m_name_map.find("LineFeed")->second)))))));
     149        cg_state.stmtsl.push_back(makeAssign(gs_retVal, makeAnd(makeVar(cg_state.newsym), makeNot(makeAdvance(makeNot(makeCharClass(m_name_map.find("LineFeed")->second)))))));
    150150        cg_state.newsym = gs_retVal;
    151151    }
    152152    else if (isa<End>(re)) {
    153153        std::string gs_retVal = symgen.get("eol");
    154         cg_state.stmtsl.push_back(make_assign(gs_retVal, make_and(make_var(cg_state.newsym), make_charclass(m_name_map.find("LineFeed")->second))));
     154        cg_state.stmtsl.push_back(makeAssign(gs_retVal, makeAnd(makeVar(cg_state.newsym), makeCharClass(m_name_map.find("LineFeed")->second))));
    155155        cg_state.newsym = gs_retVal;
    156156    }
     
    159159inline void RE_Compiler::compile(Name * name, CodeGenState & cg_state) {
    160160    std::string gs_retVal = symgen.get("marker");
    161     PabloE * markerExpr = make_var(cg_state.newsym);
     161    PabloE * markerExpr = makeVar(cg_state.newsym);
    162162    if (name->getType() != Name::Type::FixedLength) {
    163163        // Move the markers forward through any nonfinal UTF-8 bytes to the final position of each character.
    164         markerExpr = make_and(markerExpr, make_charclass(m_name_map.find("internal.initial")->second));
    165         markerExpr = new ScanThru(markerExpr, make_charclass(m_name_map.find("internal.nonfinal")->second));
     164        markerExpr = makeAnd(markerExpr, makeCharClass(m_name_map.find("internal.initial")->second));
     165        markerExpr = new ScanThru(markerExpr, makeCharClass(m_name_map.find("internal.nonfinal")->second));
    166166    }
    167167    PabloE * ccExpr;
    168168    if (name->getType() == Name::Type::UnicodeCategory) {
    169         ccExpr = make_call(name->getName());
     169        ccExpr = makeCall(name->getName());
    170170    }
    171171    else {
    172         ccExpr = make_charclass(name->getName());
     172        ccExpr = makeCharClass(name->getName());
    173173    }
    174174    if (name->isNegated()) {
    175         ccExpr = make_not(make_or(make_or(ccExpr, make_charclass(m_name_map.find("LineFeed")->second)),
    176                                 make_charclass(m_name_map.find("internal.nonfinal")->second)));
    177     }
    178     cg_state.stmtsl.push_back(make_assign(gs_retVal, make_advance(make_and(ccExpr, markerExpr))));
     175        ccExpr = makeNot(makeOr(makeOr(ccExpr, makeCharClass(m_name_map.find("LineFeed")->second)),
     176                                makeCharClass(m_name_map.find("internal.nonfinal")->second)));
     177    }
     178    cg_state.stmtsl.push_back(makeAssign(gs_retVal, makeAdvance(makeAnd(ccExpr, markerExpr))));
    179179    cg_state.newsym = gs_retVal;
    180180}
     
    189189    if (alt->empty()) {
    190190        std::string gs_retVal = symgen.get("always_fail_marker");
    191         cg_state.stmtsl.push_back(make_assign(gs_retVal, make_all(0)));
     191        cg_state.stmtsl.push_back(makeAssign(gs_retVal, makeAll(0)));
    192192        cg_state.newsym = gs_retVal;
    193193    }
     
    201201            compile(*i, cg_state);
    202202            std::string newsym = symgen.get("alt");
    203             cg_state.stmtsl.push_back(make_assign(newsym, make_or(make_var(alt1), make_var(cg_state.newsym))));
     203            cg_state.stmtsl.push_back(makeAssign(newsym, makeOr(makeVar(alt1), makeVar(cg_state.newsym))));
    204204            cg_state.newsym = newsym;
    205205        }
     
    227227        PabloE* ccExpr;
    228228        if (rep_name->getType() == Name::Type::UnicodeCategory) {
    229             ccExpr = make_call(rep_name->getName());
     229            ccExpr = makeCall(rep_name->getName());
    230230        }
    231231        else {
    232             ccExpr = make_charclass(rep_name->getName());
     232            ccExpr = makeCharClass(rep_name->getName());
    233233        }
    234234
    235235        if (rep_name->isNegated()) {
    236             ccExpr = make_not(make_or(make_or(ccExpr, make_charclass(m_name_map.find("LineFeed")->second)), make_charclass(m_name_map.find("internal.nonfinal")->second)));
     236            ccExpr = makeNot(makeOr(makeOr(ccExpr, makeCharClass(m_name_map.find("LineFeed")->second)), makeCharClass(m_name_map.find("internal.nonfinal")->second)));
    237237        }
    238238        if (rep_name->getType() == Name::Type::FixedLength) {
    239             cg_state.stmtsl.push_back(make_assign(gs_retVal, new MatchStar(make_var(cg_state.newsym), ccExpr)));
     239            cg_state.stmtsl.push_back(makeAssign(gs_retVal, makeMatchStar(makeVar(cg_state.newsym), ccExpr)));
    240240        }
    241241        else { // Name::Unicode and Name::UnicodeCategory
    242             cg_state.stmtsl.push_back(make_assign(gs_retVal,
    243                 make_and(new MatchStar(make_var(cg_state.newsym),
    244                         make_or(make_charclass(m_name_map.find("internal.nonfinal")->second), ccExpr)),
    245                                make_charclass(m_name_map.find("internal.initial")->second))));
     242            cg_state.stmtsl.push_back(makeAssign(gs_retVal,
     243                makeAnd(makeMatchStar(makeVar(cg_state.newsym),
     244                        makeOr(makeCharClass(m_name_map.find("internal.nonfinal")->second), ccExpr)),
     245                               makeCharClass(m_name_map.find("internal.initial")->second))));
    246246        }
    247247        cg_state.newsym = gs_retVal;
     
    254254      while_test_state.newsym = while_test;
    255255      compile(repeated, while_test_state);
    256       cg_state.stmtsl.push_back(make_assign(while_test, make_var(cg_state.newsym)));
    257       cg_state.stmtsl.push_back(make_assign(while_accum, make_var(cg_state.newsym)));
    258       while_test_state.stmtsl.push_back(make_assign(while_test, make_and(make_var(while_test_state.newsym), make_not(make_var(while_accum)))));
    259       while_test_state.stmtsl.push_back(make_assign(while_accum, make_or(make_var(while_accum), make_var(while_test_state.newsym))));
    260       cg_state.stmtsl.push_back(new While(make_var(while_test), while_test_state.stmtsl));
     256      cg_state.stmtsl.push_back(makeAssign(while_test, makeVar(cg_state.newsym)));
     257      cg_state.stmtsl.push_back(makeAssign(while_accum, makeVar(cg_state.newsym)));
     258      while_test_state.stmtsl.push_back(makeAssign(while_test, makeAnd(makeVar(while_test_state.newsym), makeNot(makeVar(while_accum)))));
     259      while_test_state.stmtsl.push_back(makeAssign(while_accum, makeOr(makeVar(while_accum), makeVar(while_test_state.newsym))));
     260      cg_state.stmtsl.push_back(makeWhile(makeVar(while_test), while_test_state.stmtsl));
    261261      cg_state.newsym = while_accum;
    262262    }
     
    273273         compileBoundedRep(repeated, 0, ub - 1, cg_state);
    274274         std::string altsym = symgen.get("alt");
    275          cg_state.stmtsl.push_back(make_assign(altsym, make_or(make_var(oldsym), make_var(cg_state.newsym))));
     275         cg_state.stmtsl.push_back(makeAssign(altsym, makeOr(makeVar(oldsym), makeVar(cg_state.newsym))));
    276276         cg_state.newsym = altsym;
    277277    }
  • icGREP/icgrep-devel/icgrep/utf_encoding.cpp

    r3850 r4209  
    66
    77#include "utf_encoding.h"
    8 
    9 UTF_Encoding::UTF_Encoding()
    10 {
    11     mEncodingError = false;
    12     mDefault = true;
    13     mLocked = false;
    14 }
    15 
    16 std::string UTF_Encoding::getName()
    17 {
    18     return mName;
    19 }
    20 
    21 void UTF_Encoding::setName(std::string name)
    22 {
    23     mName = name;
    24 }
    25 
    26 int UTF_Encoding::getBits()
    27 {
    28     return mBits;
    29 }
    30 
    31 void UTF_Encoding::setBits(int bits)
    32 {
    33     mBits = bits;
    34 }
    35 
    36 uint32_t UTF_Encoding::getMask()
    37 {
    38     return mMask;
    39 }
    40 
    41 void UTF_Encoding::setMask(uint32_t mask)
    42 {
    43     mMask = mask;
    44 }
    45 
    46 bool UTF_Encoding::getDefault()
    47 {
    48     return mDefault;
    49 }
    50 
    51 void UTF_Encoding::setDefault(bool defaultEncoding)
    52 {
    53     mDefault = defaultEncoding;
    54 }
    55 
    56 bool UTF_Encoding::getLocked()
    57 {
    58     return mLocked;
    59 }
    60 
    61 void UTF_Encoding::setLocked(bool locked)
    62 {
    63     mLocked = locked;
    64 }
    65 
    66 bool UTF_Encoding::getEncodingError()
    67 {
    68     return mEncodingError;
    69 }
    70 
    71 void UTF_Encoding::setEncodingError(bool error)
    72 {
    73     mEncodingError= error;
    74 }
    75 
    76 void UTF_Encoding::setBasisPattern(std::string pattern)
    77 {
    78     mBasisPattern.push_back(pattern);
    79 }
    80 
    81 std::string UTF_Encoding::getBasisPattern(int n)
    82 {
    83     return mBasisPattern.at(n);
    84 }
    85 
    86 std::vector<std::string> UTF_Encoding::getBasisPatternVector()
    87 {
    88     return mBasisPattern;
    89 }
    90 
    91 
  • icGREP/icgrep-devel/icgrep/utf_encoding.h

    r3850 r4209  
    1212#include <vector>
    1313
    14 class UTF_Encoding
    15 {
     14class Encoding{
    1615public:
    17     UTF_Encoding();
    18     //UTF_Encoding(std::string name, int bits, uint32_t mask);
    19     std::string getName();
    20     void setName(std::string name);
    21     int getBits();
    22     void setBits(int bits);
    23     uint32_t getMask();
    24     void setMask(uint32_t mask);
    25     bool getDefault();
    26     void setDefault(bool defaultEncoding);
    27     bool getLocked();
    28     void setLocked(bool locked);
    29     bool getEncodingError();
    30     void setEncodingError(bool error);
    31     std::string getBasisPattern(int n);
    32     void setBasisPattern(std::string pattern);
    33     std::vector<std::string> getBasisPatternVector();
    34     void setBasisPatternVector(std::vector<std::string> basisPattern);
     16
     17    enum class Type {
     18        ASCII
     19        , UTF_8
     20    };
     21
     22    Encoding(Type type, unsigned bits);
     23    Encoding(Type type, unsigned bits, unsigned mask);
     24    Type getType() const;
     25    unsigned getBits() const;
     26    unsigned getMask() const;
    3527private:
    36     std::string mName;
    37     int mBits;
    38     uint32_t mMask;
    39     bool mDefault;
    40     bool mLocked;
    41     bool mEncodingError;
    42     std::vector<std::string> mBasisPattern;
     28    Type        mType;
     29    unsigned    mBits;
     30    unsigned    mMask;
    4331};
    4432
     33inline Encoding::Encoding(Type type, unsigned bits)
     34: mType(type)
     35, mBits(bits)
     36, mMask((static_cast<unsigned>(1) << bits) - static_cast<unsigned>(1))
     37{
     38
     39}
     40
     41inline Encoding::Encoding(Type type, unsigned bits, unsigned mask)
     42: mType(type)
     43, mBits(bits)
     44, mMask(mask)
     45{
     46
     47}
     48
     49inline Encoding::Type Encoding::getType() const {
     50    return mType;
     51}
     52
     53inline unsigned Encoding::getBits() const {
     54    return mBits;
     55}
     56
     57inline unsigned Encoding::getMask() const {
     58    return mMask;
     59}
     60
    4561#endif // UTF_ENCODING_H
Note: See TracChangeset for help on using the changeset viewer.