Ignore:
Timestamp:
Sep 23, 2014, 3:15:47 PM (5 years ago)
Author:
nmedfort
Message:

Some refactoring of the RE CC class and CC Compiler; Moved RE into re subdirectory.

File:
1 edited

Legend:

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

    r4182 r4187  
    99#include "utf_encoding.h"
    1010#include "cc_compiler_helper.h"
     11#include "pe_sel.h"
     12#include "pe_advance.h"
     13#include "pe_all.h"
     14#include "pe_and.h"
     15#include "pe_charclass.h"
     16#include "pe_matchstar.h"
     17#include "pe_not.h"
     18#include "pe_or.h"
     19#include "pe_var.h"
     20#include "pe_xor.h"
    1121
    1222#include <math.h>
    1323#include <utility>
    1424#include <iostream>
    15 #include <sstream>
    1625#include <string>
    1726#include <list>
     
    2130#include <cassert>
    2231#include <stdlib.h>
     32#include <stdexcept>
    2333
    2434CC_Compiler::CC_Compiler(const UTF_Encoding encoding, const std::string basis_pattern, const std::string gensym_pattern)
     
    3242    for (int i = 0; i < mEncoding.getBits(); i++)
    3343    {
    34         std::string b_pattern = bit_var((mEncoding.getBits() -1) - i);
     44        std::string b_pattern = bit_var((mEncoding.getBits() - 1) - i);
    3545        Expression* expr = new Expression();
    3646        expr->expr_string  =  b_pattern;
     
    5767    mapped_value->pablo_expr = new Var(varname);
    5868
    59     std::pair<std::map<std::string, Expression*>::iterator, bool> ret = mCommon_Expression_Map.insert(make_pair(key_value, mapped_value));
     69    std::pair<MapIterator, bool> ret = mCommon_Expression_Map.insert(make_pair(key_value, mapped_value));
    6070
    6171    return ret.first->second;
    6272}
    6373
    64 Expression* CC_Compiler::expr_to_variable(Expression* expr)
    65 {
    66     if (mCommon_Expression_Map.count(expr->expr_string) > 0)
    67     {
    68         std::map<std::string, Expression*>::iterator itGet = mCommon_Expression_Map.find(expr->expr_string);
    69         return itGet->second;
    70     }
    71     else
    72     {
    73         mGenSymCounter++;
    74         std::string sym = mGenSym_Template + std::to_string(mGenSymCounter);
    75         return add_assignment(sym, expr);
     74Expression* CC_Compiler::expr_to_variable(Expression * expr) {
     75    MapIterator itr = mCommon_Expression_Map.find(expr->expr_string);
     76    if (itr != mCommon_Expression_Map.end()) {
     77        return itr->second;
     78    }
     79    else {
     80        return add_assignment(mGenSym_Template + std::to_string(++mGenSymCounter), expr);
    7681    }
    7782}
     
    9095}
    9196
    92 void CC_Compiler::compile_from_map(const std::map<std::string, RE*>& re_map)
     97void CC_Compiler::compile_from_map(const REMap &re_map)
    9398{
    9499    process_re_map(re_map);
    95100}
    96101
    97 void CC_Compiler::process_re_map(const std::map<std::string, RE*>& re_map)
    98 {
    99     for (auto it =  re_map.rbegin(); it != re_map.rend(); ++it)
    100     {
     102void CC_Compiler::process_re_map(const REMap & re_map) {
     103    for (auto it =  re_map.crbegin(); it != re_map.crend(); ++it) {
    101104        process_re(it->second);
    102105    }
    103106}
    104107
    105 void CC_Compiler::process_re(RE* re)
    106 {
    107 
    108     if (Alt* re_alt = dynamic_cast<Alt*>(re)) {
    109         for (RE * re : *re_alt) {
     108void CC_Compiler::process_re(const RE* re) {
     109    if (const Alt* re_alt = dynamic_cast<const Alt*>(re)) {
     110        for (const RE * re : *re_alt) {
    110111            process_re(re);
    111112        }
    112113    }
    113     else if (CC* re_cc = dynamic_cast<CC*>(re)) {
     114    else if (const CC* re_cc = dynamic_cast<const CC*>(re)) {
    114115        cc2pablos(re_cc);
    115116    }
    116     else if (Rep* re_rep = dynamic_cast<Rep*>(re)) {
     117    else if (const Rep* re_rep = dynamic_cast<const Rep*>(re)) {
    117118        process_re(re_rep->getRE());
    118119    }
    119     else if (Seq* re_seq = dynamic_cast<Seq*>(re)) {
    120         for (RE * re : *re_seq) {
     120    else if (const Seq* re_seq = dynamic_cast<const Seq*>(re)) {
     121        for (const RE * re : *re_seq) {
    121122            process_re(re);
    122123        }
     
    152153        bit_no++;
    153154    }
    154 /*
    155     std::cout << "FIRST LOOP:" << std::endl;
    156     for (int i = bit_terms.size() - 1; i >= 0; i--)
    157     {
    158         std::cout << StatementPrinter::ShowPabloE(bit_terms.at(i)) << std::endl;
    159     }
    160 */
     155
    161156    //Reduce the list so that all of the expressions are contained within a single expression.
    162157    while (bit_terms.size() > 1)
     
    171166            new_terms.push_back(bit_terms[bit_terms.size() -1]);
    172167        }
    173 /*
    174         std::cout << "\nNEW TERMS ITERATION:\n" << std::endl;
    175         for (int i = new_terms.size() - 1; i >=0; i--)
    176         {
    177             std::cout <<  StatementPrinter::ShowPabloE(new_terms[i]) << std::endl;
    178         }
    179         std::cout << "\n" << std::endl;
    180 */
    181168        std::vector<PabloE*>::iterator it;
    182169        bit_terms.assign(new_terms.begin(), new_terms.end());
    183170    }
    184 /*
    185     std::cout << "bit_terms.size(): " << bit_terms.size() << std::endl;
    186     std::cout << StatementPrinter::ShowPabloE(bit_terms[0]) << std::endl;
    187 */
    188171    return bit_terms[0];
    189172}
    190173
    191 PabloE* CC_Compiler::char_test_expr(int ch)
     174PabloE* CC_Compiler::char_test_expr(const CodePointType ch)
    192175{
    193176    return bit_pattern_expr(ch, mEncoding.getMask());
    194177}
    195178
    196 PabloE* CC_Compiler::make_range(int n1, int n2)
    197 {
    198     unsigned char diff_bits = n1 ^ n2;
    199     int diff_count = 0;
     179PabloE* CC_Compiler::make_range(const CodePointType n1, const CodePointType n2)
     180{
     181    CodePointType diff_bits = n1 ^ n2;
     182    CodePointType diff_count = 0;
    200183
    201184    while (diff_bits > 0)
     
    207190    if ((n2 < n1) || (diff_count > mEncoding.getBits()))
    208191    {
    209         int n1i = n1;
    210         int n2i = n2;
    211 
    212         std::cout << "n1: " << n1i << std::endl;
    213         std::cout << "n2: " << n2i << std::endl;
    214 
    215         std::cout << "Exception: Bad Range!" << std::endl;
    216         return 0;
    217     }
    218 
    219     int mask = pow(2, diff_count) - 1;
    220 
    221     PabloE* common = bit_pattern_expr(n1 & ~mask, mEncoding.getMask() ^ mask);
     192        throw std::runtime_error(std::string("Bad Range: [") + std::to_string(n1) + "," + std::to_string(n2) + "]");
     193    }
     194
     195    const CodePointType mask0 = (static_cast<CodePointType>(1) << diff_count) - 1;
     196
     197    PabloE* common = bit_pattern_expr(n1 & ~mask0, mEncoding.getMask() ^ mask0);
    222198    if (diff_count == 0) return common;
    223199
    224     mask = pow(2, (diff_count - 1)) - 1;
    225 
    226     PabloE* lo_test = GE_Range(diff_count - 1, n1 & mask);
    227     PabloE* hi_test = LE_Range(diff_count - 1, n2 & mask);
     200    const CodePointType mask1 = (static_cast<CodePointType>(1) << (diff_count - 1)) - 1;
     201
     202    PabloE* lo_test = GE_Range(diff_count - 1, n1 & mask1);
     203    PabloE* hi_test = LE_Range(diff_count - 1, n2 & mask1);
    228204
    229205    return CC_Compiler_Helper::make_and(common, CC_Compiler_Helper::make_sel(make_bitv(diff_count - 1), hi_test, lo_test));
     
    279255      Handling this as a special case avoids an overflow issue with n+1 requiring more than N bits.
    280256    */
    281     if ((n+1) == pow(2, N))
    282     {
     257    if ((n + 1) == (1 << N)) {
    283258        return new All(1); //True.
    284259    }
    285     else
    286     {
    287         return CC_Compiler_Helper::make_not(GE_Range(N, n+1));
    288     }
    289 }
    290 
    291 PabloE* CC_Compiler::char_or_range_expr(CharSetItem charset_item)
    292 {
    293     if (charset_item.lo_codepoint == charset_item.hi_codepoint)
    294     {
    295         return char_test_expr(charset_item.lo_codepoint);
    296     }
    297     else
    298     {
    299         if (charset_item.lo_codepoint < charset_item.hi_codepoint)
    300         {
    301             return make_range(charset_item.lo_codepoint, charset_item.hi_codepoint);
    302         }
    303     }
    304 
    305     std::cout << "Exception: Bad Character Set Item!" << std::endl;
    306     return 0;
    307 }
    308 
    309 PabloE* CC_Compiler::charset_expr(CC* cc)
    310 {
    311     if (cc->getItems().size() == 0)
    312     {
     260    else {
     261        return CC_Compiler_Helper::make_not(GE_Range(N, n + 1));
     262    }
     263}
     264
     265PabloE* CC_Compiler::charset_expr(const CC * cc)
     266{
     267    if (cc->empty()) {
    313268        return new All(0);
    314269    }
    315270
    316     if (cc->getItems().size() > 1)
    317     {
     271    if (cc->size() > 1) {
    318272        bool combine = true;
    319 
    320         for (unsigned long i = 0; i < cc->getItems().size(); i++)
    321         {
    322             CharSetItem item = cc->getItems().at(i);
    323             if (item.lo_codepoint != item.hi_codepoint)
    324             {
     273        for (const CharSetItem & item : *cc) {
     274            if (item.lo_codepoint != item.hi_codepoint) {
    325275                combine = false;
    326276                break;
    327277            }
    328278        }
    329 
    330         if (combine)
    331         {
    332             for (unsigned long i = 0; i < cc->getItems().size() - 1; i ++)
    333             {
    334                 CharSetItem curr_item = cc->getItems().at(i);
    335                 CharSetItem next_item = cc->getItems().at(i + 1);
    336                 if (curr_item.lo_codepoint != next_item.lo_codepoint + 2)
    337                 {
     279        if (combine) {
     280            auto i = cc->cbegin();
     281            for (auto j = i; ++j != cc->cend(); i = j) {
     282                const CharSetItem & curr_item = *i;
     283                const CharSetItem & next_item = *j;
     284                if ((curr_item.lo_codepoint + 2) != next_item.lo_codepoint) {
    338285                    combine  = false;
    339286                    break;
    340287                }
    341288            }
    342         }
    343 
    344         if (combine)
    345         {
    346             CharSetItem first_item = cc->getItems().at(0);
    347             CharSetItem last_item = cc->getItems().at(cc->getItems().size() - 1);
    348             CharSetItem combined_item;
    349             combined_item.lo_codepoint = (last_item.lo_codepoint & 0xFE);
    350             combined_item.hi_codepoint = (first_item.hi_codepoint | 0x01);
    351 
    352             return char_or_range_expr(combined_item);
    353         }
    354     }
    355 
    356     PabloE* e1 = char_or_range_expr(cc->getItems().at(0));
    357     if (cc->getItems().size() > 1)
    358     {
    359         for (unsigned long i = 1; i < cc->getItems().size(); i++)
    360         {
    361             e1 = CC_Compiler_Helper::make_or(e1, char_or_range_expr(cc->getItems().at(i)));
    362         }
    363     }
    364 
    365     return e1;
    366 }
     289            if (combine) {
     290                const CodePointType lo = cc->front().lo_codepoint;
     291                const CodePointType hi = cc->back().lo_codepoint;
     292                PabloE * expr = make_range(lo & 0xFE, hi | 0x01);
     293                // should this be here? was in the prototype but not icgrep
     294                expr = CC_Compiler_Helper::make_and(expr, new All((lo & 1) == 1 ? 0 : 1));
     295                return expr;
     296            }
     297        }
     298    }
     299    PabloE * expr = nullptr;
     300    for (const CharSetItem & item : *cc) {
     301        PabloE * temp = char_or_range_expr(item.lo_codepoint, item.hi_codepoint);
     302        expr = (expr == nullptr) ? temp : CC_Compiler_Helper::make_or(expr, temp);
     303    }
     304    return expr;
     305}
     306
     307inline PabloE * CC_Compiler::char_or_range_expr(const CodePointType lo, const CodePointType hi) {
     308    if (lo == hi) {
     309        return char_test_expr(lo);
     310    }
     311    else if (lo < hi) {
     312        return make_range(lo, hi);
     313    }
     314    throw std::runtime_error(std::string("Invalid Character Set Range: [") + std::to_string(lo) + "," + std::to_string(hi) + "]");
     315}
     316
    367317
    368318Expression* CC_Compiler::expr2pabloe(PabloE* expr)
     
    382332            retExpr->pablo_expr = new All(1);
    383333        }
    384         else if (all->getNum() ==0)
     334        else if (all->getNum() == 0)
    385335        {
    386336            retExpr->expr_string = "All(0)";
     
    450400}
    451401
    452 void CC_Compiler::cc2pablos(CC* cc)
     402void CC_Compiler::cc2pablos(const CC * cc)
    453403{
    454404    add_assignment(cc->getName(), expr2pabloe(charset_expr(cc)));
Note: See TracChangeset for help on using the changeset viewer.