Changeset 4199 for icGREP


Ignore:
Timestamp:
Sep 30, 2014, 12:02:12 PM (5 years ago)
Author:
nmedfort
Message:

First stage of refactoring PabloE classes.

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

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/cc/cc_compiler.cpp

    r4198 r4199  
    66
    77#include "cc_compiler.h"
    8 #include "ps_pablos.h"
    98#include "utf_encoding.h"
     9
     10//Pablo Expressions
    1011#include <pablo/pablo_routines.h>
    11 
    12 //Pablo Expressions
    13 #include "pe_advance.h"
    14 #include "pe_all.h"
    15 #include "pe_and.h"
    16 #include "pe_call.h"
    17 #include "pe_charclass.h"
    18 #include "pe_matchstar.h"
    19 #include "pe_not.h"
    20 #include "pe_or.h"
    21 #include "pe_pabloe.h"
    22 #include "pe_scanthru.h"
    23 #include "pe_sel.h"
    24 #include "pe_var.h"
    25 #include "pe_xor.h"
    26 
    27 //Pablo Statements
    28 #include "ps_pablos.h"
    29 #include "ps_assign.h"
    30 #include "ps_if.h"
    31 #include "ps_while.h"
    32 
    33 #include "re/re_alt.h"
    34 #include "re/re_cc.h"
    35 #include "re/re_seq.h"
    36 #include "re/re_rep.h"
     12#include <pablo/ps_pablos.h>
     13#include <pablo/pe_advance.h>
     14#include <pablo/pe_all.h>
     15#include <pablo/pe_and.h>
     16#include <pablo/pe_call.h>
     17#include <pablo/pe_charclass.h>
     18#include <pablo/pe_matchstar.h>
     19#include <pablo/pe_not.h>
     20#include <pablo/pe_or.h>
     21#include <pablo/pe_pabloe.h>
     22#include <pablo/pe_scanthru.h>
     23#include <pablo/pe_sel.h>
     24#include <pablo/pe_var.h>
     25#include <pablo/pe_xor.h>
     26#include <pablo/ps_pablos.h>
     27#include <pablo/ps_assign.h>
     28#include <pablo/ps_if.h>
     29#include <pablo/ps_while.h>
     30#include <re/re_alt.h>
     31#include <re/re_cc.h>
     32#include <re/re_seq.h>
     33#include <re/re_rep.h>
    3734
    3835#include <utility>
     
    10198}
    10299
    103 std::list<PabloS*> CC_Compiler::get_compiled()
     100CC_Compiler::List CC_Compiler::get_compiled()
    104101{
    105102    return mStmtsl;
     
    344341    if (All* all = dynamic_cast<All*>(expr))
    345342    {
    346         if (all->getNum() == 1)
     343        if (all->getValue() == 1)
    347344        {
    348345            retExpr->expr_string = "All(1)";
    349346            retExpr->pablo_expr = new All(1);
    350347        }
    351         else if (all->getNum() == 0)
     348        else if (all->getValue() == 0)
    352349        {
    353350            retExpr->expr_string = "All(0)";
  • icGREP/icgrep-devel/icgrep/cc/cc_compiler.h

    r4198 r4199  
    1616#include <re/re_cc.h>
    1717
     18
    1819namespace cc {
    1920
    2021struct Expression{
    2122    std::string expr_string;
    22     PabloE* pablo_expr;
     23    pablo::PabloE * pablo_expr;
    2324};
    2425
     
    2728    typedef std::map<std::string, Expression*>  ExpressionMap;
    2829    typedef ExpressionMap::iterator             MapIterator;
    29 
     30    typedef std::list<pablo::PabloE *>          List;
    3031public:
    3132    CC_Compiler(const UTF_Encoding encoding, const std::string basis_pattern, const std::string gensym_pattern);
    3233    std::string compile1(re::CC* cc);
    3334    void compile_from_map(const REMap & re_map);
    34     std::list<PabloS*> get_compiled();
     35    List get_compiled();
    3536private:
    3637    void process_re_map(const REMap &re_map);
    3738    void process_re(const re::RE *re);
    3839    std::string bit_var(int n);
    39     PabloE* make_bitv(int n);
    40     PabloE* bit_pattern_expr(int pattern, int selected_bits);
    41     PabloE* char_test_expr(const re::CodePointType ch);
    42     PabloE* make_range(const re::CodePointType n1, const re::CodePointType n2);
    43     PabloE* GE_Range(int N, int n);
    44     PabloE* LE_Range(int N, int n);
    45     PabloE* char_or_range_expr(const re::CodePointType lo, const re::CodePointType hi);
    46     PabloE* charset_expr(const re::CC *cc);
    47     Expression* expr2pabloe(PabloE* expr);
     40    pablo::PabloE * make_bitv(int n);
     41    pablo::PabloE * bit_pattern_expr(int pattern, int selected_bits);
     42    pablo::PabloE * char_test_expr(const re::CodePointType ch);
     43    pablo::PabloE * make_range(const re::CodePointType n1, const re::CodePointType n2);
     44    pablo::PabloE * GE_Range(int N, int n);
     45    pablo::PabloE * LE_Range(int N, int n);
     46    pablo::PabloE * char_or_range_expr(const re::CodePointType lo, const re::CodePointType hi);
     47    pablo::PabloE * charset_expr(const re::CC *cc);
     48    Expression* expr2pabloe(pablo::PabloE * expr);
    4849    void cc2pablos(const re::CC *cc);
    49 
    50     UTF_Encoding mEncoding;
    5150
    5251    void add_predefined(std::string key_value, Expression *mapped_value);
     
    5453    Expression* expr_to_variable(Expression* cgo);
    5554
     55    UTF_Encoding mEncoding;
    5656    std::string mGenSym_Template;
    5757    int mGenSymCounter;
    58     std::list<PabloS*> mStmtsl;
     58    List mStmtsl;
    5959    ExpressionMap mCommon_Expression_Map;
    6060};
  • icGREP/icgrep-devel/icgrep/compiler.cpp

    r4198 r4199  
    130130
    131131    cc_compiler.compile_from_map(re_map);
    132     std::list<PabloS*> cc_stmtsl = cc_compiler.get_compiled();
     132    auto cc_stmtsl = cc_compiler.get_compiled();
    133133    #ifdef DEBUG_PRINT_PBIX_AST
    134134    //Print to the terminal the AST that was generated by the character class compiler.
  • icGREP/icgrep-devel/icgrep/llvm_gen.cpp

    r4198 r4199  
    77#include "llvm_gen.h"
    88//Pablo Expressions
    9 #include "pe_advance.h"
    10 #include "pe_all.h"
    11 #include "pe_and.h"
    12 #include "pe_call.h"
    13 #include "pe_charclass.h"
    14 #include "pe_matchstar.h"
    15 #include "pe_not.h"
    16 #include "pe_or.h"
    17 #include "pe_pabloe.h"
    18 #include "pe_scanthru.h"
    19 #include "pe_sel.h"
    20 #include "pe_var.h"
    21 #include "pe_xor.h"
    22 
    23 //Pablo Statements
    24 #include "ps_pablos.h"
    25 #include "ps_assign.h"
    26 #include "ps_if.h"
    27 #include "ps_while.h"
     9#include <pablo/pe_advance.h>
     10#include <pablo/pe_all.h>
     11#include <pablo/pe_and.h>
     12#include <pablo/pe_call.h>
     13#include <pablo/pe_charclass.h>
     14#include <pablo/pe_matchstar.h>
     15#include <pablo/pe_not.h>
     16#include <pablo/pe_or.h>
     17#include <pablo/pe_pabloe.h>
     18#include <pablo/pe_scanthru.h>
     19#include <pablo/pe_sel.h>
     20#include <pablo/pe_var.h>
     21#include <pablo/pe_xor.h>
     22#include <pablo/ps_pablos.h>
     23#include <pablo/ps_assign.h>
     24#include <pablo/ps_if.h>
     25#include <pablo/ps_while.h>
     26
     27using namespace pablo;
    2828
    2929Ps* fPs = NULL; Nl* fNl = NULL; No* fNo = NULL; Lo* fLo = NULL; Ll* fLl = NULL; Lm* fLm = NULL; Nd* fNd = NULL;
     
    383383}
    384384
    385 LLVM_Gen_RetVal LLVM_Generator::Generate_LLVMIR(CodeGenState cg_state, CodeGenState subexpression_cg_state, std::list<PabloS*> cc_cgo_stmtsl)
     385LLVM_Gen_RetVal LLVM_Generator::Generate_LLVMIR(CodeGenState cg_state, CodeGenState subexpression_cg_state, List cc_cgo_stmtsl)
    386386{
    387387    //Create the module.
     
    653653}
    654654
    655 void LLVM_Generator::DeclareCallFunctions(std::list<PabloS*> stmts)
    656 {
    657     std::list<PabloS*>::iterator it;
    658     for (it = stmts.begin(); it != stmts.end(); ++it)
    659     {
     655void LLVM_Generator::DeclareCallFunctions(List stmts) {
     656    for (auto it = stmts.begin(); it != stmts.end(); ++it) {
    660657        DeclareCallFunctions_PabloS(*it);
    661658    }
    662659}
    663660
    664 void LLVM_Generator::DeclareCallFunctions_PabloS(PabloS* stmt)
     661void LLVM_Generator::DeclareCallFunctions_PabloS(PabloE *stmt)
    665662{
    666663    if (Assign* an = dynamic_cast<Assign*>(stmt))
     
    892889}
    893890
    894 std::string LLVM_Generator::Generate_PabloStatements(std::list<PabloS*> stmts)
    895 {
     891std::string LLVM_Generator::Generate_PabloStatements(List stmts) {
    896892    std::string retVal = "";
    897 
    898     std::list<PabloS*>::iterator it;
    899     for (it = stmts.begin(); it != stmts.end(); ++it)
    900     {
     893    for (auto it = stmts.begin(); it != stmts.end(); ++it) {
    901894        retVal = Generate_PabloS(*it);
    902895    }
    903 
    904896    return retVal;
    905897}
    906898
    907 std::string LLVM_Generator::Generate_PabloS(PabloS *stmt)
     899std::string LLVM_Generator::Generate_PabloS(PabloE *stmt)
    908900{
    909901    std::string retVal = "";
     
    10321024    {
    10331025        IRBuilder<> b(mBasicBlock);
    1034 
    1035         if ((all->getNum() != 0) && (all->getNum() != 1))
    1036             std::cout << "\nErr: 'All' can only be set to 1 or 0.\n" << std::endl;
    10371026        Value* ptr_all = b.CreateAlloca(mXi64Vect);
    1038         Value* void_1 = b.CreateStore((all->getNum() == 0 ? mConst_Aggregate_Xi64_0 : mConst_Aggregate_Xi64_neg1), ptr_all);
     1027        Value* void_1 = b.CreateStore((all->getValue() == 0 ? mConst_Aggregate_Xi64_0 : mConst_Aggregate_Xi64_neg1), ptr_all);
    10391028        Value* all_value = b.CreateLoad(ptr_all);
    1040 
    10411029        retVal = all_value;
    10421030    }
  • icGREP/icgrep-devel/icgrep/llvm_gen.h

    r4197 r4199  
    1414
    1515//Pablo Expressions
    16 #include "pe_pabloe.h"
    17 #include "pe_sel.h"
    18 #include "pe_advance.h"
    19 #include "pe_all.h"
    20 #include "pe_and.h"
    21 #include "pe_charclass.h"
    22 #include "pe_matchstar.h"
    23 #include "pe_not.h"
    24 #include "pe_or.h"
    25 #include "pe_call.h"
    26 #include "pe_var.h"
    27 #include "pe_xor.h"
    28 
    29 //Pablo Statements
    30 #include "ps_pablos.h"
    31 #include "ps_assign.h"
    32 #include "ps_if.h"
    33 #include "ps_while.h"
    34 
    35 #include "cc_compiler.h"
    36 
    37 // #include "pbix_compiler.h"
    38 
     16#include <pablo/pe_pabloe.h>
     17#include <pablo/ps_pablos.h>
    3918#include "llvm_gen_helper.h"
    40 
    4119#include "unicode_categories.h"
    4220//#include "unicode_categories-flat.h"
    4321//#include "unicode_categories-simple.h"
    44 
    4522#include <iostream>
    4623#include <string>
     
    10986};
    11087
    111 class LLVM_Generator
    112 {
     88class LLVM_Generator {
     89    typedef pablo::PabloE       PabloE;
     90    typedef std::list<PabloE *> List;
    11391public:
    11492    LLVM_Generator(std::map<std::string, std::string> name_map, std::string basis_pattern, int bits);
     
    11694    LLVM_Gen_RetVal Generate_LLVMIR(CodeGenState cg_state,
    11795                                    CodeGenState subexpression_cg_state,
    118                                     std::list<PabloS*> cc_cgo);
     96                                    List cc_cgo);
    11997private:
    12098    void MakeLLVMModule();
    12199    void DefineTypes();
    122100    void DeclareFunctions();
    123     void DeclareCallFunctions(std::list<PabloS*> stmts);
    124     void DeclareCallFunctions_PabloS(PabloS* stmt);
     101    void DeclareCallFunctions(List stmts);
     102    void DeclareCallFunctions_PabloS(PabloE* stmt);
    125103    void DeclareCallFunctions_PabloE(PabloE* expr);
    126104    void StoreBitBlockMarkerPtr(std::string name, int index);
     
    128106    void SetReturnMarker(std::string marker, int output_idx);
    129107    Value* GetMarker(std::string name);
    130     std::string Generate_PabloStatements(std::list<PabloS*> stmts);
    131     std::string Generate_PabloS(PabloS* stmt);
     108    std::string Generate_PabloStatements(List stmts);
     109    std::string Generate_PabloS(PabloE* stmt);
    132110    Value* Generate_PabloE(PabloE* expr);
    133111    Value* genMatchStar(Value* marker_expr, Value* cc_expr);
  • icGREP/icgrep-devel/icgrep/llvm_gen_helper.cpp

    r4187 r4199  
    2323#include "ps_while.h"
    2424
     25using namespace pablo;
     26
    2527LLVM_Generator_Helper::LLVM_Generator_Helper(){}
    2628
    27 int LLVM_Generator_Helper::CarryCount_PabloStatements(std::list<PabloS*> stmts)
     29int LLVM_Generator_Helper::CarryCount_PabloStatements(std::list<PabloE *> stmts)
    2830{
    2931    int retVal = 0;
    30 
    31     std::list<PabloS*>::iterator it;
    32     for (it = stmts.begin(); it != stmts.end(); ++it)
     32    for (auto it = stmts.begin(); it != stmts.end(); ++it)
    3333    {
    3434        retVal += CarryCount_PabloS(*it);
     
    3838}
    3939
    40 int LLVM_Generator_Helper::CarryCount_PabloS(PabloS* stmt)
     40int LLVM_Generator_Helper::CarryCount_PabloS(PabloE *stmt)
    4141{
    4242    int retVal = 0;
  • icGREP/icgrep-devel/icgrep/llvm_gen_helper.h

    r4187 r4199  
    1010#include <list>
    1111
    12 class PabloS;
     12namespace pablo {
    1313class PabloE;
     14}
    1415
    1516class LLVM_Generator_Helper
    1617{
    1718public:
    18     static int CarryCount_PabloStatements(std::list<PabloS*> stmts);
     19    static int CarryCount_PabloStatements(std::list<pablo::PabloE*> stmts);
    1920private:
    20     static int CarryCount_PabloS(PabloS* stmt);
    21     static int CarryCount_PabloE(PabloE* expr);
     21    static int CarryCount_PabloS(pablo::PabloE* stmt);
     22    static int CarryCount_PabloE(pablo::PabloE* expr);
    2223    LLVM_Generator_Helper();
    2324};
  • icGREP/icgrep-devel/icgrep/pablo/pablo_routines.cpp

    r4198 r4199  
    3737{
    3838    if (All * all = dynamic_cast<All*>(expr)) {
    39         if (all->getNum() == 1) { //If true literal.
     39        if (all->getValue() == 1) { //If true literal.
    4040            return new All(0); //Set to false literal.
    4141        }
     
    5858{
    5959    if (All* all = dynamic_cast<All*>(expr1)) {
    60         if (all->getNum() == 1) {
     60        if (all->getValue() == 1) {
    6161            delete all;
    6262            return expr2;
     
    6969    }
    7070    else if (All* all = dynamic_cast<All*>(expr2)) {
    71         if (all->getNum() == 1) {
     71        if (all->getValue() == 1) {
    7272            delete expr2;
    7373            return expr1;
     
    115115{
    116116    if (All * all = dynamic_cast<All*>(expr1)) {
    117         if (all->getNum() == 1) {
     117        if (all->getValue() == 1) {
    118118            delete expr2;
    119119            return all; //Return a true literal.
     
    125125    }
    126126    else if (All * all = dynamic_cast<All*>(expr2)) {
    127         if (all->getNum() == 1) {
     127        if (all->getValue() == 1) {
    128128            delete expr1;
    129129            return all; //Return a true literal.
     
    189189    if (All* all_if_expr = dynamic_cast<All*>(if_expr))
    190190    {
    191         if (all_if_expr->getNum() == 1)
     191        if (all_if_expr->getValue() == 1)
    192192        {
    193193            return t_expr;
     
    200200    else if (All* all_t_expr = dynamic_cast<All*>(t_expr))
    201201    {
    202         if (all_t_expr->getNum() == 1)
     202        if (all_t_expr->getValue() == 1)
    203203        {
    204204            return make_or(if_expr, f_expr);
     
    211211    else if (All* all_f_expr = dynamic_cast<All*>(f_expr))
    212212    {
    213         if (all_f_expr->getNum() == 1)
     213        if (all_f_expr->getValue() == 1)
    214214        {
    215215            return make_or(make_not(if_expr), t_expr);
     
    234234    if (All* all_expr1 = dynamic_cast<All*>(expr1))
    235235    {
    236         if (all_expr1->getNum() == 1)
     236        if (all_expr1->getValue() == 1)
    237237        {
    238238            return make_not(expr2);
     
    245245    else if (All* all_expr2 = dynamic_cast<All*>(expr2))
    246246    {
    247         if (all_expr2->getNum() == 1)
     247        if (all_expr2->getValue() == 1)
    248248        {
    249249            return make_not(expr1);
     
    278278    if (const All * all1 = dynamic_cast<const All*>(expr1)) {
    279279        if (const All * all2 = dynamic_cast<const All*>(expr2)) {
    280             return all1->getNum() == all2->getNum();
     280            return all1->getValue() == all2->getValue();
    281281        }
    282282    }
  • icGREP/icgrep-devel/icgrep/pablo/pablo_routines.h

    r4198 r4199  
    88#define COMPILER_HELPER_H
    99
     10namespace pablo {
     11
    1012class PabloE;
    11 
    12 namespace pablo {
    1313
    1414PabloE * make_not(PabloE * expr);
  • icGREP/icgrep-devel/icgrep/pablo/pe_advance.cpp

    r4198 r4199  
    77#include "pe_advance.h"
    88
    9 Advance::Advance(PabloE* expr)
    10 {
    11     mExpr = expr;
    12 }
    13 
    14 Advance::~Advance()
    15 {
    16     delete mExpr;
    17 }
    18 
    19 PabloE* Advance::getExpr()
    20 {
    21     return mExpr;
    22 }
    239
    2410
  • icGREP/icgrep-devel/icgrep/pablo/pe_advance.h

    r4198 r4199  
    1010#include "pe_pabloe.h"
    1111
    12 class Advance : public PabloE
    13 {
     12namespace pablo {
     13
     14class Advance : public PabloE {
    1415public:
    15     Advance(PabloE* expr);
    16     ~Advance();
    17     PabloE* getExpr();
     16    Advance(PabloE * expr)
     17    : PabloE(ClassTypeId::Advance)
     18    , mExpr(expr) {
     19
     20    }
     21
     22    virtual ~Advance() {
     23        delete mExpr;
     24    }
     25
     26    inline PabloE * getExpr() const {
     27        return mExpr;
     28    }
     29
    1830private:
    19     PabloE* mExpr;
     31    PabloE * mExpr;
    2032};
     33
     34}
    2135
    2236#endif // PE_ADVANCE_H
  • icGREP/icgrep-devel/icgrep/pablo/pe_all.cpp

    r4198 r4199  
    66
    77#include "pe_all.h"
    8 
    9 All::All(int num)
    10 : mNum(num)
    11 {
    12 
    13 }
    14 
    15 All::~All(){}
    16 
    17 int All::getNum() const
    18 {
    19     return mNum;
    20 }
    21 
    22 void All::setNum(int num)
    23 {
    24     mNum = num;
    25 }
  • icGREP/icgrep-devel/icgrep/pablo/pe_all.h

    r4198 r4199  
    1010#include "pe_pabloe.h"
    1111
    12 class All : public PabloE
    13 {
     12namespace pablo {
     13
     14class All : public PabloE {
    1415public:
    15     All(int num);
    16     ~All();
    17     int getNum() const;
    18     void setNum(int num);
     16
     17    All(const bool value)
     18    : PabloE(ClassTypeId::All)
     19    , mValue(value)
     20    {
     21
     22    }
     23
     24    virtual ~All() {
     25
     26    }
     27
     28    inline bool getValue() const {
     29        return mValue;
     30    }
     31
     32    inline void setValue(const bool value) {
     33        mValue = value;
     34    }
     35
    1936private:
    20     int mNum;
     37    bool mValue;
    2138};
     39
     40}
    2241
    2342#endif // PE_ALL_H
  • icGREP/icgrep-devel/icgrep/pablo/pe_and.cpp

    r4198 r4199  
    66
    77#include "pe_and.h"
    8 
    9 And::And(PabloE * expr1, PabloE * expr2)
    10 : mExpr1(expr1)
    11 , mExpr2(expr2)
    12 {
    13 
    14 }
    15 
    16 And::~And() {
    17     delete mExpr1;
    18     delete mExpr2;
    19 }
    20 
    21 PabloE * And::getExpr1() const {
    22     return mExpr1;
    23 }
    24 
    25 PabloE * And::getExpr2() const {
    26     return mExpr2;
    27 }
    28 
    29 
  • icGREP/icgrep-devel/icgrep/pablo/pe_and.h

    r4198 r4199  
    1010#include "pe_pabloe.h"
    1111
    12 class And : public PabloE
    13 {
     12namespace pablo {
     13
     14class And : public PabloE {
    1415public:
    15     And(PabloE* expr1, PabloE* expr2);
    16     ~And();
    17     PabloE* getExpr1() const;
    18     PabloE* getExpr2() const;
     16    And(PabloE * expr1, PabloE * expr2)
     17    : PabloE(ClassTypeId::And)
     18    , mExpr1(expr1)
     19    , mExpr2(expr2)
     20    {
     21
     22    }
     23    virtual ~And() {
     24        delete mExpr1;
     25        delete mExpr2;
     26    }
     27    PabloE * getExpr1() const {
     28        return mExpr1;
     29    }
     30    PabloE * getExpr2() const {
     31        return mExpr2;
     32    }
    1933private:
    2034    PabloE* mExpr1;
     
    2236};
    2337
     38}
     39
    2440#endif // PE_AND_H
    2541
  • icGREP/icgrep-devel/icgrep/pablo/pe_call.cpp

    r4198 r4199  
    66
    77#include "pe_call.h"
    8 
    9 Call::Call(std::string callee)
    10 {
    11     mCallee = callee;
    12 }
    13 
    14 Call::~Call(){}
    15 
    16 std::string Call::getCallee()
    17 {
    18     return mCallee;
    19 }
    20 
  • icGREP/icgrep-devel/icgrep/pablo/pe_call.h

    r4198 r4199  
    55#include <string>
    66
    7 class Call : public PabloE
    8 {
     7namespace pablo {
     8
     9class Call : public PabloE {
    910public:
    10     Call(std::string callee);
    11     ~Call();
    12     std::string getCallee();
     11    Call(std::string callee)
     12    : PabloE(ClassTypeId::Call)
     13    , mCallee(callee) {
     14
     15    }
     16
     17    virtual ~Call() {
     18
     19    }
     20
     21    inline const std::string & getCallee() const {
     22        return mCallee;
     23    }
    1324private:
    1425    std::string mCallee;
    1526};
    1627
     28}
     29
    1730#endif // PE_CALL_H
    1831
  • icGREP/icgrep-devel/icgrep/pablo/pe_charclass.cpp

    r4198 r4199  
    66
    77#include "pe_charclass.h"
    8 
    9 CharClass::CharClass(std::string charClass)
    10 {
    11     mCharClass = charClass;
    12 }
    13 
    14 CharClass::~CharClass(){}
    15 
    16 std::string CharClass::getCharClass()
    17 {
    18     return mCharClass;
    19 }
    20 
  • icGREP/icgrep-devel/icgrep/pablo/pe_charclass.h

    r4198 r4199  
    99
    1010#include "pe_pabloe.h"
    11 #include "string"
     11#include <string>
     12
     13namespace pablo {
    1214
    1315class CharClass : public PabloE
    1416{
    1517public:
    16     CharClass(std::string charClass);
    17     ~CharClass();
    18     std::string getCharClass();
     18    CharClass(std::string charClass)
     19    : PabloE(ClassTypeId::CharClass)
     20    , mCharClass(charClass)
     21    {
     22
     23    }
     24
     25    virtual ~CharClass(){
     26
     27    }
     28
     29    inline const std::string & getCharClass() const {
     30        return mCharClass;
     31    }
     32
    1933private:
    20     std::string mCharClass;
     34    const std::string mCharClass;
    2135};
     36
     37}
    2238
    2339#endif // PE_CHARCLASS_H
  • icGREP/icgrep-devel/icgrep/pablo/pe_matchstar.cpp

    r4198 r4199  
    66
    77#include "pe_matchstar.h"
    8 
    9 MatchStar::MatchStar(PabloE* expr1, PabloE* expr2)
    10 {
    11     mExpr1 = expr1;
    12     mExpr2 = expr2;
    13 }
    14 
    15 MatchStar::~MatchStar()
    16 {
    17     delete mExpr1;
    18     delete mExpr2;
    19 }
    20 
    21 PabloE* MatchStar::getExpr1()
    22 {
    23     return mExpr1;
    24 }
    25 
    26 PabloE* MatchStar::getExpr2()
    27 {
    28     return mExpr2;
    29 }
    30 
    31 
  • icGREP/icgrep-devel/icgrep/pablo/pe_matchstar.h

    r4198 r4199  
    1010#include "pe_pabloe.h"
    1111
    12 class MatchStar : public PabloE
    13 {
     12namespace pablo {
     13
     14class MatchStar : public PabloE {
    1415public:
    15     MatchStar(PabloE* expr1, PabloE* expr2);
    16     ~MatchStar();
    17     PabloE* getExpr1();
    18     PabloE* getExpr2();
     16    MatchStar(PabloE * expr1, PabloE * expr2)
     17    : PabloE(ClassTypeId::MatchStar)
     18    , mExpr1(expr1)
     19    , mExpr2(expr2)
     20    {
     21
     22    }
     23
     24    virtual ~MatchStar() {
     25        delete mExpr1;
     26        delete mExpr2;
     27    }
     28
     29    inline PabloE * getExpr1() const {
     30        return mExpr1;
     31    }
     32
     33    inline PabloE * getExpr2() const  {
     34        return mExpr2;
     35    }
     36
    1937private:
    2038    PabloE* mExpr1;
     
    2240};
    2341
     42}
     43
    2444#endif // PE_MATCHSTAR_H
    2545
  • icGREP/icgrep-devel/icgrep/pablo/pe_not.cpp

    r4198 r4199  
    66
    77#include "pe_not.h"
    8 
    9 Not::Not(PabloE* expr)
    10 : mExpr(expr) {
    11 
    12 }
    13 
    14 Not::~Not() {
    15     delete mExpr;
    16 }
    17 
    18 PabloE* Not::getExpr() const {
    19     return mExpr;
    20 }
    21 
    22 void Not::setExpr(PabloE * expr) {
    23     mExpr = expr;
    24 }
    25 
  • icGREP/icgrep-devel/icgrep/pablo/pe_not.h

    r4198 r4199  
    1010#include "pe_pabloe.h"
    1111
     12namespace pablo {
     13
    1214class Not : public PabloE
    1315{
    1416public:
    15     Not(PabloE * expr);
    16     ~Not();
    17     PabloE * getExpr() const;
    18     void setExpr(PabloE * expr = nullptr);
     17    Not(PabloE* expr)
     18    : PabloE(ClassTypeId::Not)
     19    , mExpr(expr) {
     20
     21    }
     22
     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
    1935private:
    2036    PabloE* mExpr;
    2137};
    2238
     39}
     40
    2341#endif // PE_NOT_H
    2442
  • icGREP/icgrep-devel/icgrep/pablo/pe_or.cpp

    r4198 r4199  
    66
    77#include "pe_or.h"
    8 
    9 Or::Or(PabloE* expr1, PabloE* expr2)
    10 : mExpr1(expr1)
    11 , mExpr2(expr2)
    12 {
    13 
    14 }
    15 
    16 Or::~Or()
    17 {
    18     delete mExpr1;
    19     delete mExpr2;
    20 }
    21 
    22 PabloE* Or::getExpr1() const
    23 {
    24     return mExpr1;
    25 }
    26 
    27 PabloE* Or::getExpr2() const
    28 {
    29     return mExpr2;
    30 }
    31 
  • icGREP/icgrep-devel/icgrep/pablo/pe_or.h

    r4198 r4199  
    1010#include "pe_pabloe.h"
    1111
    12 class Or : public PabloE
    13 {
     12namespace pablo {
     13
     14class Or : public PabloE {
    1415public:
    15     Or(PabloE* expr1, PabloE* expr2);
    16     ~Or();
    17     PabloE* getExpr1() const;
    18     PabloE* getExpr2() const;
     16    Or(PabloE * expr1, PabloE * expr2)
     17    : PabloE(ClassTypeId::MatchStar)
     18    , mExpr1(expr1)
     19    , mExpr2(expr2)
     20    {
     21
     22    }
     23
     24    virtual ~Or() {
     25        delete mExpr1;
     26        delete mExpr2;
     27    }
     28
     29    inline PabloE * getExpr1() const {
     30        return mExpr1;
     31    }
     32
     33    inline PabloE* getExpr2() const {
     34        return mExpr2;
     35    }
    1936private:
    2037    PabloE* mExpr1;
     
    2239};
    2340
     41}
     42
    2443#endif // PE_OR_H
    2544
  • icGREP/icgrep-devel/icgrep/pablo/pe_pabloe.cpp

    r4198 r4199  
    77#include "pe_pabloe.h"
    88
    9 PabloE::PabloE(){};
    10 PabloE::~PabloE(){};
    11 
    12 
     9namespace pablo {
     10    PabloE::~PabloE(){ }
     11}
  • icGREP/icgrep-devel/icgrep/pablo/pe_pabloe.h

    r4198 r4199  
    88#define PE_PABLOE_H
    99
     10namespace pablo {
     11
    1012class PabloE
    1113{
    1214public:
    13     virtual ~PabloE();
     15    enum class ClassTypeId : unsigned {
     16        Advance
     17        , All
     18        , And
     19        , Call
     20        , CharClass
     21        , MatchStar
     22        , Not
     23        , Or
     24        , ScanThru
     25        , Sel
     26        , Var
     27        , Xor
     28        , Assign
     29        , If
     30        , While
     31    };
     32    inline ClassTypeId getClassTypeId() const {
     33        return mClassTypeId;
     34    }
     35    virtual ~PabloE() = 0;
    1436protected:
    15     PabloE();
     37    inline PabloE(const ClassTypeId id)
     38    : mClassTypeId(id) {
     39
     40    }
     41private:
     42    const ClassTypeId mClassTypeId;
    1643};
     44
     45}
    1746
    1847#endif // PE_PABLOE_H
  • icGREP/icgrep-devel/icgrep/pablo/pe_scanthru.cpp

    r4198 r4199  
    66
    77#include "pe_scanthru.h"
    8 
    9 ScanThru::ScanThru(PabloE* from, PabloE* thru)
    10 {
    11     mScanFrom = from;
    12     mScanThru = thru;
    13 }
    14 
    15 ScanThru::~ScanThru()
    16 {
    17     delete mScanFrom;
    18     delete mScanThru;
    19 }
    20 
    21 PabloE* ScanThru::getScanFrom()
    22 {
    23     return mScanFrom;
    24 }
    25 
    26 PabloE* ScanThru::getScanThru()
    27 {
    28     return mScanThru;
    29 }
    30 
    31 
  • icGREP/icgrep-devel/icgrep/pablo/pe_scanthru.h

    r4198 r4199  
    1010#include "ps_pablos.h"
    1111
    12 class ScanThru :public  PabloE
    13 {
     12namespace pablo {
     13
     14class ScanThru : public  PabloE {
    1415public:
    15     ScanThru(PabloE* from , PabloE* thru);
    16     ~ScanThru();
    17     PabloE* getScanFrom();
    18     PabloE* getScanThru();
     16    ScanThru(PabloE* from, PabloE* thru)
     17    : PabloE(ClassTypeId::ScanThru)
     18    , mScanFrom(from)
     19    , mScanThru(thru)
     20    {
     21
     22    }
     23
     24    virtual ~ScanThru() {
     25        delete mScanFrom;
     26        delete mScanThru;
     27    }
     28
     29    PabloE * getScanFrom() const {
     30        return mScanFrom;
     31    }
     32
     33    PabloE * getScanThru() const {
     34        return mScanThru;
     35    }
    1936private:
    2037    PabloE* mScanFrom;
     
    2239};
    2340
     41}
     42
    2443#endif // PS_SCANTHRU_H
    2544
  • icGREP/icgrep-devel/icgrep/pablo/pe_sel.cpp

    r4198 r4199  
    66
    77#include "pe_sel.h"
    8 
    9 Sel::Sel(PabloE* if_expr, PabloE* t_expr, PabloE* f_expr)
    10 : mIf_expr(if_expr)
    11 , mT_expr(t_expr)
    12 , mF_expr(f_expr)
    13 {
    14 
    15 }
    16 
    17 Sel::~Sel()
    18 {
    19     delete mIf_expr;
    20     delete mT_expr;
    21     delete mF_expr;
    22 }
    23 
    24 PabloE* Sel::getIf_expr() const
    25 {
    26     return mIf_expr;
    27 }
    28 
    29 PabloE* Sel::getT_expr() const
    30 {
    31     return mT_expr;
    32 }
    33 
    34 PabloE* Sel::getF_expr() const
    35 {
    36     return mF_expr;
    37 }
    38 
  • icGREP/icgrep-devel/icgrep/pablo/pe_sel.h

    r4198 r4199  
    1010#include "pe_pabloe.h"
    1111
     12namespace pablo {
     13
    1214class Sel : public PabloE
    1315{
    1416public:
    15     Sel(PabloE* if_expr, PabloE* t_expr, PabloE* f_expr);
    16     ~Sel();
    17     PabloE* getIf_expr() const;
    18     PabloE* getT_expr() const;
    19     PabloE* getF_expr() const;
     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
     24    }
     25
     26    virtual ~Sel() {
     27        delete mIf_expr;
     28        delete mT_expr;
     29        delete mF_expr;
     30    }
     31
     32    inline PabloE * getIf_expr() const {
     33        return mIf_expr;
     34    }
     35
     36    inline PabloE * getT_expr() const {
     37        return mT_expr;
     38    }
     39
     40    inline PabloE * getF_expr() const {
     41        return mF_expr;
     42    }
     43
    2044private:
    2145    PabloE* mIf_expr;
     
    2448};
    2549
     50}
     51
    2652#endif // PE_SEL_H
    2753
  • icGREP/icgrep-devel/icgrep/pablo/pe_var.cpp

    r4198 r4199  
    66
    77#include "pe_var.h"
    8 
    9 Var::Var(std::string var)
    10 : mVar(var)
    11 {
    12 
    13 }
    14 
    15 Var::~Var(){}
    16 
    17 std::string Var::getVar() const
    18 {
    19     return mVar;
    20 }
    21 
  • icGREP/icgrep-devel/icgrep/pablo/pe_var.h

    r4198 r4199  
    1111#include <string>
    1212
    13 class Var : public PabloE
    14 {
     13namespace pablo {
     14
     15class Var : public PabloE {
    1516public:
    16     Var(std::string var);
    17     ~Var();
    18     void setVar(std::string var);
    19     std::string getVar() const;
     17    Var(std::string var)
     18    : PabloE(ClassTypeId::Var)
     19    , mVar(var)
     20    {
     21
     22    }
     23    virtual ~Var(){
     24
     25    }
     26    inline std::string getVar() const {
     27        return mVar;
     28    }
    2029private:
    21     std::string mVar;
     30    const std::string mVar;
    2231};
     32
     33}
     34
     35
    2336
    2437#endif // PE_VAR_H
  • icGREP/icgrep-devel/icgrep/pablo/pe_xor.cpp

    r4198 r4199  
    66
    77#include "pe_xor.h"
    8 
    9 Xor::Xor(PabloE *expr1, PabloE *expr2)
    10 : mExpr1(expr1)
    11 , mExpr2(expr2)
    12 {
    13 
    14 }
    15 
    16 Xor::~Xor()
    17 {
    18     delete mExpr1;
    19     delete mExpr2;
    20 }
    21 
    22 PabloE* Xor:: getExpr1() const
    23 {
    24     return mExpr1;
    25 }
    26 
    27 PabloE* Xor:: getExpr2() const
    28 {
    29     return mExpr2;
    30 }
    31 
    32 
  • icGREP/icgrep-devel/icgrep/pablo/pe_xor.h

    r4198 r4199  
    1010#include "pe_pabloe.h"
    1111
    12 class Xor : public PabloE
    13 {
     12namespace pablo {
     13
     14class Xor : public PabloE {
    1415public:
    15     Xor(PabloE* expr1, PabloE* expr2);
    16     ~Xor();
    17     PabloE* getExpr1() const;
    18     PabloE* getExpr2() const;
     16    Xor(PabloE * expr1, PabloE * expr2)
     17    : PabloE(ClassTypeId::MatchStar)
     18    , mExpr1(expr1)
     19    , mExpr2(expr2)
     20    {
     21
     22    }
     23
     24    virtual ~Xor() {
     25        delete mExpr1;
     26        delete mExpr2;
     27    }
     28
     29    inline PabloE * getExpr1() const {
     30        return mExpr1;
     31    }
     32
     33    inline PabloE * getExpr2() const {
     34        return mExpr2;
     35    }
    1936private:
    2037    PabloE* mExpr1;
    2138    PabloE* mExpr2;
    2239};
     40}
    2341
    2442#endif // XOR_H
  • icGREP/icgrep-devel/icgrep/pablo/ps_assign.cpp

    r4198 r4199  
    66
    77#include "ps_assign.h"
    8 
    9 Assign::Assign(std::string m, PabloE* expr)
    10 {
    11     mM = m;
    12     mExpr = expr;
    13 }
    14 
    15 Assign::~Assign()
    16 {
    17     delete mExpr;
    18 }
    19 
    20 std::string Assign::getM()
    21 {
    22     return mM;
    23 }
    24 
    25 PabloE* Assign::getExpr()
    26 {
    27     return mExpr;
    28 }
    29 
    30 
  • icGREP/icgrep-devel/icgrep/pablo/ps_assign.h

    r4198 r4199  
    88#define PS_SETMARKER_H
    99
    10 #include "ps_pablos.h"
     10#include "pe_pabloe.h"
    1111#include <string>
    1212
    13 class Assign : public PabloS
    14 {
     13namespace pablo {
     14
     15class Assign : public PabloE {
    1516public:
    16     Assign(std::string m, PabloE* expr);
    17     ~Assign();
    18     std::string getM();
    19     PabloE* getExpr();
     17    Assign(std::string m, PabloE* expr)
     18    : PabloE(ClassTypeId::Assign)
     19    , mM(m)
     20    , mExpr(expr)
     21    {
     22
     23    }
     24
     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    }
    2036private:
    2137    std::string mM;
     
    2339};
    2440
     41}
     42
    2543#endif // PS_SETMARKER_H
    2644
  • icGREP/icgrep-devel/icgrep/pablo/ps_if.cpp

    r4198 r4199  
    66
    77#include "ps_if.h"
    8 
    9 If::If(PabloE* expr, std::list<PabloS*> psl)
    10 {
    11     mExpr = expr;
    12     mPSList = psl;
    13 }
    14 
    15 If::~If()
    16 {
    17     delete mExpr;
    18     while (!mPSList.empty()) delete mPSList.front(), mPSList.pop_front();
    19 }
    20 
    21 PabloE* If::getExpr()
    22 {
    23     return mExpr;
    24 }
    25 
    26 std::list<PabloS*> If::getPSList()
    27 {
    28     return mPSList;
    29 }
    30 
  • icGREP/icgrep-devel/icgrep/pablo/ps_if.h

    r4198 r4199  
    1111#include <list>
    1212
    13 class If : public PabloS
    14 {
     13namespace pablo {
     14
     15class If : public PabloE {
    1516public:
    16     If(PabloE* expr, std::list<PabloS*> psl);
    17     ~If();
    18     PabloE* getExpr();
    19     std::list<PabloS*> getPSList();
     17    typedef std::list<PabloE*> List;
     18
     19    If(PabloE * expr, List psl)
     20    : PabloE(ClassTypeId::If)
     21    , mExpr(expr)
     22    , mPSList(psl)
     23    {
     24
     25    }
     26
     27    virtual ~If() {
     28        delete mExpr;
     29        for (auto statement : mPSList) {
     30            delete statement;
     31        }
     32    }
     33
     34    inline PabloE * getExpr() const {
     35        return mExpr;
     36    }
     37
     38    inline const List & getPSList() const {
     39        return mPSList;
     40    }
     41
    2042private:
    2143    PabloE* mExpr;
    22     std::list<PabloS*> mPSList;
     44    List mPSList;
    2345};
     46
     47}
    2448
    2549#endif // PS_IF_H
  • icGREP/icgrep-devel/icgrep/pablo/ps_pablos.cpp

    r4198 r4199  
    66
    77#include "ps_pablos.h"
    8 
    9 PabloS::PabloS(){}
    10 PabloS::~PabloS(){}
    11 
  • icGREP/icgrep-devel/icgrep/pablo/ps_pablos.h

    r4198 r4199  
    1212#include "pe_pabloe.h"
    1313
    14 class PabloS {
    15 public:
    16     virtual ~PabloS();
    17 protected:
    18     PabloS();
    19 };
    20 
    2114struct CodeGenState{
    22     std::list<PabloS*> stmtsl;
    23     std::string newsym;
     15    std::list<pablo::PabloE *> stmtsl;
     16    std::string                 newsym;
    2417};
    2518
  • icGREP/icgrep-devel/icgrep/pablo/ps_while.cpp

    r4198 r4199  
    66
    77#include "ps_while.h"
    8 
    9 While::While(PabloE* expr, std::list<PabloS*> psl)
    10 {
    11     mExpr = expr;
    12     mPSList = psl;
    13 }
    14 
    15 While::~While()
    16 {
    17     delete mExpr;
    18     while (!mPSList.empty()) delete mPSList.front(), mPSList.pop_front();
    19 }
    20 
    21 PabloE* While::getExpr()
    22 {
    23     return mExpr;
    24 }
    25 
    26 std::list<PabloS*> While::getPSList()
    27 {
    28     return mPSList;
    29 }
    30 
  • icGREP/icgrep-devel/icgrep/pablo/ps_while.h

    r4198 r4199  
    1111#include <list>
    1212
    13 class While : public PabloS
    14 {
     13namespace pablo {
     14
     15class While : public PabloE {
     16    typedef std::list<PabloE*> List;
    1517public:
    16     While(PabloE* expr, std::list<PabloS*> psl);
    17     ~While();
    18     PabloE* getExpr();
    19     std::list<PabloS*> getPSList();
     18    While(PabloE* expr, List psl)
     19    : PabloE(ClassTypeId::While)
     20    , mExpr(expr)
     21    , mPSList(psl)
     22    {
     23
     24    }
     25
     26    virtual ~While() {
     27        delete mExpr;
     28        for (auto statement : mPSList) {
     29            delete statement;
     30        }
     31    }
     32
     33    inline PabloE * getExpr() const {
     34        return mExpr;
     35    }
     36
     37    inline const List & getPSList() const {
     38        return mPSList;
     39    }
    2040private:
    21     PabloE* mExpr;
    22     std::list<PabloS*> mPSList;
     41    PabloE *    mExpr;
     42    List        mPSList;
    2343};
     44
     45}
    2446
    2547#endif // PS_WHILE_H
  • icGREP/icgrep-devel/icgrep/printer_pablos.cpp

    r4197 r4199  
    88
    99//Regular Expressions
    10 #include "re/re_re.h"
    11 #include "re/re_cc.h"
    12 #include "re/re_start.h"
    13 #include "re/re_end.h"
    14 #include "re/re_seq.h"
    15 #include "re/re_name.h"
     10#include <re/re_re.h>
     11#include <re/re_cc.h>
     12#include <re/re_start.h>
     13#include <re/re_end.h>
     14#include <re/re_seq.h>
     15#include <re/re_name.h>
    1616
    1717//Pablo Expressions
    18 #include "pe_advance.h"
    19 #include "pe_all.h"
    20 #include "pe_and.h"
    21 #include "pe_call.h"
    22 #include "pe_charclass.h"
    23 #include "pe_matchstar.h"
    24 #include "pe_not.h"
    25 #include "pe_or.h"
    26 #include "pe_pabloe.h"
    27 #include "pe_scanthru.h"
    28 #include "pe_sel.h"
    29 #include "pe_var.h"
    30 #include "pe_xor.h"
     18#include <pablo/pe_pabloe.h>
     19#include <pablo/pe_advance.h>
     20#include <pablo/pe_all.h>
     21#include <pablo/pe_and.h>
     22#include <pablo/pe_call.h>
     23#include <pablo/pe_charclass.h>
     24#include <pablo/pe_matchstar.h>
     25#include <pablo/pe_not.h>
     26#include <pablo/pe_or.h>
     27#include <pablo/pe_scanthru.h>
     28#include <pablo/pe_sel.h>
     29#include <pablo/pe_var.h>
     30#include <pablo/pe_xor.h>
     31#include <pablo/ps_pablos.h>
     32#include <pablo/ps_assign.h>
     33#include <pablo/ps_if.h>
     34#include <pablo/ps_while.h>
    3135
    32 //Pablo Statements
    33 #include "ps_pablos.h"
    34 #include "ps_assign.h"
    35 #include "ps_if.h"
    36 #include "ps_while.h"
     36using namespace re;
     37using namespace pablo;
    3738
    38 
    39 std::string StatementPrinter::PrintStmts(CodeGenState cg_state)
     39std::string StatementPrinter::PrintStmts(const CodeGenState & cg_state)
    4040{
    4141    std::string strOut = "[";
     
    5555}
    5656
    57 std::string StatementPrinter::Print_PB_PabloStmts(std::list<PabloS*> stmts, std::string strOut)
    58 {
    59     std::list<PabloS*>::iterator it;
    60     //std::cout << "Total Statements: " + std::to_string(stmts.size()) << std::endl;
    61     for (it = stmts.begin(); it != stmts.end(); ++it)
    62     {
    63         strOut += ShowPabloS(*it);
     57std::string StatementPrinter::Print_PB_PabloStmts(const List &stmts, std::string strOut) {
     58    for (const auto stmt : stmts) {
     59        strOut += ShowPabloS(stmt);
    6460    }
    65 
    6661    return strOut;
    6762}
    6863
    69 std::string StatementPrinter::Print_CC_PabloStmts(std::list<PabloS*> stmts)
    70 {
     64std::string StatementPrinter::Print_CC_PabloStmts(const List & stmts) {
    7165    std::string strOut = "Total Statements: " + std::to_string(stmts.size()) + "\n";
    7266    for (const auto stmt : stmts) {
     
    7670}
    7771
    78 std::string StatementPrinter::ShowPabloS(PabloS* stmt)
     72std::string StatementPrinter::ShowPabloS(const PabloE * stmt)
    7973{
    8074    std::string retVal = "";
    8175
    82     if (Assign* an = dynamic_cast<Assign*>(stmt))
     76    if (const Assign * an = dynamic_cast<const Assign*>(stmt))
    8377    {
    8478        retVal = "Assign('" + an->getM() + "', " + ShowPabloE(an->getExpr()) + "),";
    8579    }
    86     else if (If* ifstmt = dynamic_cast<If*>(stmt))
     80    else if (const If * ifstmt = dynamic_cast<const If *>(stmt))
    8781    {
    8882        retVal = "If(" + ShowPabloE(ifstmt->getExpr()) + ", " + Print_PB_PabloStmts(ifstmt->getPSList(), retVal) + ")";
    8983    }
    90     else if (While* whl = dynamic_cast<While*>(stmt))
     84    else if (const While * whl = dynamic_cast<const While *>(stmt))
    9185    {
    9286        retVal = "While(" + ShowPabloE(whl->getExpr()) + ", " + Print_PB_PabloStmts(whl->getPSList(), retVal) + ")";
     
    9690}
    9791
    98 std::string StatementPrinter::ShowPabloE(PabloE* expr)
     92std::string StatementPrinter::ShowPabloE(const PabloE *expr)
    9993{
    10094    std::string retVal = "";
    10195
    102     if (All* all = dynamic_cast<All*>(expr))
     96    if (const All * all = dynamic_cast<const All*>(expr))
    10397    {
    104         retVal = "All " + std::to_string(all->getNum()) + " ";
     98        retVal = "All " + std::to_string(all->getValue()) + " ";
    10599    }
    106     else if (Call* pablo_call = dynamic_cast<Call*>(expr))
     100    else if (const Call * pablo_call = dynamic_cast<const Call*>(expr))
    107101    {
    108102        retVal = "Call '" + pablo_call->getCallee() + "'";
    109103    }
    110     else if (Var* pablo_var = dynamic_cast<Var*>(expr))
     104    else if (const Var * pablo_var = dynamic_cast<const Var*>(expr))
    111105    {
    112106        retVal = "Var '" + pablo_var->getVar() + "' ";
    113107    }
    114     else if (And* pablo_and = dynamic_cast<And*>(expr))
     108    else if (const And * pablo_and = dynamic_cast<const And*>(expr))
    115109    {
    116110        retVal = "And(" + ShowPabloE(pablo_and->getExpr1()) +", " + ShowPabloE(pablo_and->getExpr2()) + ")";
    117111    }
    118     else if (Or* pablo_or = dynamic_cast<Or*>(expr))
     112    else if (const Or * pablo_or = dynamic_cast<const Or*>(expr))
    119113    {
    120114        retVal = "Or(" + ShowPabloE(pablo_or->getExpr1()) + ", " + ShowPabloE(pablo_or->getExpr2()) + ")";
    121115    }
    122     else if (Sel* pablo_sel = dynamic_cast<Sel*>(expr))
     116    else if (const Sel * pablo_sel = dynamic_cast<const Sel*>(expr))
    123117    {
    124118        retVal = "((" + ShowPabloE(pablo_sel->getIf_expr()) + "And " + ShowPabloE(pablo_sel->getT_expr()) +
    125119                ")|(Not(" + ShowPabloE(pablo_sel->getIf_expr()) + ") And " + ShowPabloE(pablo_sel->getF_expr()) + ")";
    126120    }
    127     else if (Not* pablo_not = dynamic_cast<Not*>(expr))
     121    else if (const Not * pablo_not = dynamic_cast<const Not*>(expr))
    128122    {
    129123        retVal = "Not (" + ShowPabloE(pablo_not->getExpr()) + ")";
    130124    }
    131     else if (CharClass* cc = dynamic_cast<CharClass*>(expr))
     125    else if (const CharClass * cc = dynamic_cast<const CharClass*>(expr))
    132126    {
    133127        retVal = "CharClass '" + cc->getCharClass() + "'";
    134128    }
    135     else if (re::Name * name = dynamic_cast<re::Name *>(expr))
     129    else if (const re::Name * name = dynamic_cast<const re::Name *>(expr))
    136130    {
    137131        retVal = "Name '" + name->getName() + "'";
    138132    }
    139     else if (Advance* adv = dynamic_cast<Advance*>(expr))
     133    else if (const Advance * adv = dynamic_cast<const Advance*>(expr))
    140134    {
    141135        retVal = "Advance(" + ShowPabloE(adv->getExpr()) + ")";
    142136    }
    143     else if (MatchStar* mstar = dynamic_cast<MatchStar*>(expr))
     137    else if (const MatchStar * mstar = dynamic_cast<const MatchStar*>(expr))
    144138    {
    145139        retVal = "MatchStar (" + ShowPabloE(mstar->getExpr1()) + ", " + ShowPabloE(mstar->getExpr2()) + ")";
    146140    }
    147     else if (ScanThru* sthru = dynamic_cast<ScanThru*>(expr))
     141    else if (const ScanThru * sthru = dynamic_cast<const ScanThru*>(expr))
    148142    {
    149143        retVal = "ScanThru (" + ShowPabloE(sthru->getScanFrom()) + ", " + ShowPabloE(sthru->getScanThru()) + ")";
  • icGREP/icgrep-devel/icgrep/printer_pablos.h

    r4197 r4199  
    88#define SHOW_H
    99
    10 #include "ps_pablos.h"
     10#include <pablo/ps_pablos.h>
    1111#include <string>
    1212#include <list>
    1313
    14 class StatementPrinter
    15 {
     14class StatementPrinter {
     15    typedef pablo::PabloE       PabloE;
     16    typedef std::list<PabloE *> List;
    1617public:
    17     static std::string PrintStmts(CodeGenState cg_state);
    18     static std::string Print_CC_PabloStmts(std::list<PabloS*> stmts);
    19     static std::string Print_PB_PabloStmts(std::list<PabloS*> stmts, std::string strOut);
    20     static std::string ShowPabloE(PabloE* expr);
    21     static std::string ShowPabloS(PabloS* stmt);
     18    static std::string PrintStmts(const CodeGenState  &cg_state);
     19    static std::string Print_CC_PabloStmts(const List & stmts);
     20    static std::string Print_PB_PabloStmts(const List & stmts, std::string strOut);
     21    static std::string ShowPabloE(const PabloE * expr);
     22    static std::string ShowPabloS(const PabloE *stmt);
    2223};
    2324
  • icGREP/icgrep-devel/icgrep/re/re_compiler.cpp

    r4198 r4199  
    77#include "re_compiler.h"
    88//Regular Expressions
    9 #include "re_name.h"
    10 #include "re_start.h"
    11 #include "re_end.h"
    12 #include "re_seq.h"
    13 #include "re_alt.h"
    14 #include "re_rep.h"
     9#include <re/re_name.h>
     10#include <re/re_start.h>
     11#include <re/re_end.h>
     12#include <re/re_alt.h>
     13#include <re/re_cc.h>
     14#include <re/re_seq.h>
     15#include <re/re_rep.h>
     16
    1517
    1618//Pablo Expressions
    17 #include "pablo/pe_pabloe.h"
    18 #include "pablo/pe_sel.h"
    19 #include "pablo/pe_advance.h"
    20 #include "pablo/pe_all.h"
    21 #include "pablo/pe_and.h"
    22 #include "pablo/pe_charclass.h"
    23 #include "pablo/pe_call.h"
    24 #include "pablo/pe_matchstar.h"
    25 #include "pablo/pe_scanthru.h"
    26 #include "pablo/pe_not.h"
    27 #include "pablo/pe_or.h"
    28 #include "pablo/pe_var.h"
    29 #include "pablo/pe_xor.h"
    30 
    31 //Pablo Statements
    32 #include "pablo/ps_pablos.h"
    33 #include "pablo/ps_assign.h"
    34 #include "pablo/ps_if.h"
    35 #include "pablo/ps_while.h"
     19#include <pablo/pablo_routines.h>
     20#include <pablo/ps_pablos.h>
     21#include <pablo/pe_advance.h>
     22#include <pablo/pe_all.h>
     23#include <pablo/pe_and.h>
     24#include <pablo/pe_call.h>
     25#include <pablo/pe_charclass.h>
     26#include <pablo/pe_matchstar.h>
     27#include <pablo/pe_not.h>
     28#include <pablo/pe_or.h>
     29#include <pablo/pe_pabloe.h>
     30#include <pablo/pe_scanthru.h>
     31#include <pablo/pe_sel.h>
     32#include <pablo/pe_var.h>
     33#include <pablo/pe_xor.h>
     34#include <pablo/ps_pablos.h>
     35#include <pablo/ps_assign.h>
     36#include <pablo/ps_if.h>
     37#include <pablo/ps_while.h>
    3638
    3739#include <assert.h>
    3840#include <stdexcept>
     41
     42using namespace pablo;
    3943
    4044namespace re {
     
    107111        PabloE * u8scope42 = new Advance(u8pfx4);
    108112        PabloE * u8scope43 = new Advance(u8scope42);
    109         PabloS * assign_non_final = new Assign(gs_nonfinal, new Or(new Or(u8pfx, u8scope32), new Or(u8scope42, u8scope43)));
     113        PabloE * assign_non_final = new Assign(gs_nonfinal, new Or(new Or(u8pfx, u8scope32), new Or(u8scope42, u8scope43)));
    110114        #ifdef USE_IF_FOR_NONFINAL
    111         std::list<PabloS *> * if_body = new std::list<PabloS *> ();
     115        std::list<PabloE *> * if_body = new std::list<PabloE *> ();
    112116        if_body->push_back(assign_non_final);
    113117        cg_state.stmtsl.push_back(new If(u8pfx, *if_body));
  • icGREP/icgrep-devel/icgrep/re/re_re.h

    r4194 r4199  
    4545        , Union
    4646    };
    47     ClassTypeId getClassTypeId() const {
     47    inline ClassTypeId getClassTypeId() const {
    4848        return mClassTypeId;
    4949    }
Note: See TracChangeset for help on using the changeset viewer.