Changeset 3982


Ignore:
Timestamp:
Aug 9, 2014, 11:43:09 AM (5 years ago)
Author:
daled
Message:

icGREP now support Unicode categories.

Location:
icGREP/icgrep-devel/icgrep
Files:
1 added
3 edited

Legend:

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

    r3975 r3982  
    5151 
    5252# add the executable
    53 add_executable(icgrep icgrep.cpp llvm_gen.cpp categories_Nd.h llvm_gen_helper.cpp utf_encoding.cpp cc_codegenobject.cpp  cc_compiler.cpp  cc_compiler_helper.cpp re_simplifier.cpp re_reducer.cpp re_nullable.cpp re_compiler.cpp pbix_compiler.cpp  symbol_generator.cpp utf8_encoder.cpp)
     53add_executable(icgrep icgrep.cpp llvm_gen.cpp llvm_gen_helper.cpp utf_encoding.cpp cc_codegenobject.cpp  cc_compiler.cpp  cc_compiler_helper.cpp re_simplifier.cpp re_reducer.cpp re_nullable.cpp re_compiler.cpp pbix_compiler.cpp  symbol_generator.cpp utf8_encoder.cpp unicode_categories.h)
    5454
    5555target_link_libraries (icgrep PabloADT RegExpADT ${REQ_LLVM_LIBRARIES})
  • icGREP/icgrep-devel/icgrep/llvm_gen.cpp

    r3969 r3982  
    88#include "printer_pablos.h"
    99
    10 Nd nd;
     10Ps* ps = NULL; Nl* nl = NULL; No* no = NULL; Lo* lo = NULL; Ll* ll = NULL; Lm* lm = NULL; Nd* nd = NULL;
     11Pc* pc = NULL; Lt* lt = NULL; Lu* lu = NULL; Pf* pf = NULL; Pd* pd = NULL; Pe* pe = NULL; Pi* pi = NULL;
     12Po* po = NULL; Me* me = NULL; Mc* mc = NULL; Mn* mn = NULL; Sk* sk = NULL; So* so = NULL; Sm* sm = NULL;
     13Sc* sc = NULL; Zl* zl = NULL; Co* co = NULL; Cn* cn = NULL; Cc* cc = NULL; Cf* cf = NULL; Cs* cs = NULL;
     14Zp* zp = NULL; Zs* zs = NULL;
    1115
    1216extern "C" {
     
    1721
    1822extern "C" {
    19     BitBlock wrapped_get_category_Nd(Basis_bits &basis_bits, const char* name){
    20 
     23    BitBlock wrapped_get_category_Ps(Basis_bits &basis_bits){
     24        if (ps == NULL) ps = new Ps();
     25        Struct_Ps ps_output;
     26        ps->do_block(basis_bits, ps_output);
     27
     28        return ps_output.cc;
     29    }
     30}
     31
     32extern "C" {
     33    BitBlock wrapped_get_category_Nl(Basis_bits &basis_bits){
     34        if (nl == NULL) nl = new Nl();
     35        Struct_Nl nl_output;
     36        nl->do_block(basis_bits, nl_output);
     37
     38        return nl_output.cc;
     39    }
     40}
     41
     42extern "C" {
     43    BitBlock wrapped_get_category_No(Basis_bits &basis_bits){
     44        if (no == NULL) no = new No();
     45        Struct_No no_output;
     46        no->do_block(basis_bits, no_output);
     47
     48        return no_output.cc;
     49    }
     50}
     51
     52extern "C" {
     53    BitBlock wrapped_get_category_Lo(Basis_bits &basis_bits){
     54        if (lo == NULL) lo = new Lo();
     55        Struct_Lo lo_output;
     56        lo->do_block(basis_bits, lo_output);
     57
     58        return lo_output.cc;
     59    }
     60}
     61
     62extern "C" {
     63    BitBlock wrapped_get_category_Ll(Basis_bits &basis_bits){
     64        if (ll == NULL) ll = new Ll();
     65        Struct_Ll ll_output;
     66        ll->do_block(basis_bits, ll_output);
     67
     68        return ll_output.cc;
     69    }
     70}
     71
     72extern "C" {
     73    BitBlock wrapped_get_category_Lm(Basis_bits &basis_bits){
     74        if (lm == NULL) lm = new Lm();
     75        Struct_Lm lm_output;
     76        lm->do_block(basis_bits, lm_output);
     77
     78        return lm_output.cc;
     79    }
     80}
     81
     82extern "C" {
     83    BitBlock wrapped_get_category_Nd(Basis_bits &basis_bits){
     84        if (nd == NULL) nd = new Nd();
    2185        Struct_Nd nd_output;
    22         nd.do_block(basis_bits, nd_output);
     86        nd->do_block(basis_bits, nd_output);
    2387
    2488        return nd_output.cc;
     89    }
     90}
     91
     92extern "C" {
     93    BitBlock wrapped_get_category_Pc(Basis_bits &basis_bits){
     94        if (pc == NULL) pc = new Pc();
     95        Struct_Pc pc_output;
     96        pc->do_block(basis_bits, pc_output);
     97
     98        return pc_output.cc;
     99    }
     100}
     101
     102extern "C" {
     103    BitBlock wrapped_get_category_Lt(Basis_bits &basis_bits){
     104        if (lt == NULL) lt = new Lt();
     105        Struct_Lt lt_output;
     106        lt->do_block(basis_bits, lt_output);
     107
     108        return lt_output.cc;
     109    }
     110}
     111
     112extern "C" {
     113    BitBlock wrapped_get_category_Lu(Basis_bits &basis_bits){
     114        if (lu == NULL) lu = new Lu();
     115        Struct_Lu lu_output;
     116        lu->do_block(basis_bits, lu_output);
     117
     118        return lu_output.cc;
     119    }
     120}
     121
     122extern "C" {
     123    BitBlock wrapped_get_category_Pf(Basis_bits &basis_bits){
     124        if (pf == NULL) pf = new Pf();
     125        Struct_Pf pf_output;
     126        pf->do_block(basis_bits, pf_output);
     127
     128        return pf_output.cc;
     129    }
     130}
     131
     132extern "C" {
     133    BitBlock wrapped_get_category_Pd(Basis_bits &basis_bits){
     134        if (pd == NULL) pd = new Pd();
     135        Struct_Pd pd_output;
     136        pd->do_block(basis_bits, pd_output);
     137
     138        return pd_output.cc;
     139    }
     140}
     141
     142extern "C" {
     143    BitBlock wrapped_get_category_Pe(Basis_bits &basis_bits){
     144        if (pe == NULL) pe = new Pe();
     145        Struct_Pe pe_output;
     146        pe->do_block(basis_bits, pe_output);
     147
     148        return pe_output.cc;
     149    }
     150}
     151
     152extern "C" {
     153    BitBlock wrapped_get_category_Pi(Basis_bits &basis_bits){
     154        if (pi == NULL) pi = new Pi();
     155        Struct_Pi pi_output;
     156        pi->do_block(basis_bits, pi_output);
     157
     158        return pi_output.cc;
     159    }
     160}
     161
     162extern "C" {
     163    BitBlock wrapped_get_category_Po(Basis_bits &basis_bits){
     164        if (po == NULL) po = new Po();
     165        Struct_Po po_output;
     166        po->do_block(basis_bits, po_output);
     167
     168        return po_output.cc;
     169    }
     170}
     171
     172extern "C" {
     173    BitBlock wrapped_get_category_Me(Basis_bits &basis_bits){
     174        if (me == NULL) me = new Me();
     175        Struct_Me me_output;
     176        me->do_block(basis_bits, me_output);
     177
     178        return me_output.cc;
     179    }
     180}
     181
     182extern "C" {
     183    BitBlock wrapped_get_category_Mc(Basis_bits &basis_bits){
     184        if (mc == NULL) mc = new Mc();
     185        Struct_Mc mc_output;
     186        mc->do_block(basis_bits, mc_output);
     187
     188        return mc_output.cc;
     189    }
     190}
     191
     192extern "C" {
     193    BitBlock wrapped_get_category_Mn(Basis_bits &basis_bits){
     194        if (mn == NULL) mn = new Mn();
     195        Struct_Mn mn_output;
     196        mn->do_block(basis_bits, mn_output);
     197
     198        return mn_output.cc;
     199    }
     200}
     201
     202extern "C" {
     203    BitBlock wrapped_get_category_Sk(Basis_bits &basis_bits){
     204        if (sk == NULL) sk = new Sk();
     205        Struct_Sk sk_output;
     206        sk->do_block(basis_bits, sk_output);
     207
     208        return sk_output.cc;
     209    }
     210}
     211
     212extern "C" {
     213    BitBlock wrapped_get_category_So(Basis_bits &basis_bits){
     214        if (so == NULL) so = new So();
     215        Struct_So so_output;
     216        so->do_block(basis_bits, so_output);
     217
     218        return so_output.cc;
     219    }
     220}
     221
     222extern "C" {
     223    BitBlock wrapped_get_category_Sm(Basis_bits &basis_bits){
     224        if (sm == NULL) sm = new Sm();
     225        Struct_Sm sm_output;
     226        sm->do_block(basis_bits, sm_output);
     227
     228        return sm_output.cc;
     229    }
     230}
     231
     232extern "C" {
     233    BitBlock wrapped_get_category_Sc(Basis_bits &basis_bits){
     234        if (sc == NULL) sc = new Sc();
     235        Struct_Sc sc_output;
     236        sc->do_block(basis_bits, sc_output);
     237
     238        return sc_output.cc;
     239    }
     240}
     241
     242extern "C" {
     243    BitBlock wrapped_get_category_Zl(Basis_bits &basis_bits){
     244        if (zl == NULL) zl = new Zl();
     245        Struct_Zl zl_output;
     246        zl->do_block(basis_bits, zl_output);
     247
     248        return zl_output.cc;
     249    }
     250}
     251
     252extern "C" {
     253    BitBlock wrapped_get_category_Co(Basis_bits &basis_bits){
     254        if (co == NULL) co = new Co();
     255        Struct_Co co_output;
     256        co->do_block(basis_bits, co_output);
     257
     258        return co_output.cc;
     259    }
     260}
     261
     262extern "C" {
     263    BitBlock wrapped_get_category_Cn(Basis_bits &basis_bits){
     264        if (cn == NULL) cn = new Cn();
     265        Struct_Cn cn_output;
     266        cn->do_block(basis_bits, cn_output);
     267
     268        return cn_output.cc;
     269    }
     270}
     271
     272extern "C" {
     273    BitBlock wrapped_get_category_Cc(Basis_bits &basis_bits){
     274        if (cc == NULL) cc = new Cc();
     275        Struct_Cc cc_output;
     276        cc->do_block(basis_bits, cc_output);
     277
     278        return cc_output.cc;
     279    }
     280}
     281
     282extern "C" {
     283    BitBlock wrapped_get_category_Cf(Basis_bits &basis_bits){
     284        if (cf == NULL) cf = new Cf();
     285        Struct_Cf cf_output;
     286        cf->do_block(basis_bits, cf_output);
     287
     288        return cf_output.cc;
     289    }
     290}
     291
     292extern "C" {
     293    BitBlock wrapped_get_category_Cs(Basis_bits &basis_bits){
     294        if (cs == NULL) cs = new Cs();
     295        Struct_Cs cs_output;
     296        cs->do_block(basis_bits, cs_output);
     297
     298        return cs_output.cc;
     299    }
     300}
     301
     302extern "C" {
     303    BitBlock wrapped_get_category_Zp(Basis_bits &basis_bits){
     304        if (zp == NULL) zp = new Zp();
     305        Struct_Zp zp_output;
     306        zp->do_block(basis_bits, zp_output);
     307
     308        return zp_output.cc;
     309    }
     310}
     311
     312extern "C" {
     313    BitBlock wrapped_get_category_Zs(Basis_bits &basis_bits){
     314        if (zs == NULL) zs = new Zs();
     315        Struct_Zs zs_output;
     316        zs->do_block(basis_bits, zs_output);
     317
     318        return zs_output.cc;
    25319    }
    26320}
     
    36330{
    37331    delete mMod;
     332
     333    if (ps != NULL) delete ps;
     334    if (nl != NULL) delete nl;
     335    if (no != NULL) delete no;
     336    if (lo != NULL) delete lo;
     337    if (ll != NULL) delete ll;
     338    if (lm != NULL) delete lm;
     339    if (nd != NULL) delete nd;
     340    if (pc != NULL) delete pc;
     341    if (lt != NULL) delete lt;
     342    if (lu != NULL) delete lu;
     343    if (pf != NULL) delete pf;
     344    if (pd != NULL) delete pd;
     345    if (pe != NULL) delete pe;
     346    if (pi != NULL) delete pi;
     347    if (po != NULL) delete po;
     348    if (me != NULL) delete me;
     349    if (mc != NULL) delete mc;
     350    if (mn != NULL) delete mn;
     351    if (sk != NULL) delete sk;
     352    if (so != NULL) delete so;
     353    if (sm != NULL) delete sm;
     354    if (sc != NULL) delete sc;
     355    if (zl != NULL) delete zl;
     356    if (co != NULL) delete co;
     357    if (cn != NULL) delete cn;
     358    if (cc != NULL) delete cc;
     359    if (cf != NULL) delete cf;
     360    if (cs != NULL) delete cs;
     361    if (zp != NULL) delete zp;
     362    if (zs != NULL) delete zs;
     363
    38364}
    39365
     
    59385    DefineTypes();
    60386    DeclareFunctions();
     387    DeclareCallFunctions(cg_state.stmtsl);
    61388
    62389    Function::arg_iterator args = mFunc_process_block->arg_begin();
     
    198525void LLVM_Generator::DeclareFunctions()
    199526{
    200     mFunc_get_unicode_category_Nd = mMod->getOrInsertFunction("wrapped_get_category_Nd", m64x2Vect, mStruct_Basis_Bits_Ptr1, Type::getInt8PtrTy(mMod->getContext()), NULL);
    201     mExecutionEngine->addGlobalMapping(cast<GlobalValue>(mFunc_get_unicode_category_Nd), (void *)&wrapped_get_category_Nd);
    202 
    203527    //mFunc_get_unicode_category = mMod->getOrInsertFunction("wrapped_get_unicode_category", m64x2Vect, mStruct_Basis_Bits_Ptr1, Type::getInt8PtrTy(mMod->getContext()), NULL);
    204528    //mExecutionEngine->addGlobalMapping(cast<GlobalValue>(mFunc_get_unicode_category), (void *)&wrapped_get_unicode_category);
     
    249573    }
    250574    mFunc_process_block->setAttributes(AttrSet);
     575}
     576
     577void LLVM_Generator::DeclareCallFunctions(std::list<PabloS*> stmts)
     578{
     579    std::list<PabloS*>::iterator it;
     580    for (it = stmts.begin(); it != stmts.end(); ++it)
     581    {
     582        DeclareCallFunctions_PabloS(*it);
     583    }
     584}
     585
     586void LLVM_Generator::DeclareCallFunctions_PabloS(PabloS* stmt)
     587{
     588    if (Assign* an = dynamic_cast<Assign*>(stmt))
     589    {
     590        DeclareCallFunctions_PabloE(an->getExpr());
     591    }
     592    if (While* whl = dynamic_cast<While*>(stmt))
     593    {
     594        DeclareCallFunctions_PabloE(whl->getExpr());
     595        DeclareCallFunctions(whl->getPSList());
     596    }
     597}
     598
     599void LLVM_Generator::DeclareCallFunctions_PabloE(PabloE* expr)
     600{
     601    if (Call* pablo_call = dynamic_cast<Call*>(expr))
     602    {
     603        std::string callee = "wrapped_get_category_" + pablo_call->getCallee();
     604        if (mMarkerMap.find(callee) == mMarkerMap.end())
     605        {
     606            Value* func_get_unicode_category = mMod->getOrInsertFunction(callee, m64x2Vect, mStruct_Basis_Bits_Ptr1, NULL);
     607            void* addr;
     608            if (pablo_call->getCallee() == "Ps")
     609            {
     610                addr = (void *)&wrapped_get_category_Ps;
     611            }
     612            else if (pablo_call->getCallee() == "Nl")
     613            {
     614                addr = (void *)&wrapped_get_category_Nl;
     615            }
     616            else if (pablo_call->getCallee() == "No")
     617            {
     618                addr = (void *)&wrapped_get_category_No;
     619            }
     620            else if (pablo_call->getCallee() == "Lo")
     621            {
     622                addr = (void *)&wrapped_get_category_Lo;
     623            }
     624            else if (pablo_call->getCallee() == "Ll")
     625            {
     626                addr = (void *)&wrapped_get_category_Ll;
     627            }
     628            else if (pablo_call->getCallee() == "Lm")
     629            {
     630                addr = (void *)&wrapped_get_category_Lm;
     631            }
     632            else if (pablo_call->getCallee() == "Nd")
     633            {
     634                addr = (void *)&wrapped_get_category_Nd;
     635            }
     636            else if (pablo_call->getCallee() == "Pc")
     637            {
     638                addr = (void *)&wrapped_get_category_Pc;
     639            }
     640            else if (pablo_call->getCallee() == "Lt")
     641            {
     642                addr = (void *)&wrapped_get_category_Lt;
     643            }
     644            else if (pablo_call->getCallee() == "Lu")
     645            {
     646                addr = (void *)&wrapped_get_category_Lu;
     647            }
     648            else if (pablo_call->getCallee() == "Pf")
     649            {
     650                addr = (void *)&wrapped_get_category_Pf;
     651            }
     652            else if (pablo_call->getCallee() == "Pd")
     653            {
     654                addr = (void *)&wrapped_get_category_Pd;
     655            }
     656            else if (pablo_call->getCallee() == "Pe")
     657            {
     658                addr = (void *)&wrapped_get_category_Pe;
     659            }
     660            else if (pablo_call->getCallee() == "Pi")
     661            {
     662                addr = (void *)&wrapped_get_category_Pi;
     663            }
     664            else if (pablo_call->getCallee() == "Po")
     665            {
     666                addr = (void *)&wrapped_get_category_Po;
     667            }
     668            else if (pablo_call->getCallee() == "Me")
     669            {
     670                addr = (void *)&wrapped_get_category_Me;
     671            }
     672            else if (pablo_call->getCallee() == "Mc")
     673            {
     674                addr = (void *)&wrapped_get_category_Mc;
     675            }
     676            else if (pablo_call->getCallee() == "Mn")
     677            {
     678                addr = (void *)&wrapped_get_category_Mn;
     679            }
     680            else if (pablo_call->getCallee() == "Sk")
     681            {
     682                addr = (void *)&wrapped_get_category_Sk;
     683            }
     684            else if (pablo_call->getCallee() == "So")
     685            {
     686                addr = (void *)&wrapped_get_category_So;
     687            }
     688            else if (pablo_call->getCallee() == "Sm")
     689            {
     690                addr = (void *)&wrapped_get_category_Sm;
     691            }
     692            else if (pablo_call->getCallee() == "Sc")
     693            {
     694                addr = (void *)&wrapped_get_category_Sc;
     695            }
     696            else if (pablo_call->getCallee() == "Zl")
     697            {
     698                addr = (void *)&wrapped_get_category_Zl;
     699            }
     700            else if (pablo_call->getCallee() == "Co")
     701            {
     702                addr = (void *)&wrapped_get_category_Co;
     703            }
     704            else if (pablo_call->getCallee() == "Cn")
     705            {
     706                addr = (void *)&wrapped_get_category_Cn;
     707            }
     708            else if (pablo_call->getCallee() == "Cc")
     709            {
     710                addr = (void *)&wrapped_get_category_Cc;
     711            }
     712            else if (pablo_call->getCallee() == "Cf")
     713            {
     714                addr = (void *)&wrapped_get_category_Cf;
     715            }
     716            else if (pablo_call->getCallee() == "Cs")
     717            {
     718                addr = (void *)&wrapped_get_category_Cs;
     719            }
     720            else if (pablo_call->getCallee() == "Zp")
     721            {
     722                addr = (void *)&wrapped_get_category_Zp;
     723            }
     724            else if (pablo_call->getCallee() == "Zs")
     725            {
     726                addr = (void *)&wrapped_get_category_Zs;
     727            }
     728
     729            mExecutionEngine->addGlobalMapping(cast<GlobalValue>(func_get_unicode_category), addr);
     730            mMarkerMap.insert(make_pair(callee, func_get_unicode_category));
     731        }
     732    }
     733    else if (And* pablo_and = dynamic_cast<And*>(expr))
     734    {
     735        DeclareCallFunctions_PabloE(pablo_and->getExpr1());
     736        DeclareCallFunctions_PabloE(pablo_and->getExpr2());
     737    }
     738    else if (Or* pablo_or = dynamic_cast<Or*>(expr))
     739    {
     740        DeclareCallFunctions_PabloE(pablo_or->getExpr1());
     741        DeclareCallFunctions_PabloE(pablo_or->getExpr2());
     742    }
     743    else if (Sel* pablo_sel = dynamic_cast<Sel*>(expr))
     744    {
     745        DeclareCallFunctions_PabloE(pablo_sel->getIf_expr());
     746        DeclareCallFunctions_PabloE(pablo_sel->getT_expr());
     747        DeclareCallFunctions_PabloE(pablo_sel->getF_expr());
     748    }
     749    else if (Not* pablo_not = dynamic_cast<Not*>(expr))
     750    {
     751        DeclareCallFunctions_PabloE(pablo_not->getExpr());
     752    }
     753    else if (Advance* adv = dynamic_cast<Advance*>(expr))
     754    {
     755        DeclareCallFunctions_PabloE(adv->getExpr());
     756    }
     757    else if (MatchStar* mstar = dynamic_cast<MatchStar*>(expr))
     758    {
     759        DeclareCallFunctions_PabloE(mstar->getExpr1());
     760        DeclareCallFunctions_PabloE(mstar->getExpr2());
     761    }
     762    else if (ScanThru* sthru = dynamic_cast<ScanThru*>(expr))
     763    {
     764        DeclareCallFunctions_PabloE(sthru->getScanFrom());
     765        DeclareCallFunctions_PabloE(sthru->getScanThru());
     766    }
    251767}
    252768
     
    412928        if (mMarkerMap.find(call->getCallee()) == mMarkerMap.end())
    413929        {
     930            std::map<std::string, Value*>::iterator itFuncGet = mMarkerMap.find("wrapped_get_category_" + call->getCallee());
    414931            Value* basis_bits_struct = b.CreateLoad(mPtr_basis_bits_addr);
    415             Value* unicode_category = b.CreateCall2(mFunc_get_unicode_category_Nd, basis_bits_struct, b.CreateGlobalStringPtr(call->getCallee()));
    416             //b.CreateCall(mFunc_print_register, unicode_category);
     932            Value* unicode_category = b.CreateCall(itFuncGet->second, basis_bits_struct);
    417933            Value* ptr = b.CreateAlloca(m64x2Vect);
    418934            Value* void_1 = b.CreateStore(unicode_category, ptr);
  • icGREP/icgrep-devel/icgrep/llvm_gen.h

    r3969 r3982  
    4444#include "llvm_gen_helper.h"
    4545
    46 //TODO: Remove
    47 //#include "unicode_categories.h"
    48 
    49 #include "categories_Nd.h"
    50 
     46#include "unicode_categories.h"
    5147
    5248#include <iostream>
     
    115111    void DefineTypes();
    116112    void DeclareFunctions();
     113    void DeclareCallFunctions(std::list<PabloS*> stmts);
     114    void DeclareCallFunctions_PabloS(PabloS* stmt);
     115    void DeclareCallFunctions_PabloE(PabloE* expr);
    117116    void StoreBitBlockMarkerPtr(std::string name, int index);
    118117    void LoadBitBlocksFromStaticExtern();
     
    157156    Constant*     mFunc_test_getCategory;
    158157    Constant*     mFunc_get_unicode_category;
    159     Constant*     mFunc_get_unicode_category_Nd;
     158    Value*     mFunc_get_unicode_category_Nd;
    160159
    161160    AllocaInst*  mPtr_basis_bits_addr;
Note: See TracChangeset for help on using the changeset viewer.