Ignore:
Timestamp:
Sep 30, 2014, 2:44:40 PM (5 years ago)
Author:
nmedfort
Message:

Replaced dynamic_cast with llvm::dyn_cast in pablo code; implemented make functions for pablo constructors. Disabled RTTI.

Location:
icGREP/icgrep-devel/icgrep
Files:
2 deleted
29 edited

Legend:

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

    r4198 r4200  
    5353include(FindBoost)
    5454
    55 add_library(PabloADT pablo/pablo_routines.cpp pablo/pe_advance.cpp pablo/pe_all.cpp pablo/pe_and.cpp pablo/pe_call.cpp pablo/pe_charclass.cpp  pablo/pe_matchstar.cpp pablo/pe_scanthru.cpp pablo/pe_not.cpp  pablo/pe_or.cpp  pablo/pe_pabloe.cpp  pablo/pe_sel.cpp  pablo/pe_var.cpp  pablo/pe_xor.cpp pablo/ps_assign.cpp  pablo/ps_if.cpp  pablo/ps_pablos.cpp  pablo/ps_while.cpp printer_pablos.cpp)
     55add_library(PabloADT pablo/pe_advance.cpp pablo/pe_all.cpp pablo/pe_and.cpp pablo/pe_call.cpp pablo/pe_charclass.cpp  pablo/pe_matchstar.cpp pablo/pe_scanthru.cpp pablo/pe_not.cpp  pablo/pe_or.cpp  pablo/pe_pabloe.cpp  pablo/pe_sel.cpp  pablo/pe_var.cpp  pablo/pe_xor.cpp pablo/ps_assign.cpp  pablo/ps_if.cpp  pablo/ps_pablos.cpp  pablo/ps_while.cpp printer_pablos.cpp)
    5656
    5757add_library(RegExpADT re/re_alt.cpp re/re_cc.cpp re/re_end.cpp re/re_name.cpp re/re_parser.cpp re/re_re.cpp re/re_rep.cpp re/re_seq.cpp re/re_start.cpp re/parsefailure.cpp re/re_reducer.cpp re/re_nullable.cpp re/re_simplifier.cpp re/re_compiler.cpp re/symbol_generator.cpp printer_re.cpp)
     
    103103endif()
    104104
    105 #Check compiler and system support for SSE or AVX
     105#Disable RunTime Type Information
     106
     107IF (MSVC) # using Visual Studio C++
     108  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /GR-")
     109ELSE() # using Clang, GCC, Intel C++, etc
     110  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti")
     111ENDIF()
     112
     113
     114#Check compiler and system architecture support for SSE or AVX
    106115include(CheckCXXSourceRuns)
    107116
     
    230239endif()
    231240
    232 SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -DNDEBUG")
     241SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS} -O3 -DNDEBUG")
    233242
    234243add_test(
  • icGREP/icgrep-devel/icgrep/cc/cc_compiler.cpp

    r4199 r4200  
    99
    1010//Pablo Expressions
    11 #include <pablo/pablo_routines.h>
    1211#include <pablo/ps_pablos.h>
    1312#include <pablo/pe_advance.h>
     
    7574{   
    7675    //Add the new mapping to the list of pablo statements:
    77     mStmtsl.push_back(new Assign(varname, expr->pablo_expr));
     76    mStmtsl.push_back(make_assign(varname, expr->pablo_expr));
    7877
    7978    //Add the new mapping to the common expression map:
     
    8180    Expression* mapped_value = new Expression();
    8281    mapped_value->expr_string = varname;
    83     mapped_value->pablo_expr = new Var(varname);
     82    mapped_value->pablo_expr = make_var(varname);
    8483
    8584    std::pair<MapIterator, bool> ret = mCommon_Expression_Map.insert(make_pair(key_value, mapped_value));
     
    105104
    106105
    107 std::string CC_Compiler::compile1(CC* cc)
     106std::string CC_Compiler::compile1(CC * cc)
    108107{
    109108  cc2pablos(cc);
     
    122121}
    123122
    124 void CC_Compiler::process_re(const RE* re) {
     123void CC_Compiler::process_re(const RE * re) {
    125124    if (const Alt* re_alt = dyn_cast<const Alt>(re)) {
    126125        for (const RE * re : *re_alt) {
     
    143142PabloE* CC_Compiler::bit_pattern_expr(int pattern, int selected_bits)
    144143{
    145     if (selected_bits == 0) return new All(1);
     144    if (selected_bits == 0) return make_all(1);
    146145
    147146    std::vector<PabloE*> bit_terms;
     
    164163        else
    165164        {
    166             bit_terms.push_back(new All(1));
     165            bit_terms.push_back(make_all(1));
    167166        }
    168167        selected_bits &= ~test_bit;
     
    218217}
    219218
    220 PabloE* CC_Compiler::GE_Range(int N, int n)
    221 {
     219PabloE * CC_Compiler::GE_Range(int N, int n) {
    222220    if (N == 0)
    223221    {
    224         return new All(1); //Return a true literal.
     222        return make_all(1); //Return a true literal.
    225223    }
    226224    else if (((N % 2) == 0) && ((n >> (N - 2)) == 0))
    227225    {
    228         return make_or(make_or(make_bitv(N-1), make_bitv(N-2)), GE_Range(N-2, n));
     226        return make_or(make_or(make_bitv(N - 1), make_bitv(N - 2)), GE_Range(N - 2, n));
    229227    }
    230228    else if (((N % 2) == 0) && ((n >> (N - 2)) == 3))
    231229    {
    232         return make_and(make_and(make_bitv(N-1), make_bitv(N-2)), GE_Range(N-2, n-(3<<(N-2))));
    233     }
    234     else if(N >= 1)
     230        return make_and(make_and(make_bitv(N - 1), make_bitv(N - 2)), GE_Range(N - 2, n - (3 << (N - 2))));
     231    }
     232    else if (N >= 1)
    235233    {
    236234        int hi_bit = n & (1 << (N-1));
     
    255253        }
    256254    }
    257     else
    258     {
    259         return 0;
    260     }
    261 }
    262 
    263 PabloE* CC_Compiler::LE_Range(int N, int n)
     255    throw std::runtime_error("Unexpected input given to ge_range: " + std::to_string(N) + ", " + std::to_string(n));
     256}
     257
     258PabloE * CC_Compiler::LE_Range(int N, int n)
    264259{
    265260    /*
     
    268263    */
    269264    if ((n + 1) == (1 << N)) {
    270         return new All(1); //True.
     265        return make_all(1); //True.
    271266    }
    272267    else {
     
    277272PabloE* CC_Compiler::charset_expr(const CC * cc) {
    278273    if (cc->empty()) {
    279         return new All(0);
     274        return make_all(0);
    280275    }
    281276    if (cc->size() > 2) {
     
    339334    Expression* retExpr = new Expression();
    340335
    341     if (All* all = dynamic_cast<All*>(expr))
     336    if (All * all = dyn_cast<All>(expr))
    342337    {
    343338        if (all->getValue() == 1)
    344339        {
    345340            retExpr->expr_string = "All(1)";
    346             retExpr->pablo_expr = new All(1);
     341            retExpr->pablo_expr = make_all(1);
    347342        }
    348343        else if (all->getValue() == 0)
    349344        {
    350345            retExpr->expr_string = "All(0)";
    351             retExpr->pablo_expr = new All(0);
    352         }
    353     }
    354     else if (Var * var = dynamic_cast<Var*>(expr))
     346            retExpr->pablo_expr = make_all(0);
     347        }
     348    }
     349    else if (Var * var = dyn_cast<Var>(expr))
    355350    {
    356351            retExpr->expr_string = var->getVar();
    357             retExpr->pablo_expr = new Var(var->getVar());
    358     }
    359     else if (Not* pe_not = dynamic_cast<Not*>(expr))
     352            retExpr->pablo_expr = make_var(var->getVar());
     353    }
     354    else if (Not * pe_not = dyn_cast<Not>(expr))
    360355    {
    361356        Expression* ret = expr_to_variable(expr2pabloe(pe_not->getExpr()));
    362357        retExpr->expr_string =  "~" + ret->expr_string;
    363         retExpr->pablo_expr = new Not(ret->pablo_expr);
    364     }
    365     else if(Or* pe_or = dynamic_cast<Or*>(expr))
     358        retExpr->pablo_expr = make_not(ret->pablo_expr);
     359    }
     360    else if(Or * pe_or = dyn_cast<Or>(expr))
    366361    {
    367362        Expression* ret1 = expr_to_variable(expr2pabloe(pe_or->getExpr1()));
    368363        Expression* ret2 = expr_to_variable(expr2pabloe(pe_or->getExpr2()));
    369364        retExpr->expr_string = "(" + ret1->expr_string + "|" + ret2->expr_string + ")";
    370         retExpr->pablo_expr = new Or(ret1->pablo_expr, ret2->pablo_expr);
    371     }
    372     else if (Xor* pe_xor = dynamic_cast<Xor*>(expr))
     365        retExpr->pablo_expr = make_or(ret1->pablo_expr, ret2->pablo_expr);
     366    }
     367    else if (Xor * pe_xor = dyn_cast<Xor>(expr))
    373368    {
    374369        Expression* ret1 = expr_to_variable(expr2pabloe(pe_xor->getExpr1()));
    375370        Expression* ret2 = expr_to_variable(expr2pabloe(pe_xor->getExpr2()));
    376371        retExpr->expr_string = "(" + ret1->expr_string + "^" + ret2->expr_string + ")";
    377         retExpr->pablo_expr = new Xor(ret1->pablo_expr, ret2->pablo_expr);
    378     }
    379     else if (And* pe_and = dynamic_cast<And*>(expr))
    380     {
    381         if (Not* pe_not = dynamic_cast<Not*>(pe_and->getExpr1()))
     372        retExpr->pablo_expr = make_xor(ret1->pablo_expr, ret2->pablo_expr);
     373    }
     374    else if (And * pe_and = dyn_cast<And>(expr))
     375    {
     376        if (Not * pe_not = dyn_cast<Not>(pe_and->getExpr1()))
    382377        {
    383378            Expression* ret1 = expr_to_variable(expr2pabloe(pe_not->getExpr()));
    384379            Expression* ret2 = expr_to_variable(expr2pabloe(pe_and->getExpr2()));
    385380            retExpr->expr_string = "(" + ret2->expr_string + "&~" + ret1->expr_string + ")";
    386             retExpr->pablo_expr = new And(ret2->pablo_expr, new Not(ret1->pablo_expr));
    387         }
    388         else if (Not* pe_not = dynamic_cast<Not*>(pe_and->getExpr2()))
     381            retExpr->pablo_expr = make_and(ret2->pablo_expr, make_not(ret1->pablo_expr));
     382        }
     383        else if (Not * pe_not = dyn_cast<Not>(pe_and->getExpr2()))
    389384        {
    390385            Expression* ret1 = expr_to_variable(expr2pabloe(pe_and->getExpr1()));
    391386            Expression* ret2 = expr_to_variable(expr2pabloe(pe_not->getExpr()));
    392387            retExpr->expr_string = "(" + ret1->expr_string  + "&~" + ret2->expr_string + ")";
    393             retExpr->pablo_expr = new And(ret1->pablo_expr, new Not(ret2->pablo_expr));
     388            retExpr->pablo_expr = make_and(ret1->pablo_expr, make_not(ret2->pablo_expr));
    394389        }
    395390        else
     
    398393            Expression* ret2 = expr_to_variable(expr2pabloe(pe_and->getExpr2()));
    399394            retExpr->expr_string = "(" + ret1->expr_string + "&" + ret2->expr_string + ")";
    400             retExpr->pablo_expr = new And(ret1->pablo_expr, ret2->pablo_expr);
    401         }
    402     }
    403     else if (Sel * pe_sel = dynamic_cast<Sel*>(expr))
     395            retExpr->pablo_expr = make_and(ret1->pablo_expr, ret2->pablo_expr);
     396        }
     397    }
     398    else if (Sel * pe_sel = dyn_cast<Sel>(expr))
    404399    {
    405400        Expression* ret_sel = expr_to_variable(expr2pabloe(pe_sel->getIf_expr()));
     
    408403        retExpr->expr_string = "((" + ret_sel->expr_string + "&" + ret_true->expr_string + ")|(~("
    409404            + ret_sel->expr_string + ")&" + ret_false->expr_string + ")";
    410         retExpr->pablo_expr = new Sel(ret_sel->pablo_expr, ret_true->pablo_expr, ret_false->pablo_expr);
     405        retExpr->pablo_expr = make_sel(ret_sel->pablo_expr, ret_true->pablo_expr, ret_false->pablo_expr);
    411406    }
    412407
     
    426421PabloE* CC_Compiler::make_bitv(int n)
    427422{
    428     return new Var(bit_var((mEncoding.getBits() - 1) - n));
     423    return make_var(bit_var((mEncoding.getBits() - 1) - n));
    429424}
    430425
  • icGREP/icgrep-devel/icgrep/llvm_gen.cpp

    r4199 r4200  
    661661void LLVM_Generator::DeclareCallFunctions_PabloS(PabloE *stmt)
    662662{
    663     if (Assign* an = dynamic_cast<Assign*>(stmt))
     663    if (Assign * an = dyn_cast<Assign>(stmt))
    664664    {
    665665        DeclareCallFunctions_PabloE(an->getExpr());
    666666    }
    667     else if (If* ifstmt = dynamic_cast<If*>(stmt))
     667    else if (If * ifstmt = dyn_cast<If>(stmt))
    668668    {
    669669        DeclareCallFunctions_PabloE(ifstmt->getExpr());
    670670        DeclareCallFunctions(ifstmt->getPSList());
    671671    }
    672     else if (While* whl = dynamic_cast<While*>(stmt))
     672    else if (While * whl = dyn_cast<While>(stmt))
    673673    {
    674674        DeclareCallFunctions_PabloE(whl->getExpr());
     
    679679void LLVM_Generator::DeclareCallFunctions_PabloE(PabloE* expr)
    680680{
    681     if (Call* pablo_call = dynamic_cast<Call*>(expr))
     681    if (Call * pablo_call = dyn_cast<Call>(expr))
    682682    {
    683683        std::string callee = "wrapped_get_category_" + pablo_call->getCallee();
     
    811811        }
    812812    }
    813     else if (And* pablo_and = dynamic_cast<And*>(expr))
     813    else if (And * pablo_and = dyn_cast<And>(expr))
    814814    {
    815815        DeclareCallFunctions_PabloE(pablo_and->getExpr1());
    816816        DeclareCallFunctions_PabloE(pablo_and->getExpr2());
    817817    }
    818     else if (Or* pablo_or = dynamic_cast<Or*>(expr))
     818    else if (Or * pablo_or = dyn_cast<Or>(expr))
    819819    {
    820820        DeclareCallFunctions_PabloE(pablo_or->getExpr1());
    821821        DeclareCallFunctions_PabloE(pablo_or->getExpr2());
    822822    }
    823     else if (Sel* pablo_sel = dynamic_cast<Sel*>(expr))
     823    else if (Sel * pablo_sel = dyn_cast<Sel>(expr))
    824824    {
    825825        DeclareCallFunctions_PabloE(pablo_sel->getIf_expr());
     
    827827        DeclareCallFunctions_PabloE(pablo_sel->getF_expr());
    828828    }
    829     else if (Not* pablo_not = dynamic_cast<Not*>(expr))
     829    else if (Not * pablo_not = dyn_cast<Not>(expr))
    830830    {
    831831        DeclareCallFunctions_PabloE(pablo_not->getExpr());
    832832    }
    833     else if (Advance* adv = dynamic_cast<Advance*>(expr))
     833    else if (Advance * adv = dyn_cast<Advance>(expr))
    834834    {
    835835        DeclareCallFunctions_PabloE(adv->getExpr());
    836836    }
    837     else if (MatchStar* mstar = dynamic_cast<MatchStar*>(expr))
     837    else if (MatchStar * mstar = dyn_cast<MatchStar>(expr))
    838838    {
    839839        DeclareCallFunctions_PabloE(mstar->getExpr1());
    840840        DeclareCallFunctions_PabloE(mstar->getExpr2());
    841841    }
    842     else if (ScanThru* sthru = dynamic_cast<ScanThru*>(expr))
     842    else if (ScanThru * sthru = dyn_cast<ScanThru>(expr))
    843843    {
    844844        DeclareCallFunctions_PabloE(sthru->getScanFrom());
     
    901901    std::string retVal = "";
    902902
    903     if (Assign* assign = dynamic_cast<Assign*>(stmt))
     903    if (Assign * assign = dyn_cast<Assign>(stmt))
    904904    {
    905905        IRBuilder<> b(mBasicBlock);
     
    909909        retVal = assign->getM();
    910910    }
    911     else if (If* ifstmt = dynamic_cast<If*>(stmt))
     911    else if (If * ifstmt = dyn_cast<If>(stmt))
    912912    {
    913913        BasicBlock*  ifEntryBlock = mBasicBlock;
     
    939939                if_carry_accum_value = b_ifbody.CreateOr(carryq_value, if_carry_accum_value);
    940940            }
    941             Value* void_1 = genCarryOutStore(if_carry_accum_value, mptr_carry_q, if_accum_idx);
     941            genCarryOutStore(if_carry_accum_value, mptr_carry_q, if_accum_idx);
    942942
    943943        }
     
    958958        retVal = returnMarker;
    959959    }
    960     else if (While* whl = dynamic_cast<While*>(stmt))
     960    else if (While* whl = dyn_cast<While>(stmt))
    961961    {
    962962        int idx = mCarryQueueIdx;
     
    987987        //Create and initialize a new carry queue.
    988988        Value* ptr_while_carry_q = b_wb1.CreateAlloca(mXi64Vect, b_wb1.getInt64(mCarryQueueSize - idx));
    989         for (int i=0; i<(mCarryQueueSize-idx); i++)
     989        for (int i=0; i < (mCarryQueueSize - idx); i++)
    990990        {
    991             Value* void_1 = genCarryOutStore(mConst_Aggregate_Xi64_0, ptr_while_carry_q, i);
     991            genCarryOutStore(mConst_Aggregate_Xi64_0, ptr_while_carry_q, i);
    992992        }
    993993
     
    999999        IRBuilder<> b_wb2(mBasicBlock);
    10001000        //Copy back to the last carry queue the carries from the execution of the while statement list.
    1001         for (int c=0; c<(mCarryQueueSize-idx); c++)
     1001        for (int c = 0; c < (mCarryQueueSize - idx); c++)
    10021002        {
    10031003            Value* new_carryq_value = b_wb2.CreateOr(genCarryInLoad(mptr_carry_q, c), genCarryInLoad(ptr_last_carry_q, idx + c));
    1004             Value* void_1 = genCarryOutStore(new_carryq_value, ptr_last_carry_q, idx + c);
     1004            genCarryOutStore(new_carryq_value, ptr_last_carry_q, idx + c);
    10051005        }
    10061006
     
    10211021    Value* retVal = 0;
    10221022
    1023     if (All* all = dynamic_cast<All*>(expr))
     1023    if (All* all = dyn_cast<All>(expr))
    10241024    {
    10251025        IRBuilder<> b(mBasicBlock);
    10261026        Value* ptr_all = b.CreateAlloca(mXi64Vect);
    1027         Value* void_1 = b.CreateStore((all->getValue() == 0 ? mConst_Aggregate_Xi64_0 : mConst_Aggregate_Xi64_neg1), ptr_all);
     1027        b.CreateStore((all->getValue() == 0 ? mConst_Aggregate_Xi64_0 : mConst_Aggregate_Xi64_neg1), ptr_all);
    10281028        Value* all_value = b.CreateLoad(ptr_all);
    10291029        retVal = all_value;
    10301030    }
    1031     else if (Call* call = dynamic_cast<Call*>(expr))
     1031    else if (Call* call = dyn_cast<Call>(expr))
    10321032    {
    10331033        IRBuilder<> b(mBasicBlock);
     
    10501050        retVal = var_value;
    10511051    }
    1052     else if (Var* var = dynamic_cast<Var*>(expr))
     1052    else if (Var * var = dyn_cast<Var>(expr))
    10531053    {
    10541054        IRBuilder<> b(mBasicBlock);
     
    10581058        retVal = var_value;
    10591059    }
    1060     else if (And* pablo_and = dynamic_cast<And*>(expr))
     1060    else if (And * pablo_and = dyn_cast<And>(expr))
    10611061    {
    10621062        IRBuilder<> b(mBasicBlock);
     
    10661066        retVal = and_result;
    10671067    }
    1068     else if (Or* pablo_or = dynamic_cast<Or*>(expr))
     1068    else if (Or * pablo_or = dyn_cast<Or>(expr))
    10691069    {
    10701070        IRBuilder<> b(mBasicBlock);
     
    10741074        retVal = or_result;
    10751075    }
    1076     else if (Sel* pablo_sel = dynamic_cast<Sel*>(expr))
     1076    else if (Sel * pablo_sel = dyn_cast<Sel>(expr))
    10771077    {
    10781078        IRBuilder<>b(mBasicBlock);
     
    10841084        retVal = or_result;
    10851085    }
    1086     else if (Not* pablo_not = dynamic_cast<Not*>(expr))
     1086    else if (Not * pablo_not = dyn_cast<Not>(expr))
    10871087    {
    10881088        IRBuilder<> b(mBasicBlock);
     
    10931093        retVal = xor_rslt;
    10941094    }
    1095     else if (CharClass* cc = dynamic_cast<CharClass*>(expr))
     1095    else if (CharClass * cc = dyn_cast<CharClass>(expr))
    10961096    {
    10971097        IRBuilder<> b(mBasicBlock);
     
    11011101        retVal = character_class;
    11021102    }
    1103     else if (Advance* adv = dynamic_cast<Advance*>(expr))
     1103    else if (Advance * adv = dyn_cast<Advance>(expr))
    11041104    {
    11051105        IRBuilder<> b(mBasicBlock);
     
    11071107        retVal = genAdvanceWithCarry(strm_value);
    11081108    }
    1109     else if (MatchStar* mstar = dynamic_cast<MatchStar*>(expr))
     1109    else if (MatchStar * mstar = dyn_cast<MatchStar>(expr))
    11101110    {
    11111111        IRBuilder<> b(mBasicBlock);
     
    11141114        retVal = genMatchStar(strm_value, cc_value);
    11151115    }
    1116     else if (ScanThru* sthru = dynamic_cast<ScanThru*>(expr))
     1116    else if (ScanThru * sthru = dyn_cast<ScanThru>(expr))
    11171117    {
    11181118        IRBuilder<> b(mBasicBlock);
  • icGREP/icgrep-devel/icgrep/llvm_gen_helper.cpp

    r4199 r4200  
    88
    99//Pablo Expressions
    10 #include "pe_pabloe.h"
    11 #include "pe_advance.h"
    12 #include "pe_and.h"
    13 #include "pe_charclass.h"
    14 #include "pe_not.h"
    15 #include "pe_or.h"
    16 #include "pe_matchstar.h"
    17 #include "pe_scanthru.h"
     10#include <pablo/pe_pabloe.h>
     11#include <pablo/pe_advance.h>
     12#include <pablo/pe_and.h>
     13#include <pablo/pe_charclass.h>
     14#include <pablo/pe_not.h>
     15#include <pablo/pe_or.h>
     16#include <pablo/pe_matchstar.h>
     17#include <pablo/pe_scanthru.h>
    1818
    1919//Pablo Statements
    20 #include "ps_pablos.h"
    21 #include "ps_assign.h"
    22 #include "ps_if.h"
    23 #include "ps_while.h"
     20#include <pablo/ps_pablos.h>
     21#include <pablo/ps_assign.h>
     22#include <pablo/ps_if.h>
     23#include <pablo/ps_while.h>
    2424
    2525using namespace pablo;
     
    4242    int retVal = 0;
    4343
    44     if (Assign* sm = dynamic_cast<Assign*>(stmt))
     44    if (Assign* sm = dyn_cast<Assign>(stmt))
    4545    {
    4646        retVal = CarryCount_PabloE(sm->getExpr());
    4747    }
    48     else if (If* ifstmt = dynamic_cast<If*>(stmt)) {
     48    else if (If* ifstmt = dyn_cast<If>(stmt)) {
    4949        retVal = CarryCount_PabloE(ifstmt->getExpr());
    5050        retVal += CarryCount_PabloStatements(ifstmt->getPSList());
     
    5454        if (retVal > 1) retVal++;
    5555    }
    56     else if (While* whl = dynamic_cast<While*>(stmt))
     56    else if (While* whl = dyn_cast<While>(stmt))
    5757    {
    5858        retVal = CarryCount_PabloE(whl->getExpr());
     
    6767    int retVal = 0;
    6868
    69     if (And* pablo_and = dynamic_cast<And*>(expr))
     69    if (And* pablo_and = dyn_cast<And>(expr))
    7070    {
    7171        retVal =  CarryCount_PabloE(pablo_and->getExpr1()) + CarryCount_PabloE(pablo_and->getExpr2());
    7272    }
    73     else if (Or* pablo_or = dynamic_cast<Or*>(expr))
     73    else if (Or* pablo_or = dyn_cast<Or>(expr))
    7474    {
    7575        retVal = CarryCount_PabloE(pablo_or->getExpr1()) + CarryCount_PabloE(pablo_or->getExpr2());
    7676    }
    77     else if (Not* pablo_not = dynamic_cast<Not*>(expr))
     77    else if (Not* pablo_not = dyn_cast<Not>(expr))
    7878    {
    7979        retVal = CarryCount_PabloE(pablo_not->getExpr());
    8080    }
    81     else if (Advance* adv = dynamic_cast<Advance*>(expr))
     81    else if (Advance* adv = dyn_cast<Advance>(expr))
    8282    {
    8383        //Carry queues are needed for advances.
    8484        retVal = 1 + CarryCount_PabloE(adv->getExpr());
    8585    }
    86     else if(MatchStar* mstar = dynamic_cast<MatchStar*>(expr))
     86    else if(MatchStar* mstar = dyn_cast<MatchStar>(expr))
    8787    {
    8888        //Carry queues are also needed for MatchStar.
    8989        retVal = 1 + CarryCount_PabloE(mstar->getExpr1()) + CarryCount_PabloE(mstar->getExpr2());
    9090    }
    91     else if (ScanThru* sthru = dynamic_cast<ScanThru*>(expr))
     91    else if (ScanThru* sthru = dyn_cast<ScanThru>(expr))
    9292    {
    9393        retVal = 1 + CarryCount_PabloE(sthru->getScanFrom()) + CarryCount_PabloE(sthru->getScanThru());
  • icGREP/icgrep-devel/icgrep/pablo/pe_advance.h

    r4199 r4200  
    1313
    1414class Advance : public PabloE {
     15    friend Advance * make_advance(PabloE * expr);
    1516public:
    16     Advance(PabloE * expr)
    17     : PabloE(ClassTypeId::Advance)
    18     , mExpr(expr) {
    19 
     17    static inline bool classof(const PabloE * e) {
     18        return e->getClassTypeId() == ClassTypeId::Advance;
    2019    }
    21 
     20    static inline bool classof(const void *) {
     21        return false;
     22    }
    2223    virtual ~Advance() {
    2324        delete mExpr;
     
    2728        return mExpr;
    2829    }
     30protected:
     31    Advance(PabloE * expr)
     32    : PabloE(ClassTypeId::Advance)
     33    , mExpr(expr) {
    2934
     35    }
    3036private:
    31     PabloE * mExpr;
     37    PabloE * const mExpr;
    3238};
     39
     40inline Advance * make_advance(PabloE * expr) {
     41    return new Advance(expr);
     42}
    3343
    3444}
  • icGREP/icgrep-devel/icgrep/pablo/pe_all.h

    r4199 r4200  
    1313
    1414class All : public PabloE {
     15    friend All * make_all(bool value);
    1516public:
    16 
    17     All(const bool value)
    18     : PabloE(ClassTypeId::All)
    19     , mValue(value)
    20     {
    21 
     17    static inline bool classof(const PabloE * e) {
     18        return e->getClassTypeId() == ClassTypeId::All;
     19    }
     20    static inline bool classof(const void *) {
     21        return false;
    2222    }
    2323
     
    2929        return mValue;
    3030    }
     31protected:
     32    All(const bool value)
     33    : PabloE(ClassTypeId::All)
     34    , mValue(value)
     35    {
    3136
    32     inline void setValue(const bool value) {
    33         mValue = value;
    3437    }
     38private:
     39    const bool mValue;
     40};
    3541
    36 private:
    37     bool mValue;
    38 };
     42inline All * make_all(bool value) {
     43    return new All(value);
     44}
    3945
    4046}
  • icGREP/icgrep-devel/icgrep/pablo/pe_and.cpp

    r4199 r4200  
    66
    77#include "pe_and.h"
     8#include "pe_all.h"
     9#include "pe_not.h"
     10#include "pe_or.h"
     11
     12namespace pablo {
     13
     14PabloE * make_and(PabloE * expr1, PabloE *expr2) {
     15    if (All * all = dyn_cast<All>(expr1)) {
     16        if (all->getValue()) {
     17            return expr2;
     18        }
     19        else {
     20            return make_all(0);
     21        }
     22    }
     23    else if (All* all = dyn_cast<All>(expr2)) {
     24        if (all->getValue()) {
     25            return expr1;
     26        }
     27        else {
     28            return make_all(0);
     29        }
     30    }
     31    else if (equals(expr1, expr2)) {
     32        return expr1;
     33    }
     34    else if (Not * pe_not_e1 = dyn_cast<Not>(expr1)) {
     35        if (Not * pe_not_e2 = dyn_cast<Not>(expr2)) {
     36            return make_not(make_or(pe_not_e1->getExpr(), pe_not_e2->getExpr()));
     37        }
     38        else if (equals(pe_not_e1->getExpr(), expr2)) {
     39            return make_all(0);
     40        }
     41    }
     42    else if (Not * pe_not_e2 = dyn_cast<Not>(expr2)) {
     43        if (equals(expr1, pe_not_e2->getExpr())) {
     44            return make_all(0);
     45        }
     46    }
     47    return new And(expr1, expr2);
     48}
     49
     50}
  • icGREP/icgrep-devel/icgrep/pablo/pe_and.h

    r4199 r4200  
    1313
    1414class And : public PabloE {
     15    friend PabloE * make_and(PabloE *, PabloE *);
    1516public:
    16     And(PabloE * expr1, PabloE * expr2)
    17     : PabloE(ClassTypeId::And)
    18     , mExpr1(expr1)
    19     , mExpr2(expr2)
    20     {
    21 
     17    static inline bool classof(const PabloE * e) {
     18        return e->getClassTypeId() == ClassTypeId::And;
     19    }
     20    static inline bool classof(const void *) {
     21        return false;
    2222    }
    2323    virtual ~And() {
     
    3131        return mExpr2;
    3232    }
     33protected:
     34    And(PabloE * expr1, PabloE * expr2)
     35    : PabloE(ClassTypeId::And)
     36    , mExpr1(expr1)
     37    , mExpr2(expr2)
     38    {
     39
     40    }
    3341private:
    34     PabloE* mExpr1;
    35     PabloE* mExpr2;
     42    PabloE * const mExpr1;
     43    PabloE * const mExpr2;
    3644};
     45
     46PabloE * make_and(PabloE * expr1, PabloE * expr2);
    3747
    3848}
  • icGREP/icgrep-devel/icgrep/pablo/pe_call.h

    r4199 r4200  
    88
    99class Call : public PabloE {
     10    friend Call * make_call(const std::string callee);
    1011public:
    11     Call(std::string callee)
    12     : PabloE(ClassTypeId::Call)
    13     , mCallee(callee) {
    14 
     12    static inline bool classof(const PabloE * e) {
     13        return e->getClassTypeId() == ClassTypeId::Call;
    1514    }
    16 
     15    static inline bool classof(const void *) {
     16        return false;
     17    }
    1718    virtual ~Call() {
    1819
     
    2223        return mCallee;
    2324    }
     25protected:
     26    Call(const std::string callee)
     27    : PabloE(ClassTypeId::Call)
     28    , mCallee(callee) {
     29
     30    }
    2431private:
    25     std::string mCallee;
     32    const std::string mCallee;
    2633};
     34
     35inline Call * make_call(const std::string callee) {
     36    return new Call(callee);
     37}
    2738
    2839}
  • icGREP/icgrep-devel/icgrep/pablo/pe_charclass.h

    r4199 r4200  
    1313namespace pablo {
    1414
    15 class CharClass : public PabloE
    16 {
     15class CharClass : public PabloE {
     16    friend CharClass * make_charclass(const std::string cc);
    1717public:
    18     CharClass(std::string charClass)
     18    static inline bool classof(const PabloE * e) {
     19        return e->getClassTypeId() == ClassTypeId::CharClass;
     20    }
     21    static inline bool classof(const void *) {
     22        return false;
     23    }
     24    virtual ~CharClass(){
     25
     26    }
     27    inline const std::string & getCharClass() const {
     28        return mCharClass;
     29    }
     30protected:
     31    CharClass(const std::string charClass)
    1932    : PabloE(ClassTypeId::CharClass)
    2033    , mCharClass(charClass)
     
    2235
    2336    }
    24 
    25     virtual ~CharClass(){
    26 
    27     }
    28 
    29     inline const std::string & getCharClass() const {
    30         return mCharClass;
    31     }
    32 
    3337private:
    3438    const std::string mCharClass;
    3539};
     40
     41inline CharClass * make_charclass(const std::string cc) {
     42    return new CharClass(cc);
     43}
    3644
    3745}
  • icGREP/icgrep-devel/icgrep/pablo/pe_matchstar.h

    r4199 r4200  
    1414class MatchStar : public PabloE {
    1515public:
     16    static inline bool classof(const PabloE * e) {
     17        return e->getClassTypeId() == ClassTypeId::MatchStar;
     18    }
     19    static inline bool classof(const void *) {
     20        return false;
     21    }
    1622    MatchStar(PabloE * expr1, PabloE * expr2)
    1723    : PabloE(ClassTypeId::MatchStar)
     
    3642
    3743private:
    38     PabloE* mExpr1;
    39     PabloE* mExpr2;
     44    PabloE * const mExpr1;
     45    PabloE * const mExpr2;
    4046};
    4147
  • icGREP/icgrep-devel/icgrep/pablo/pe_not.cpp

    r4199 r4200  
    66
    77#include "pe_not.h"
     8#include "pe_all.h"
     9
     10namespace pablo {
     11
     12PabloE * make_not(PabloE * expr) {
     13    if (All * all = dyn_cast<All>(expr)) {
     14        return make_all(!all->getValue());
     15    }
     16    else if (Not * pe_not = dyn_cast<Not>(expr)) {
     17        return pe_not->getExpr();
     18    }
     19    return new Not(expr);
     20}
     21
     22}
  • icGREP/icgrep-devel/icgrep/pablo/pe_not.h

    r4199 r4200  
    1212namespace pablo {
    1313
    14 class Not : public PabloE
    15 {
     14class Not : public PabloE {
     15    friend PabloE * make_not(PabloE *);
    1616public:
    17     Not(PabloE* expr)
     17    static inline bool classof(const PabloE * e) {
     18        return e->getClassTypeId() == ClassTypeId::Not;
     19    }
     20    static inline bool classof(const void *) {
     21        return false;
     22    }
     23
     24
     25    ~Not() {
     26        delete mExpr;
     27    }
     28    PabloE * getExpr() const {
     29        return mExpr;
     30    }
     31protected:
     32    Not(PabloE * expr)
    1833    : PabloE(ClassTypeId::Not)
    1934    , mExpr(expr) {
    2035
    2136    }
     37private:
     38    PabloE * const mExpr;
     39};
    2240
    23     ~Not() {
    24         delete mExpr;
    25     }
    26 
    27     PabloE * getExpr() const {
    28         return mExpr;
    29     }
    30 
    31     void setExpr(PabloE * expr) {
    32         mExpr = expr;
    33     }
    34 
    35 private:
    36     PabloE* mExpr;
    37 };
     41PabloE * make_not(PabloE * expr);
    3842
    3943}
  • icGREP/icgrep-devel/icgrep/pablo/pe_or.cpp

    r4199 r4200  
    66
    77#include "pe_or.h"
     8#include "pe_all.h"
     9#include "pe_not.h"
     10#include "pe_and.h"
     11
     12namespace pablo {
     13
     14PabloE * make_or(PabloE * expr1, PabloE * expr2) {
     15    if (All * all = dyn_cast<All>(expr1)) {
     16        if (all->getValue() == 1) {
     17            return all; //Return a true literal.
     18        }
     19        else {
     20            return expr2;
     21        }
     22    }
     23    else if (All * all = dyn_cast<All>(expr2)) {
     24        if (all->getValue() == 1) {
     25            return all; //Return a true literal.
     26        }
     27        else {
     28            return expr1;
     29        }
     30    }
     31    else if (Not * not1 = dyn_cast<Not>(expr1)) {
     32        // ¬a√b = ¬¬(¬a√b) = ¬(a ∧ ¬b)
     33        return make_not(make_and(not1->getExpr(), make_not(expr2)));
     34    }
     35    else if (Not * not2 = dyn_cast<Not>(expr2)) {
     36        // a√¬b = ¬¬(¬b√a) = ¬(b ∧ ¬a)
     37        return make_not(make_and(not2->getExpr(), make_not(expr1)));
     38    }
     39    else if (equals(expr1, expr2)) {
     40        return expr1;
     41    }
     42    else if (And * and_expr1 = dyn_cast<And>(expr1)) {
     43        if (And * and_expr2 = dyn_cast<And>(expr2)) {
     44            PabloE * const expr1a = and_expr1->getExpr1();
     45            PabloE * const expr1b = and_expr1->getExpr2();
     46            PabloE * const expr2a = and_expr2->getExpr1();
     47            PabloE * const expr2b = and_expr2->getExpr1();
     48            //These optimizations factor out common components that can occur when sets are formed by union
     49            //(e.g., union of [a-z] and [A-Z].
     50            if (equals(expr1a, expr2a)) {
     51                return make_and(expr1a, make_or(expr1b, expr2b));
     52            }
     53            else if (equals(expr1b, expr2b)) {
     54                return make_and(expr1b, make_or(expr1a, expr2a));
     55            }
     56            else if (equals(expr1a, expr2b)) {
     57                return make_and(expr1a, make_or(expr1b, expr2a));
     58            }
     59            else if (equals(expr1b, expr2a)) {
     60                return make_and(expr1b, make_or(expr1a, expr2b));
     61            }
     62        }
     63    }
     64
     65    return new Or(expr1, expr2);
     66}
     67
     68}
  • icGREP/icgrep-devel/icgrep/pablo/pe_or.h

    r4199 r4200  
    1313
    1414class Or : public PabloE {
     15    friend PabloE * make_or(PabloE *, PabloE *);
    1516public:
    16     Or(PabloE * expr1, PabloE * expr2)
    17     : PabloE(ClassTypeId::MatchStar)
    18     , mExpr1(expr1)
    19     , mExpr2(expr2)
    20     {
    21 
     17    static inline bool classof(const PabloE * e) {
     18        return e->getClassTypeId() == ClassTypeId::Or;
    2219    }
    23 
     20    static inline bool classof(const void *) {
     21        return false;
     22    }
    2423    virtual ~Or() {
    2524        delete mExpr1;
     
    3433        return mExpr2;
    3534    }
     35protected:
     36    Or(PabloE * expr1, PabloE * expr2)
     37    : PabloE(ClassTypeId::Or)
     38    , mExpr1(expr1)
     39    , mExpr2(expr2)
     40    {
     41
     42    }
    3643private:
    37     PabloE* mExpr1;
    38     PabloE* mExpr2;
     44    PabloE * const mExpr1;
     45    PabloE * const mExpr2;
    3946};
     47
     48PabloE * make_or(PabloE * expr1, PabloE * expr2);
    4049
    4150}
  • icGREP/icgrep-devel/icgrep/pablo/pe_pabloe.cpp

    r4199 r4200  
    66
    77#include "pe_pabloe.h"
     8#include "pe_advance.h"
     9#include "pe_all.h"
     10#include "pe_and.h"
     11#include "pe_call.h"
     12#include "pe_charclass.h"
     13#include "pe_matchstar.h"
     14#include "pe_not.h"
     15#include "pe_or.h"
     16#include "pe_pabloe.h"
     17#include "pe_scanthru.h"
     18#include "pe_sel.h"
     19#include "pe_var.h"
     20#include "pe_xor.h"
    821
    922namespace pablo {
    10     PabloE::~PabloE(){ }
     23
     24/*
     25
     26    Return true if expr1 and expr2 can be proven equivalent according to some rules,
     27    false otherwise.  Note that false may be returned i some cases when the exprs are
     28    equivalent.
     29
     30*/
     31
     32bool equals(const PabloE * expr1, const PabloE * expr2) {
     33    if (expr1->getClassTypeId() == expr2->getClassTypeId()) {
     34        if (const All * all1 = dyn_cast<const All>(expr1)) {
     35            if (const All * all2 = cast<const All>(expr2)) {
     36                return all1->getValue() == all2->getValue();
     37            }
     38        }
     39        else if (const Var * var1 = dyn_cast<const Var>(expr1)) {
     40            if (const Var * var2 = cast<const Var>(expr2)) {
     41                return (var1->getVar() == var2->getVar());
     42            }
     43        }
     44        else if (const Not* not1 = dyn_cast<const Not>(expr1)) {
     45            if (const Not* not2 = cast<const Not>(expr2)) {
     46                return equals(not1->getExpr(), not2->getExpr());
     47            }
     48        }
     49        else if (const And* and1 = dyn_cast<const And>(expr1)) {
     50            if (const And* and2 = cast<const And>(expr2)) {
     51                if (equals(and1->getExpr1(), and2->getExpr1())) {
     52                    return equals(and1->getExpr2(), and2->getExpr2());
     53                }
     54                else if (equals(and1->getExpr1(), and2->getExpr2())) {
     55                    return equals(and1->getExpr2(), and2->getExpr1());
     56                }
     57            }
     58        }
     59        else if (const Or * or1 = dyn_cast<const Or>(expr1)) {
     60            if (const Or* or2 = cast<const Or>(expr2)) {
     61                if (equals(or1->getExpr1(), or2->getExpr1())) {
     62                    return equals(or1->getExpr2(), or2->getExpr2());
     63                }
     64                else if (equals(or1->getExpr1(), or2->getExpr2())) {
     65                    return equals(or1->getExpr2(), or2->getExpr1());
     66                }
     67            }
     68        }
     69        else if (const Xor * xor1 = dyn_cast<const Xor>(expr1)) {
     70            if (const Xor * xor2 = cast<const Xor>(expr2)) {
     71                if (equals(xor1->getExpr1(), xor2->getExpr1())) {
     72                    return equals(xor1->getExpr2(), xor2->getExpr2());
     73                }
     74                else if (equals(xor1->getExpr1(), xor2->getExpr2())) {
     75                    return equals(xor1->getExpr2(), xor2->getExpr1());
     76                }
     77            }
     78        }
     79        else if (const Sel* sel1 = dyn_cast<const Sel>(expr1)) {
     80            if (const Sel* sel2 = cast<const Sel>(expr2)) {
     81                if (equals(sel1->getIf_expr(), sel2->getIf_expr())) {
     82                    if (equals(sel1->getT_expr(), sel2->getT_expr())) {
     83                        return equals(sel1->getF_expr(), sel2->getF_expr());
     84                    }
     85                }
     86            }
     87        }
     88    }
     89    return false;
    1190}
     91
     92
     93
     94PabloE::~PabloE(){ }
     95
     96
     97
     98}
  • icGREP/icgrep-devel/icgrep/pablo/pe_pabloe.h

    r4199 r4200  
    77#ifndef PE_PABLOE_H
    88#define PE_PABLOE_H
     9
     10#include <llvm/Support/Casting.h>
     11
     12using namespace llvm;
    913
    1014namespace pablo {
     
    4347};
    4448
     49bool equals(const PabloE * expr1, const PabloE *expr2);
     50
     51//template <typename To, typename From>
     52//inline static bool isa(const From * object) {
     53//    return To::classof(object);
     54//}
     55
     56//template <typename To, typename From>
     57//inline static To * cast(From * object) {
     58//    return reinterpret_cast<To *>(object);
     59//}
     60
     61//template <typename To, typename From>
     62//inline static To * dyn_cast(From * object) {
     63//    if (isa<To, From>(object)) {
     64//        return cast<To, From>(object);
     65//    }
     66//    return nullptr;
     67//}
     68
    4569}
    4670
  • icGREP/icgrep-devel/icgrep/pablo/pe_scanthru.h

    r4199 r4200  
    1313
    1414class ScanThru : public  PabloE {
     15    friend PabloE * make_scanthru(PabloE *, PabloE *);
    1516public:
    16     ScanThru(PabloE* from, PabloE* thru)
     17    static inline bool classof(const PabloE * e) {
     18        return e->getClassTypeId() == ClassTypeId::ScanThru;
     19    }
     20    static inline bool classof(const void *) {
     21        return false;
     22    }
     23    ScanThru(PabloE * from, PabloE * thru)
    1724    : PabloE(ClassTypeId::ScanThru)
    1825    , mScanFrom(from)
     
    3542    }
    3643private:
    37     PabloE* mScanFrom;
    38     PabloE* mScanThru;
     44    PabloE * const mScanFrom;
     45    PabloE * const mScanThru;
    3946};
     47
     48inline PabloE * make_scanthru(PabloE * from, PabloE * thru) {
     49    return new ScanThru(from, thru);
     50}
    4051
    4152}
  • icGREP/icgrep-devel/icgrep/pablo/pe_sel.cpp

    r4199 r4200  
    66
    77#include "pe_sel.h"
     8#include "pe_all.h"
     9#include "pe_and.h"
     10#include "pe_or.h"
     11#include "pe_not.h"
     12
     13namespace pablo {
     14
     15PabloE * make_sel(PabloE * if_expr, PabloE * t_expr, PabloE * f_expr) {
     16    if (All * all_if_expr = dyn_cast<All>(if_expr)) {
     17        if (all_if_expr->getValue()) {
     18            return t_expr;
     19        }
     20        else {
     21            return f_expr;
     22        }
     23    }
     24    else if (All * all_t_expr = dyn_cast<All>(t_expr)) {
     25        if (all_t_expr->getValue()) {
     26            return make_or(if_expr, f_expr);
     27        }
     28        else {
     29            return make_and(make_not(if_expr), f_expr);
     30        }
     31    }
     32    else if (All * all_f_expr = dyn_cast<All>(f_expr)) {
     33        if (all_f_expr->getValue()) {
     34            return make_or(make_not(if_expr), t_expr);
     35        }
     36        else {
     37            return make_and(if_expr, t_expr);
     38        }
     39    }
     40    else if (equals(t_expr, f_expr)) {
     41        return t_expr;
     42    }
     43    return new Sel(if_expr, t_expr, f_expr);
     44}
     45
     46}
  • icGREP/icgrep-devel/icgrep/pablo/pe_sel.h

    r4199 r4200  
    1212namespace pablo {
    1313
    14 class Sel : public PabloE
    15 {
     14class Sel : public PabloE {
     15    friend PabloE * make_sel(PabloE *, PabloE *, PabloE *);
    1616public:
    17     Sel(PabloE* if_expr, PabloE* t_expr, PabloE* f_expr)
    18     : PabloE(ClassTypeId::Sel)
    19     , mIf_expr(if_expr)
    20     , mT_expr(t_expr)
    21     , mF_expr(f_expr)
    22     {
    23 
     17    static inline bool classof(const PabloE * e) {
     18        return e->getClassTypeId() == ClassTypeId::Sel;
    2419    }
    25 
     20    static inline bool classof(const void *) {
     21        return false;
     22    }
    2623    virtual ~Sel() {
    2724        delete mIf_expr;
     
    4138        return mF_expr;
    4239    }
     40protected:
     41    Sel(PabloE* if_expr, PabloE* t_expr, PabloE* f_expr)
     42    : PabloE(ClassTypeId::Sel)
     43    , mIf_expr(if_expr)
     44    , mT_expr(t_expr)
     45    , mF_expr(f_expr)
     46    {
    4347
     48    }
    4449private:
    45     PabloE* mIf_expr;
    46     PabloE* mT_expr;
    47     PabloE* mF_expr;
     50    PabloE * const mIf_expr;
     51    PabloE * const mT_expr;
     52    PabloE * const mF_expr;
    4853};
     54
     55PabloE * make_sel(PabloE * if_expr, PabloE * t_expr, PabloE * f_expr);
    4956
    5057}
  • icGREP/icgrep-devel/icgrep/pablo/pe_var.h

    r4199 r4200  
    1414
    1515class Var : public PabloE {
     16    friend Var * make_var(const std::string);
    1617public:
    17     Var(std::string var)
     18    static inline bool classof(const PabloE * e) {
     19        return e->getClassTypeId() == ClassTypeId::Var;
     20    }
     21    static inline bool classof(const void *) {
     22        return false;
     23    }
     24    virtual ~Var(){
     25
     26    }
     27    inline const std::string & getVar() const {
     28        return mVar;
     29    }
     30protected:
     31    Var(const std::string var)
    1832    : PabloE(ClassTypeId::Var)
    1933    , mVar(var)
     
    2135
    2236    }
    23     virtual ~Var(){
    24 
    25     }
    26     inline std::string getVar() const {
    27         return mVar;
    28     }
    2937private:
    3038    const std::string mVar;
    3139};
     40
     41inline Var * make_var(const std::string var) {
     42    return new Var(var);
     43}
    3244
    3345}
  • icGREP/icgrep-devel/icgrep/pablo/pe_xor.cpp

    r4199 r4200  
    66
    77#include "pe_xor.h"
     8#include "pe_all.h"
     9#include "pe_not.h"
     10
     11namespace pablo {
     12
     13PabloE * make_xor(PabloE * expr1, PabloE * expr2) {
     14    if (All * all1 = dyn_cast<All>(expr1)) {
     15        if (all1->getValue()) {
     16            return make_not(expr2);
     17        }
     18        else {
     19            return expr2;
     20        }
     21    }
     22    else if (All* all2 = dyn_cast<All>(expr2)) {
     23        if (all2->getValue() == 1) {
     24            return make_not(expr1);
     25        }
     26        else { //if (all_expr2->getNum() == 0)
     27            return expr1;
     28        }
     29    }
     30    else if (Not * not1 = dyn_cast<Not>(expr1)) {
     31        if (Not * not2 = dyn_cast<Not>(expr2)) {
     32            return make_xor(not1->getExpr(), not2->getExpr());
     33        }
     34    }
     35    return new Xor(expr1, expr2);
     36}
     37
     38}
  • icGREP/icgrep-devel/icgrep/pablo/pe_xor.h

    r4199 r4200  
    1313
    1414class Xor : public PabloE {
     15    friend PabloE * make_xor(PabloE *, PabloE *);
    1516public:
     17    static inline bool classof(const PabloE * e) {
     18        return e->getClassTypeId() == ClassTypeId::Xor;
     19    }
     20    static inline bool classof(const void *) {
     21        return false;
     22    }
     23    virtual ~Xor() {
     24        delete mExpr1;
     25        delete mExpr2;
     26    }
     27    inline PabloE * getExpr1() const {
     28        return mExpr1;
     29    }
     30    inline PabloE * getExpr2() const {
     31        return mExpr2;
     32    }
     33protected:
    1634    Xor(PabloE * expr1, PabloE * expr2)
    17     : PabloE(ClassTypeId::MatchStar)
     35    : PabloE(ClassTypeId::Xor)
    1836    , mExpr1(expr1)
    1937    , mExpr2(expr2)
     
    2139
    2240    }
     41private:
     42    PabloE * const mExpr1;
     43    PabloE * const mExpr2;
     44};
    2345
    24     virtual ~Xor() {
    25         delete mExpr1;
    26         delete mExpr2;
    27     }
     46PabloE * make_xor(PabloE * expr1, PabloE * expr2);
    2847
    29     inline PabloE * getExpr1() const {
    30         return mExpr1;
    31     }
    32 
    33     inline PabloE * getExpr2() const {
    34         return mExpr2;
    35     }
    36 private:
    37     PabloE* mExpr1;
    38     PabloE* mExpr2;
    39 };
    4048}
    4149
  • icGREP/icgrep-devel/icgrep/pablo/ps_assign.h

    r4199 r4200  
    1414
    1515class Assign : public PabloE {
     16    friend Assign * make_assign(const std::string, PabloE *);
    1617public:
    17     Assign(std::string m, PabloE* expr)
     18    static inline bool classof(const PabloE * e) {
     19        return e->getClassTypeId() == ClassTypeId::Assign;
     20    }
     21    static inline bool classof(const void *) {
     22        return false;
     23    }
     24    virtual ~Assign() {
     25        delete mExpr;
     26    }
     27
     28    inline const std::string & getM() const {
     29        return mM;
     30    }
     31
     32    inline PabloE * getExpr() const {
     33        return mExpr;
     34    }
     35protected:
     36    Assign(const std::string m, PabloE * expr)
    1837    : PabloE(ClassTypeId::Assign)
    1938    , mM(m)
     
    2241
    2342    }
     43private:
     44    const std::string   mM;
     45    PabloE * const      mExpr;
     46};
    2447
    25     virtual ~Assign() {
    26         delete mExpr;
    27     }
    28 
    29     inline std::string getM() const {
    30         return mM;
    31     }
    32 
    33     inline PabloE* getExpr() const {
    34         return mExpr;
    35     }
    36 private:
    37     std::string mM;
    38     PabloE* mExpr;
    39 };
     48inline Assign * make_assign(const std::string marker, PabloE * expr) {
     49    return new Assign(marker, expr);
     50}
    4051
    4152}
  • icGREP/icgrep-devel/icgrep/pablo/ps_if.h

    r4199 r4200  
    1616public:
    1717    typedef std::list<PabloE*> List;
     18    friend If * make_if(PabloE * expr, List psl);
    1819
    19     If(PabloE * expr, List psl)
    20     : PabloE(ClassTypeId::If)
    21     , mExpr(expr)
    22     , mPSList(psl)
    23     {
     20    static inline bool classof(const PabloE * e) {
     21        return e->getClassTypeId() == ClassTypeId::If;
     22    }
     23    static inline bool classof(const void *) {
     24        return false;
     25    }
    2426
    25     }
     27
    2628
    2729    virtual ~If() {
     
    3941        return mPSList;
    4042    }
     43protected:
     44    If(PabloE * expr, List psl)
     45    : PabloE(ClassTypeId::If)
     46    , mExpr(expr)
     47    , mPSList(psl)
     48    {
    4149
     50    }
    4251private:
    43     PabloE* mExpr;
    44     List mPSList;
     52    PabloE * const mExpr;
     53    List           mPSList;
    4554};
     55
     56inline If * make_if(PabloE * expr, If::List statements) {
     57    return new If(expr, statements);
     58}
    4659
    4760}
  • icGREP/icgrep-devel/icgrep/pablo/ps_while.h

    r4199 r4200  
    1313namespace pablo {
    1414
    15 class While : public PabloE {
     15class While : public PabloE {   
     16public:
     17
     18    static inline bool classof(const PabloE * e) {
     19        return e->getClassTypeId() == ClassTypeId::While;
     20    }
     21    static inline bool classof(const void *) {
     22        return false;
     23    }
     24
    1625    typedef std::list<PabloE*> List;
    17 public:
     26
    1827    While(PabloE* expr, List psl)
    1928    : PabloE(ClassTypeId::While)
     
    3948    }
    4049private:
    41     PabloE *    mExpr;
    42     List        mPSList;
     50    PabloE * const  mExpr;
     51    List            mPSList;
    4352};
    4453
  • icGREP/icgrep-devel/icgrep/printer_pablos.cpp

    r4199 r4200  
    7474    std::string retVal = "";
    7575
    76     if (const Assign * an = dynamic_cast<const Assign*>(stmt))
     76    if (const Assign * an = dyn_cast<const Assign>(stmt))
    7777    {
    7878        retVal = "Assign('" + an->getM() + "', " + ShowPabloE(an->getExpr()) + "),";
    7979    }
    80     else if (const If * ifstmt = dynamic_cast<const If *>(stmt))
     80    else if (const If * ifstmt = dyn_cast<const If>(stmt))
    8181    {
    8282        retVal = "If(" + ShowPabloE(ifstmt->getExpr()) + ", " + Print_PB_PabloStmts(ifstmt->getPSList(), retVal) + ")";
    8383    }
    84     else if (const While * whl = dynamic_cast<const While *>(stmt))
     84    else if (const While * whl = dyn_cast<const While>(stmt))
    8585    {
    8686        retVal = "While(" + ShowPabloE(whl->getExpr()) + ", " + Print_PB_PabloStmts(whl->getPSList(), retVal) + ")";
     
    9494    std::string retVal = "";
    9595
    96     if (const All * all = dynamic_cast<const All*>(expr))
     96    if (const All * all = dyn_cast<const All>(expr))
    9797    {
    9898        retVal = "All " + std::to_string(all->getValue()) + " ";
    9999    }
    100     else if (const Call * pablo_call = dynamic_cast<const Call*>(expr))
     100    else if (const Call * pablo_call = dyn_cast<const Call>(expr))
    101101    {
    102102        retVal = "Call '" + pablo_call->getCallee() + "'";
    103103    }
    104     else if (const Var * pablo_var = dynamic_cast<const Var*>(expr))
     104    else if (const Var * pablo_var = dyn_cast<const Var>(expr))
    105105    {
    106106        retVal = "Var '" + pablo_var->getVar() + "' ";
    107107    }
    108     else if (const And * pablo_and = dynamic_cast<const And*>(expr))
     108    else if (const And * pablo_and = dyn_cast<const And>(expr))
    109109    {
    110110        retVal = "And(" + ShowPabloE(pablo_and->getExpr1()) +", " + ShowPabloE(pablo_and->getExpr2()) + ")";
    111111    }
    112     else if (const Or * pablo_or = dynamic_cast<const Or*>(expr))
     112    else if (const Or * pablo_or = dyn_cast<const Or>(expr))
    113113    {
    114114        retVal = "Or(" + ShowPabloE(pablo_or->getExpr1()) + ", " + ShowPabloE(pablo_or->getExpr2()) + ")";
    115115    }
    116     else if (const Sel * pablo_sel = dynamic_cast<const Sel*>(expr))
     116    else if (const Sel * pablo_sel = dyn_cast<const Sel>(expr))
    117117    {
    118118        retVal = "((" + ShowPabloE(pablo_sel->getIf_expr()) + "And " + ShowPabloE(pablo_sel->getT_expr()) +
    119119                ")|(Not(" + ShowPabloE(pablo_sel->getIf_expr()) + ") And " + ShowPabloE(pablo_sel->getF_expr()) + ")";
    120120    }
    121     else if (const Not * pablo_not = dynamic_cast<const Not*>(expr))
     121    else if (const Not * pablo_not = dyn_cast<const Not>(expr))
    122122    {
    123123        retVal = "Not (" + ShowPabloE(pablo_not->getExpr()) + ")";
    124124    }
    125     else if (const CharClass * cc = dynamic_cast<const CharClass*>(expr))
     125    else if (const CharClass * cc = dyn_cast<const CharClass>(expr))
    126126    {
    127127        retVal = "CharClass '" + cc->getCharClass() + "'";
    128128    }
    129     else if (const re::Name * name = dynamic_cast<const re::Name *>(expr))
    130     {
    131         retVal = "Name '" + name->getName() + "'";
    132     }
    133     else if (const Advance * adv = dynamic_cast<const Advance*>(expr))
     129    else if (const Advance * adv = dyn_cast<const Advance>(expr))
    134130    {
    135131        retVal = "Advance(" + ShowPabloE(adv->getExpr()) + ")";
    136132    }
    137     else if (const MatchStar * mstar = dynamic_cast<const MatchStar*>(expr))
     133    else if (const MatchStar * mstar = dyn_cast<const MatchStar>(expr))
    138134    {
    139135        retVal = "MatchStar (" + ShowPabloE(mstar->getExpr1()) + ", " + ShowPabloE(mstar->getExpr2()) + ")";
    140136    }
    141     else if (const ScanThru * sthru = dynamic_cast<const ScanThru*>(expr))
     137    else if (const ScanThru * sthru = dyn_cast<const ScanThru>(expr))
    142138    {
    143139        retVal = "ScanThru (" + ShowPabloE(sthru->getScanFrom()) + ", " + ShowPabloE(sthru->getScanThru()) + ")";
  • icGREP/icgrep-devel/icgrep/re/re_compiler.cpp

    r4199 r4200  
    1717
    1818//Pablo Expressions
    19 #include <pablo/pablo_routines.h>
    2019#include <pablo/ps_pablos.h>
    2120#include <pablo/pe_advance.h>
     
    5958            if (seq->getType() == Seq::Type::Byte) {
    6059                std::string gs_retVal = symgen.get("start_marker");
    61                 cg_state.stmtsl.push_back(new Assign(gs_retVal, new All(1)));
     60                cg_state.stmtsl.push_back(make_assign(gs_retVal, make_all(1)));
    6261                for (auto j = seq->begin();; ) {
    6362                    Name * name = dyn_cast<Name>(*j);
    6463                    assert (name);
    65                     And * cc_mask = new And(new Var(gs_retVal), new CharClass(name->getName()));
     64                    auto * cc_mask = make_and(make_var(gs_retVal), make_charclass(name->getName()));
    6665                    if (++j != seq->end()) {
    6766                        gs_retVal = symgen.get("marker");
    68                         cg_state.stmtsl.push_back(new Assign(gs_retVal, new Advance(cc_mask)));
     67                        cg_state.stmtsl.push_back(make_assign(gs_retVal, make_advance(cc_mask)));
    6968                    }
    7069                    else {
    71                         cg_state.stmtsl.push_back(new Assign(seq->getName(), cc_mask));
     70                        cg_state.stmtsl.push_back(make_assign(seq->getName(), cc_mask));
    7271                        break;
    7372                    }
     
    8584
    8685    std::string gs_m0 = symgen.get("start_marker");
    87     cg_state.stmtsl.push_back(new Assign(gs_m0, new All(1)));
     86    cg_state.stmtsl.push_back(make_assign(gs_m0, make_all(1)));
    8887
    8988    if (hasUnicode(re)) {
     
    9291        std::string gs_initial = symgen.get("internal.initial");
    9392        m_name_map.insert(make_pair("internal.initial", gs_initial));
    94         PabloE * u8single = new Var(m_name_map.find("UTF8-SingleByte")->second);
    95         PabloE * u8pfx2 = new Var(m_name_map.find("UTF8-Prefix2")->second);
    96         PabloE * u8pfx3 = new Var(m_name_map.find("UTF8-Prefix3")->second);
    97         PabloE * u8pfx4 = new Var(m_name_map.find("UTF8-Prefix4")->second);
    98         PabloE * u8pfx = new Or(new Or(u8pfx2, u8pfx3), u8pfx4);
    99         cg_state.stmtsl.push_back(new Assign(gs_initial, new Or(u8pfx, u8single)));
     93        PabloE * u8single = make_var(m_name_map.find("UTF8-SingleByte")->second);
     94        PabloE * u8pfx2 = make_var(m_name_map.find("UTF8-Prefix2")->second);
     95        PabloE * u8pfx3 = make_var(m_name_map.find("UTF8-Prefix3")->second);
     96        PabloE * u8pfx4 = make_var(m_name_map.find("UTF8-Prefix4")->second);
     97        PabloE * u8pfx = make_or(make_or(u8pfx2, u8pfx3), u8pfx4);
     98        cg_state.stmtsl.push_back(make_assign(gs_initial, make_or(u8pfx, u8single)));
    10099        cg_state.newsym = gs_initial;
    101100
     
    106105        //#define USE_IF_FOR_NONFINAL
    107106        #ifdef USE_IF_FOR_NONFINAL
    108         cg_state.stmtsl.push_back(new Assign(gs_nonfinal, new All(0)));
     107        cg_state.stmtsl.push_back(make_assign(gs_nonfinal, make_all(0)));
    109108        #endif
    110         PabloE * u8scope32 = new Advance(u8pfx3);
    111         PabloE * u8scope42 = new Advance(u8pfx4);
    112         PabloE * u8scope43 = new Advance(u8scope42);
    113         PabloE * assign_non_final = new Assign(gs_nonfinal, new Or(new Or(u8pfx, u8scope32), new Or(u8scope42, u8scope43)));
     109        PabloE * u8scope32 = make_advance(u8pfx3);
     110        PabloE * u8scope42 = make_advance(u8pfx4);
     111        PabloE * u8scope43 = make_advance(u8scope42);
     112        PabloE * assign_non_final = make_assign(gs_nonfinal, make_or(make_or(u8pfx, u8scope32), make_or(u8scope42, u8scope43)));
    114113        #ifdef USE_IF_FOR_NONFINAL
    115114        std::list<PabloE *> * if_body = new std::list<PabloE *> ();
     
    127126    //These three lines are specifically for grep.
    128127    std::string gs_retVal = symgen.get("marker");
    129     cg_state.stmtsl.push_back(new Assign(gs_retVal, new And(new MatchStar(new Var(cg_state.newsym),
    130         new Not(new Var(m_name_map.find("LineFeed")->second))), new Var(m_name_map.find("LineFeed")->second))));
     128    cg_state.stmtsl.push_back(make_assign(gs_retVal, make_and(new MatchStar(make_var(cg_state.newsym),
     129        make_not(make_var(m_name_map.find("LineFeed")->second))), make_var(m_name_map.find("LineFeed")->second))));
    131130    cg_state.newsym = gs_retVal;
    132131
     
    149148    else if (isa<Start>(re)) {
    150149        std::string gs_retVal = symgen.get("sol");
    151         cg_state.stmtsl.push_back(new Assign(gs_retVal, new And(new Var(cg_state.newsym), new Not(new Advance(new Not(new CharClass(m_name_map.find("LineFeed")->second)))))));
     150        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)))))));
    152151        cg_state.newsym = gs_retVal;
    153152    }
    154153    else if (isa<End>(re)) {
    155154        std::string gs_retVal = symgen.get("eol");
    156         cg_state.stmtsl.push_back(new Assign(gs_retVal, new And(new Var(cg_state.newsym), new CharClass(m_name_map.find("LineFeed")->second))));
     155        cg_state.stmtsl.push_back(make_assign(gs_retVal, make_and(make_var(cg_state.newsym), make_charclass(m_name_map.find("LineFeed")->second))));
    157156        cg_state.newsym = gs_retVal;
    158157    }
     
    161160inline void RE_Compiler::compile(Name * name, CodeGenState & cg_state) {
    162161    std::string gs_retVal = symgen.get("marker");
    163     PabloE * markerExpr = new Var(cg_state.newsym);
     162    PabloE * markerExpr = make_var(cg_state.newsym);
    164163    if (name->getType() != Name::Type::FixedLength) {
    165164        // Move the markers forward through any nonfinal UTF-8 bytes to the final position of each character.
    166         markerExpr = new And(markerExpr, new CharClass(m_name_map.find("internal.initial")->second));
    167         markerExpr = new ScanThru(markerExpr, new CharClass(m_name_map.find("internal.nonfinal")->second));
     165        markerExpr = make_and(markerExpr, make_charclass(m_name_map.find("internal.initial")->second));
     166        markerExpr = new ScanThru(markerExpr, make_charclass(m_name_map.find("internal.nonfinal")->second));
    168167    }
    169168    PabloE * ccExpr;
    170169    if (name->getType() == Name::Type::UnicodeCategory) {
    171         ccExpr = new Call(name->getName());
     170        ccExpr = make_call(name->getName());
    172171    }
    173172    else {
    174         ccExpr = new CharClass(name->getName());
     173        ccExpr = make_charclass(name->getName());
    175174    }
    176175    if (name->isNegated()) {
    177         ccExpr = new Not(new Or(new Or(ccExpr, new CharClass(m_name_map.find("LineFeed")->second)),
    178                                 new CharClass(m_name_map.find("internal.nonfinal")->second)));
    179     }
    180     cg_state.stmtsl.push_back(new Assign(gs_retVal, new Advance(new And(ccExpr, markerExpr))));
     176        ccExpr = make_not(make_or(make_or(ccExpr, make_charclass(m_name_map.find("LineFeed")->second)),
     177                                make_charclass(m_name_map.find("internal.nonfinal")->second)));
     178    }
     179    cg_state.stmtsl.push_back(make_assign(gs_retVal, make_advance(make_and(ccExpr, markerExpr))));
    181180    cg_state.newsym = gs_retVal;
    182181}
     
    191190    if (alt->empty()) {
    192191        std::string gs_retVal = symgen.get("always_fail_marker");
    193         cg_state.stmtsl.push_back(new Assign(gs_retVal, new All(0)));
     192        cg_state.stmtsl.push_back(make_assign(gs_retVal, make_all(0)));
    194193        cg_state.newsym = gs_retVal;
    195194    }
     
    203202            compile(*i, cg_state);
    204203            std::string altsym = symgen.get("alt");
    205             cg_state.stmtsl.push_back(new Assign(altsym, new Or(new Var(oldsym), new Var(cg_state.newsym))));
     204            cg_state.stmtsl.push_back(make_assign(altsym, make_or(make_var(oldsym), make_var(cg_state.newsym))));
    206205            cg_state.newsym = altsym;
    207206        }
     
    216215        PabloE* ccExpr;
    217216        if (rep_name->getType() == Name::Type::UnicodeCategory) {
    218             ccExpr = new Call(rep_name->getName());
     217            ccExpr = make_call(rep_name->getName());
    219218        }
    220219        else {
    221             ccExpr = new CharClass(rep_name->getName());
     220            ccExpr = make_charclass(rep_name->getName());
    222221        }
    223222
    224223        if (rep_name->isNegated()) {
    225             ccExpr = new Not(new Or(new Or(ccExpr, new CharClass(m_name_map.find("LineFeed")->second)), new CharClass(m_name_map.find("internal.nonfinal")->second)));
     224            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)));
    226225        }
    227226        if (rep_name->getType() == Name::Type::FixedLength) {
    228             cg_state.stmtsl.push_back(new Assign(gs_retVal, new MatchStar(new Var(cg_state.newsym), ccExpr)));
     227            cg_state.stmtsl.push_back(make_assign(gs_retVal, new MatchStar(make_var(cg_state.newsym), ccExpr)));
    229228        }
    230229        else { // Name::Unicode and Name::UnicodeCategory
    231             cg_state.stmtsl.push_back(new Assign(gs_retVal,
    232                 new And(new MatchStar(new Var(cg_state.newsym),
    233                         new Or(new CharClass(m_name_map.find("internal.nonfinal")->second), ccExpr)),
    234                                new CharClass(m_name_map.find("internal.initial")->second))));
     230            cg_state.stmtsl.push_back(make_assign(gs_retVal,
     231                make_and(new MatchStar(make_var(cg_state.newsym),
     232                        make_or(make_charclass(m_name_map.find("internal.nonfinal")->second), ccExpr)),
     233                               make_charclass(m_name_map.find("internal.initial")->second))));
    235234        }
    236235        cg_state.newsym = gs_retVal;
     
    253252    while_test_state.newsym = while_test;
    254253    compile(repeated, while_test_state);
    255     cg_state.stmtsl.push_back(new Assign(while_test, new Var(cg_state.newsym)));
    256     cg_state.stmtsl.push_back(new Assign(while_accum, new Var(cg_state.newsym)));
    257     while_test_state.stmtsl.push_back(new Assign(while_test, new And(new Var(while_test_state.newsym), new Not(new Var(while_accum)))));
    258     while_test_state.stmtsl.push_back(new Assign(while_accum, new Or(new Var(while_accum), new Var(while_test_state.newsym))));
    259     cg_state.stmtsl.push_back(new While(new Var(while_test), while_test_state.stmtsl));
     254    cg_state.stmtsl.push_back(make_assign(while_test, make_var(cg_state.newsym)));
     255    cg_state.stmtsl.push_back(make_assign(while_accum, make_var(cg_state.newsym)));
     256    while_test_state.stmtsl.push_back(make_assign(while_test, make_and(make_var(while_test_state.newsym), make_not(make_var(while_accum)))));
     257    while_test_state.stmtsl.push_back(make_assign(while_accum, make_or(make_var(while_accum), make_var(while_test_state.newsym))));
     258    cg_state.stmtsl.push_back(new While(make_var(while_test), while_test_state.stmtsl));
    260259    cg_state.newsym = while_accum;
    261260}
     
    271270         compileBoundedRep(repeated, 0, ub - 1, cg_state);
    272271         std::string altsym = symgen.get("alt");
    273          cg_state.stmtsl.push_back(new Assign(altsym, new Or(new Var(oldsym), new Var(cg_state.newsym))));
     272         cg_state.stmtsl.push_back(make_assign(altsym, make_or(make_var(oldsym), make_var(cg_state.newsym))));
    274273         cg_state.newsym = altsym;
    275274    }
  • icGREP/icgrep-devel/icgrep/re/re_re.h

    r4199 r4200  
    1010#include <vector>
    1111#include <assert.h>
     12#include <llvm/Support/Casting.h>
     13
     14using namespace llvm;
    1215
    1316namespace re {
     
    5861};
    5962
    60 template <typename To, typename From>
    61 inline static bool isa(const From * object) {
    62     return To::classof(object);
    63 }
     63//template <typename To, typename From>
     64//inline static bool isa(const From * object) {
     65//    return To::classof(object);
     66//}
    6467
    65 template <typename To, typename From>
    66 inline static To * dyn_cast(From * object) {
    67     if (isa<To, From>(object)) {
    68         return reinterpret_cast<To *>(object);
    69     }
    70     return nullptr;
    71 }
     68//template <typename To, typename From>
     69//inline static To * dyn_cast(From * object) {
     70//    if (isa<To, From>(object)) {
     71//        return reinterpret_cast<To *>(object);
     72//    }
     73//    return nullptr;
     74//}
    7275
    7376class Vector : public RE, public std::vector<RE*> {
Note: See TracChangeset for help on using the changeset viewer.