Ignore:
Timestamp:
Jan 10, 2018, 11:06:11 PM (15 months ago)
Author:
faldebey
Message:

Update to CoRE testing system

File:
1 edited

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/combine/stringGen.cpp

    r5805 r5825  
    2424#include <codecvt>
    2525#include <stdlib.h>
    26 #include <time.h> 
     26#include <time.h>
    2727#include <UCD/resolve_properties.h>
    2828#include <UCD/unicode_set.h>
    29 #include <UCD/PropertyObjects.h>
    30 
    31 
     29
     30#include <re/printer_re.h>
    3231using namespace std;
    3332using namespace re;
     
    3534
    3635
    37 const std::vector<std::string> split(const std::string &s, char delim) {
    38     std::vector<std::string> elems;
    39     std::stringstream ss;
    40     ss.str(s);
    41     std::string item;
    42     while (std::getline(ss, item, delim)) {
    43         elems.push_back(item);
    44     }
    45     return elems;
    46 }
    47 
    48 vector<string> appendRtoL(std::vector<string> LHS, std::vector<string> RHS){
    49         std::copy(RHS.begin(), RHS.end(), std::back_inserter(LHS));
    50         return LHS;
    51 }
    52 
    53 vector<string> getIntersect(vector<string> v1, vector<string> v2)
    54 {
    55 
    56     vector<string> v3;
    57 
    58     sort(v1.begin(), v1.end());
    59     sort(v2.begin(), v2.end());
    60 
    61     set_intersection(v1.begin(),v1.end(),v2.begin(),v2.end(),back_inserter(v3));
    62 
    63     return v3;
    64 }
    65 
    66 vector<string> getDiff(vector<string> v1, vector<string> v2)
    67 {
    68 
    69     vector<string> v3;
    70 
    71     sort(v1.begin(), v1.end());
    72     sort(v2.begin(), v2.end());
    73 
    74     set_difference(v1.begin(),v1.end(),v2.begin(),v2.end(),back_inserter(v3));
    75 
    76     return v3;
    77 }
    78 
    79 std::vector<string> getAllCodepoints(){
    80         std::vector<string> cpSet;
    81         unsigned int max = 0x10FFFF;
    82         for (unsigned cp = 0; cp < max; ++cp){
    83                 if (cp < 0xD800 || cp > 0xDFFF) {
    84                         std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> converter;
    85                 std::string u8str = converter.to_bytes(cp);
    86                 cpSet.push_back(u8str);
    87                 }
    88         }
    89         return cpSet;
    90 }
    91 
    92 string StringGenerator::stringifyVec(vector<string> elements, string separator){
     36CC * StringGenerator::getRandomCodepointCC(CC * cc){
     37    assert (cc);
     38    if (!cc->subset(*getAllCodepoints())) {
     39        cc = intersectCC(cc, getAllCodepoints());
     40    }
     41    if (cc->empty()) {
     42        return cc;
     43    }
     44    int random = rand() % cc->count();
     45    return makeCC(cc->at(random));
     46
     47}
     48
     49inline CC * StringGenerator::getAllCodepoints() {
     50    assert (allCodepointsCC);
     51    return allCodepointsCC;
     52}
     53
     54string stringifyCC(CC * cc){
     55    if (cc->empty()){
     56        return "";
     57    }
     58    std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> converter;
     59    std::string u8str = converter.to_bytes(lo_codepoint(cc->begin()));
     60    return u8str;
     61}
     62
     63string StringGenerator::stringifyVec(vector<CC *> elements) {
    9364        string line = "";
    94         bool sep = false;
    95         for (auto e : elements){
    96                 line += sep? separator + e : e;
    97                 sep = true;
     65        for (auto e : elements) {
     66        if (!e->empty()){
     67            line += stringifyCC(getRandomCodepointCC(e));
     68        }
    9869        }
    9970        return line;
    10071}
    10172
    102 bool StringGenerator::hasFlag(string flag, std::vector<string> flags){
    103         return (std::find(flags.begin(), flags.end(), flag) != flags.end()) ? true : false;
    104 }
    105 
    106 
    107 string StringGenerator::generate(string re, std::vector<string> flags, re::RE_Syntax syntax){
    108 
    109         bool caseInsensitive = hasFlag("-i", flags);
    110 
    111         re::RE * re_ast = re::RE_Parser::parse(re, caseInsensitive, syntax);
    112         string str = stringifyVec(generate(re_ast));
    113         return str;
    114 }
    115 
    116 std::vector<std::string> StringGenerator::generate(RE * re) {
    117         srand (time(NULL));
    118         std::vector<string> retVec;
     73
     74string StringGenerator::generate() {
     75    if (mSyntax == re::RE_Syntax::FixedStrings) {
     76      return mRegex;
     77    }
     78    else {
     79      string result;
     80      bool caseInsensitive = std::find(mFlags.begin(), mFlags.end(), "-i") != mFlags.end();
     81      if (re::RE * re_ast = re::RE_Parser::parse(mRegex, caseInsensitive, mSyntax)){
     82         result = stringifyVec(generate(re_ast));
     83      }
     84      return result;
     85    }
     86}
     87
     88std::vector<CC *> StringGenerator::generate(RE * re, bool Complement, bool getOne) {
     89    // cout << Printer_RE::PrintRE(re) << endl;
     90        std::vector<CC*> retVec = {};
    11991    if (re == nullptr) {
    12092        return retVec;
     93
     94    } else if (isa<Any>(re)) {
     95        if (getOne){
     96            retVec.push_back(getRandomCodepointCC(getAllCodepoints()));
     97        }
     98        else{
     99            retVec.push_back(getAllCodepoints());
     100        }
     101
    121102    } else if ( Alt* re_alt = dyn_cast<Alt>(re)) {
    122         std::vector<string> set;
    123         for ( RE * re : *re_alt){
    124                 set = appendRtoL(set, generate(re));
    125         }
    126                 int random = rand() % set.size();
    127                 retVec.push_back(set[random]);
    128                
     103        int random = rand() % re_alt->size();
     104        retVec = generate((*re_alt)[random]);
    129105    } else if (CC* re_cc = dyn_cast<CC>(re)) {
    130         for (auto i : *re_cc) {
    131                 for (auto cp = lo_codepoint(i); cp <= hi_codepoint(i); cp++){
    132                         std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> converter;
    133                         std::string u8str = converter.to_bytes(cp);
    134                         retVec.push_back(u8str);
    135                 }
     106        if (!re_cc->empty()){
     107            retVec.push_back(subtractCC(re_cc, forbiddenCC));
    136108        }
    137109    } else if (Name* re_name = dyn_cast<Name>(re)) {
    138110
    139111        switch (re_name->getType()) {
     112        case Name::Type::Byte:
    140113                case Name::Type::Unicode:
    141                                 retVec = generate(re_name->getDefinition()); 
     114                                retVec = generate(re_name->getDefinition());
    142115                                break;
    143116                        case Name::Type::UnicodeProperty: {
    144                 if (re_name->getName() == "whitespace"){
    145                     retVec.push_back(" ");
     117                if ((re_name->getName() == "whitespace") && !Complement) {
     118                    retVec.push_back(makeCC(0x0020));
    146119                    break;
    147120                }
    148                                 UCD::UnicodeSet ucs = UCD::resolveUnicodeSet(re_name);
    149                                 for (auto i : ucs){
    150                                         for (auto cp = lo_codepoint(i); cp <= hi_codepoint(i); cp++){
    151                                                 std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> converter;
    152                                         std::string u8str = converter.to_bytes(cp);
    153                                                 retVec.push_back(u8str);
    154                                 }
     121                UCD::UnicodeSet ucs = UCD::resolveUnicodeSet(re_name);
     122
     123                if (!ucs.empty()) {
     124                    CC * propertyCC = makeCC(std::move(ucs));
     125                    if (propertyCC->intersects(*forbiddenCC)) {
     126                        propertyCC = subtractCC(propertyCC, forbiddenCC);
     127                    }
     128                    retVec.push_back(propertyCC);
    155129                                }
    156130                                break;
    157131                        }
    158132                case Name::Type::Capture: {
    159                         std::vector<string> set = generate(re_name->getDefinition());
    160                         int random = rand() % set.size();
    161                         string str = set[random];
    162                         references.push_back(str);
    163                         retVec.push_back(str);
     133                        std::vector<CC *> set = generate(re_name->getDefinition());
     134                std::vector<CC *> ref;
     135                        if (!set.empty()){
     136                    for (auto s : set) {
     137                        if (!s->empty()){
     138                            CC * randomCC = getRandomCodepointCC(s);
     139                            retVec.push_back(randomCC);
     140                            ref.push_back(randomCC);
     141                        }
     142                    }
     143                }
     144
     145                mReferences.push_back(ref);
    164146                        break;
    165147                }
    166148                        case Name::Type::Reference:
    167149                        {
    168                 bool found = false;
    169                                 for (unsigned i = 0; i < references.size(); i++){
     150                                for (unsigned i = 0; i < mReferences.size(); i++){
    170151                                        string ref = "\\" + to_string(i+1);
    171152                                        if (ref == re_name->getName()){
    172                                                 retVec.push_back(references[i]);
    173                         found = true;
     153                                                retVec = mReferences[i];
     154                        break;
    174155                                        }
    175156                                }
    176                 if (!found){
    177                     cerr << "reference not found\n";
    178                 }
    179157                                break;
    180158                        }
    181                         default: 
    182                         retVec.push_back("Bad MyEnum");
    183                  }
    184     } else if (Assertion * a = dyn_cast<Assertion>(re)) {
     159                        default:
     160                        cerr << "Bad name type" << endl;
     161                }
     162    } else if (isa<Assertion>(re)) {
    185163        //Do Nothing
    186164    } else if (Diff* diff = dyn_cast<Diff>(re)) {
    187 
    188         std::vector<string> set = getDiff(generate(diff->getLH()), generate(diff->getRH()));
    189         retVec = appendRtoL(retVec, set);
    190 
     165        CC * LHS = makeCC();
     166        CC * RHS = makeCC();
     167        for (auto cc : generate(diff->getLH())) {
     168            LHS = makeCC(LHS, cc);
     169        }
     170        LHS = subtractCC(LHS, forbiddenCC);
     171        for (auto cc : generate(diff->getRH(), true, false)) {
     172            RHS = makeCC(RHS, cc);
     173        }
     174        retVec.push_back(subtractCC(LHS, RHS));
    191175    } else if (Intersect* x = dyn_cast<Intersect>(re)) {
    192176
    193         std::vector<string> set = getIntersect(generate(x->getLH()), generate(x->getRH()));
    194         retVec = appendRtoL(retVec, set);
     177        CC * LHS = makeCC();
     178        CC * RHS = makeCC();
     179        for (auto cc : generate(x->getLH(), true, false)) {
     180            LHS = makeCC(LHS, cc);
     181        }
     182        for (auto cc : generate(x->getRH(), true, false)) {
     183            RHS = makeCC(RHS, cc);
     184        }
     185        retVec.push_back(intersectCC(LHS, RHS));
    195186
    196187    } else if (Rep* re_rep = dyn_cast<Rep>(re)) {
    197188
    198         int lb = re_rep->getLB();
    199         int ub = (re_rep->getUB() == Rep::UNBOUNDED_REP) ? lb + 100 : re_rep->getUB();
    200         string ret = "";
    201        
    202         int range = (ub - lb) + 1;
    203         int random = (lb == 0)? rand() % ub : rand() % range + lb;
    204        
    205         std::vector<string> set = generate(re_rep->getRE());
    206         for (auto i =0; i<random; ++i){
    207                 srand (time(NULL));
    208                 int random2 = rand() % set.size();
    209                 ret += set[random2];
    210         }
    211         retVec.push_back(ret);
     189        std::vector<CC *> set = generate(re_rep->getRE());
     190        if (!set.empty()){
     191                int lb = re_rep->getLB();
     192            int ub = (re_rep->getUB() == Rep::UNBOUNDED_REP) ? lb + 1000 : re_rep->getUB();
     193
     194            int boundRange = (lb == 0)? (ub+1) : (ub - lb + 1);
     195                int random = rand() % boundRange + lb;
     196                // cout << "random bound = " << to_string(random) << endl;
     197            for (auto i =0; i < random; ++i){
     198                for (auto *s : set) {
     199                    retVec.push_back(s);
     200                }
     201            }
     202        }
    212203
    213204    } else if (Seq* re_seq = dyn_cast<Seq>(re)) {
    214205
    215206        for (RE * re : *re_seq) {
    216             std::vector<string> set = generate(re);
    217            
    218             if (!set.empty()){
    219                     int random = rand() % set.size();
    220                     retVec.push_back(set[random]);
     207            std::vector<CC *> set = generate(re);
     208
     209            if (!set.empty()) {
     210                for (auto s : set) {
     211                    retVec.push_back(getRandomCodepointCC(s));
     212                }
    221213                }
    222214        }
    223215    } else if (isa<Start>(re) || isa<End>(re)) {
    224                 retVec.push_back("");
    225     } else if (isa<Any>(re)) {
    226         retVec = getAllCodepoints();
     216                retVec.push_back(makeCC());
    227217    } else {
    228218        cerr << "RE type not recognised\n";
    229219    }
     220    // if (!retVec.empty())
     221    //     cout << retVec.back() << endl;
     222    // if (!returnCC->empty()) {
     223    //     cout << "returnCC = " << Printer_RE::PrintRE(returnCC) << endl;
     224    // }
    230225    return retVec;
    231226}
     227
     228
     229
     230StringGenerator::StringGenerator(std::string re, std::vector<std::string> flags, re::RE_Syntax syntax)
     231: mRegex(re)
     232, mFlags(flags)
     233, mSyntax(syntax)
     234, asciiCC(re::makeCC(0, 0x007E))
     235, unicodeCC(re::makeCC(0, 0xEFFFF))
     236, forbiddenCC(re::makeCC({{0x0000, 0x0008}, {0x000A, 0x001F},
     237                          {0x007F, 0x007F}, {0x0085, 0x0085},
     238                          {0x2028, 0x2029}, {0x2424, 0x2424},
     239                          {0x2B89, 0x2B92}, {0x4DD7, 0x4DD7},
     240                          {0xD800, 0xDFFF}, {0xE01F0, 0xEFFFF}}))
     241, allCodepointsCC(subtractCC((syntax == re::RE_Syntax::PCRE) ? unicodeCC : asciiCC, forbiddenCC))
     242{
     243
     244}
     245
     246StringGenerator::~StringGenerator() {
     247    re::RE::Reset();
     248    // UCD::UnicodeSet::Reset();
     249}
Note: See TracChangeset for help on using the changeset viewer.