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

Update to CoRE testing system

File:
1 edited

Legend:

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

    r5613 r5825  
    11#include "regexGen.h"
    22#include "stringGen.h"
     3#include "propGen.h"
     4
    35
    46#include <string>
     
    1012#include <algorithm>
    1113
    12 #include <stdlib.h> 
    13 #include <time.h> 
     14#include <stdlib.h>
     15#include <time.h>
    1416#include <stdio.h>
    1517#include <re/re_diff.h>
    16 #include <re/re_any.h> 
     18#include <re/re_any.h>
    1719#include <re/re_parser.h>
     20
    1821
    1922
     
    2326        std::vector<string> ccList;
    2427        std::vector<string> usedCC;
     28        re::RE_Syntax syntax;
    2529public:
    26         CC(std::vector<string> header, std::vector<string> row, re::RE_Syntax syntax){
    27                 RegexGen reGen(syntax);
    28                 ccList = reGen.parseCC(header, row);
    29 
    30         }
     30        CC(std::vector<string> &params, std::vector<string> &values, re::RE_Syntax syntax){
     31                this->syntax = syntax;
     32                parseCC(params, values);
     33        }
     34
    3135        std::string getCC(){
    3236                int random;
     
    4448                        return cc;
    4549                }
    46                 else return "n";
    47         }
     50                else return "C";
     51        }
     52
    4853        std::vector<string> getRemainingCC(){
    4954                return ccList;
    5055        }
     56private:
     57
     58        void parseCC(std::vector<string> params, std::vector<string> values){
     59                int colnum = 0;
     60                for(auto col : values){
     61                        if ((col != "false") && (col!= "off")){
     62                                string cc;
     63                                if (params[colnum] == "wordC") {
     64                                        ccList.push_back(getWord());
     65                                }
     66                                else if (params[colnum] == "notWordC") {
     67                                        ccList.push_back(getNotWord());
     68                                }
     69                                else if (params[colnum] == "whitespace") {
     70                                        ccList.push_back(getWhitespace());
     71                                }
     72                                else if (params[colnum] == "notWhitespace") {
     73                                        ccList.push_back(getNotWhitespace());
     74                                }
     75                                else if (params[colnum] == "tab") {
     76                                        ccList.push_back(getTab());
     77                                }
     78                                else if (params[colnum] == "digit") {
     79                                        ccList.push_back(getDigit());
     80                                }
     81                                else if (params[colnum] == "notDigit") {
     82                                        ccList.push_back(getNotDigit());
     83                                }
     84                                else if (params[colnum] == "any") {
     85                                        ccList.push_back(getAny());
     86                                }
     87                                else if (params[colnum] == "unicodeC"){
     88                                        ccList.push_back(getUnicodeCodepoint());
     89                                }
     90                                else if (params[colnum] == "range"){
     91                                        ccList.push_back(getRange());
     92                                }
     93                                else if (params[colnum] == "posix"){
     94                                        ccList.push_back(getPosix(col));
     95                                }
     96                                else if (params[colnum] == "property") {
     97                                        ccList.push_back(getProperty(col));
     98                                }
     99                                else if (params[colnum] == "notProperty") {
     100                                        ccList.push_back(getNotProperty(col));
     101                                }
     102                                else if (params[colnum] == "nameProperty") {
     103                                        ccList.push_back(getUnicodeName());
     104                                }
     105
     106                        }
     107                        ++colnum;
     108                }
     109        }
     110
     111        string getWord(){
     112                if (syntax == re::RE_Syntax::BRE){
     113                        return "w";
     114                }
     115                else return "\\w";
     116        }
     117        string getNotWord(){
     118                if (syntax == re::RE_Syntax::BRE){
     119                        return "notWord";
     120                }
     121                else return "\\W";
     122        }
     123        string getWhitespace(){
     124                return "\\s";
     125        }
     126        string getNotWhitespace(){
     127                return "\\S";
     128        }
     129        string getTab(){
     130                if (syntax != re::RE_Syntax::PCRE){
     131                        return "t";
     132                }
     133                else return "\\t";
     134        }
     135        string getDigit(){
     136                if (syntax != re::RE_Syntax::PCRE){
     137                        return "d";
     138                }
     139                else return "\\d";
     140        }
     141        string getNotDigit(){
     142                if (syntax != re::RE_Syntax::PCRE){
     143                        return "D";
     144                }
     145                else return "\\D";
     146        }
     147        string getAny(){
     148                return ".";
     149        }
     150        string getPosix(string value){
     151                        return "[[:" + value + ":]]";
     152        }
     153
     154        std::string getCharacterName(){
     155                int random = rand() % 28179;
     156                ifstream file;
     157                file.open("../icgrep/combine/UnicodeNames.txt");
     158                string line;
     159                for (int i = 0; i <= random ; i++){
     160                        if (!getline(file, line)) {
     161                                cerr << "Error in extracting Unicode property names!\n";
     162                        }
     163                }
     164                file.close();
     165                return line;
     166        }
     167        std::string getProperty(string type){
     168
     169                if (syntax == re::RE_Syntax::PCRE) {
     170                        // vector<string> prop = {"L", "Ll", "Lu", "Lt", "Lm", "Lo", "M", "Mn",
     171                        //                                                                                       "Mc", "Me", "Z", "Zs", "Zl", "Zp", "S", "Sm", "Sc",
     172                        //                                                                                       "Sk", "So", "N", "Nd", "Nl", "No", "P", "Pd", "Ps",
     173                        //                                                                                       "Pe", "Pi", "Pf", "Pc", "Po", "C", "Cc", "Cf", "Co",
     174                        //                                                                                 "Cs", "Cn"};
     175                        PropGen p;
     176                        string regex = "";
     177                        if (type == "string"){
     178                                regex = "abc";
     179                        }
     180                        return "\\p{" + p.getPropertyValue(type, regex) + "}" ;
     181                }
     182                else {
     183                        return "p";
     184                }
     185        }
     186        std::string getNotProperty(string type){
     187                if (syntax == re::RE_Syntax::PCRE) {
     188                        // vector<string> prop = {"L", "Ll", "Lu", "Lt", "Lm", "Lo", "M", "Mn",
     189                        //                                                                                       "Mc", "Me", "Z", "Zs", "Zl", "Zp", "S", "Sm", "Sc",
     190                        //                                                                                       "Sk", "So", "N", "Nd", "Nl", "No", "P", "Pd", "Ps",
     191                        //                                                                                       "Pe", "Pi", "Pf", "Pc", "Po", "C", "Cc", "Cf", "Co",
     192                        //                                                                                 "Cs", "Cn"};
     193                        // int random = rand() % prop.size();
     194                        // return "\\p{" + prop[random] + "}" ;
     195                        string regex = "";
     196                        if (type == "string"){
     197                                regex = "abc";
     198                        }
     199                        PropGen p;
     200                        return "\\P{" + p.getPropertyValue(type, regex) + "}" ;
     201                }
     202                else {
     203                        return "P";
     204                }
     205        }
     206        std::string getUnicodeName(){
     207                if (syntax == re::RE_Syntax::PCRE) {
     208                        return "\\N{^" + getCharacterName() + "$}" ;
     209                }
     210                else {
     211                        return "N";
     212                }
     213        }
     214        std::string getUnicodeCodepoint(){
     215                if (syntax != re::RE_Syntax::PCRE) {
     216                        return "u";
     217                }
     218                else {
     219                        int random = rand() % 16544;
     220                        ifstream file;
     221                        file.open("../icgrep/combine/Unicode.txt");
     222                        string line;
     223                        for (int i = 0; i <= random ; i++){
     224                                if (!getline(file, line)) {
     225                                        cerr << "Error in extracting Unicode codepoints!\n";
     226                                }
     227                        }
     228                        file.close();
     229                        return "\\u" + line;
     230                }
     231        }
     232        std::string getUnicodeRange(){
     233
     234                int random1 = rand() % 16544;
     235                int random2 = rand() % 16544;
     236                if (random1 > random2){
     237                        std::swap(random1, random2);
     238                }
     239                ifstream file;
     240                file.open("../icgrep/combine/Unicode.txt");
     241                string line1;
     242                string line2;
     243                for (int i = 0; i < random2 ; i++){
     244                        if (!getline(file, line2)) {
     245                                cerr << "Error in extracting Unicode codepoints!\n";
     246                        }
     247                        if (random1 == i){
     248                                line1 = line2;
     249                        }
     250                }
     251                file.close();
     252                return "[\\u" + line1 + "-\\u" + line2 + "]";
     253
     254        }
     255        std::string getRange(){
     256
     257                if (syntax != re::RE_Syntax::PCRE){
     258                        std::vector<string> lists = {"[a-zA-Z0-9]","[A-Za-z]","[0-9]"};
     259                        int random = rand() % lists.size();
     260                        return lists[random];
     261                }
     262                else {
     263                        return getUnicodeRange();
     264                }
     265        }
    51266};
    52267
    53 RegexGen::RegexGen(std::vector<string> header, std::vector<string> row){
    54         syntax = setSyntax(header, row);
    55         RE = parseRE(header, row);
    56         flags = parseFlags(header, row);
     268RegexGen::RegexGen(std::vector<string> param, std::vector<string> val): mParameters(param), mValues(val) {
     269        try{
     270                syntax = getSyntax();
     271                RE = parseRE();
     272                flags = parseFlags();
     273                fileType = getFileTy();
     274        }
     275        catch (...){
     276                syntax = re::RE_Syntax::PCRE;
     277                RE = "Could Not Generate RE";
     278        }
    57279}
    58280
     
    67289}
    68290
    69 string RegexGen::getBoundary(){
    70         return "\\b";
    71 }
    72 string RegexGen::getNotBoundary(){
    73         return "\\B";
    74 }
    75 string RegexGen::getWord(){
    76         if (syntax == re::RE_Syntax::BRE){
    77                 return "w";
    78         }
    79         else return "\\w";
    80 }
    81 string RegexGen::getNotWord(){
    82         if (syntax == re::RE_Syntax::BRE){
    83                 return "notWord";
    84         }
    85         else return "\\W";
    86 }
    87 string RegexGen::getWhitespace(){
    88         return "\\s";
    89 }
    90 string RegexGen::getNotWhitespace(){
    91         return "\\S";
    92 }
    93 string RegexGen::getTab(){
    94         if (syntax == re::RE_Syntax::BRE){
    95                 return "t";
    96         }
    97         else return "\\t";
    98 }
    99 string RegexGen::getDigit(){
    100         if (syntax == re::RE_Syntax::BRE){
    101                 return "d";
    102         }
    103         else return "\\d";
    104 }
    105 string RegexGen::getNotDigit(){
    106         if (syntax == re::RE_Syntax::BRE){
    107                 return "D";
    108         }
    109         else return "\\D";
    110 }
    111 string RegexGen::getAny(){
    112         return ".";
    113 }
    114 string RegexGen::getPosix(string value){
    115         if (syntax == re::RE_Syntax::PCRE){
    116                 return "[[:" + value + ":]]";
    117         }
    118         else {
    119                 return "p";
    120         }
    121 }
    122 std::string RegexGen::getUnicode(){
    123         if (syntax == re::RE_Syntax::BRE) {
    124                 return "u";
    125         }
    126         else {
    127                 int random = rand() % 30712;
    128                 ifstream file;
    129                 file.open("../icgrep/combine/Unicode.txt");
    130                 string line;
    131                 for (int i = 0; i <= random ; i++){
    132                         if (!getline(file, line)) {
    133                                 cerr << "Error in extracting Unicode codepoints!\n";
    134                         }
    135                 }
    136                 return "\\u" + line;
    137         }
    138 }
    139 std::string RegexGen::getList(){
     291
     292std::string RegexGen::getList(string cc1, string cc2, string cc3){
    140293        if (syntax == re::RE_Syntax::BRE) {
    141294                return "l";
    142295        }
    143         else {
    144                 std::vector<string> lists = {"[abc]","[XYZ]","[123]","[àŠ¹à§àŠ¯àŠŸàŠ²à§‹]"};
    145                 int random = rand() % lists.size();
    146                 return lists[random];
    147         }
    148        
    149 }
    150 std::string RegexGen::getNList(){
     296        else if (syntax == re::RE_Syntax::ERE){
     297                if(cc1.find("[")!= string::npos) cc1 = "a";
     298                if(cc2.find("[")!= string::npos) cc2 = "b";
     299                if(cc3.find("[")!= string::npos) cc3 = "c";
     300                return "[" + cc1 + cc2 + cc3 + "]";
     301        }
     302        else {
     303                return "[" + cc1 + cc2 + cc3 + "]";
     304        }
     305
     306}
     307std::string RegexGen::getNList(string cc1, string cc2, string cc3){
    151308        if (syntax == re::RE_Syntax::BRE) {
    152309                return "L";
    153310        }
    154         else {
    155                 std::vector<string> lists = {"[^abc]","[^XYZ]","[^123]","[^àŠ¹à§àŠ¯àŠŸàŠ²à§‹]"};
    156                 int random = rand() % lists.size();
    157                 return lists[random];
    158         }
    159 }
    160 std::string RegexGen::getRange(){
    161         if (syntax == re::RE_Syntax::BRE) {
    162                 return "r";
    163         }
    164         else {
    165                 std::vector<string> lists = {"[a-zA-Z0-9]","[A-Za-z]","[0-9]","[ا-ي]"};
    166                 int random = rand() % lists.size();
    167                 return lists[random];
    168         }
    169 }
    170 std::string RegexGen::getPropertyValue(){
    171         std::vector<string> property = {"Common", "Latin", "Greek", "Cyrillic",
    172                                                         "Armenian", "Hebrew", "Arabic", "Syriac",
    173                                                         "Thaana", "Devanagari", "Bengali", "Gurmukhi",
    174                                                         "Gujarati", "Oriya", "Tamil", "Telugu", "Kannada"};
    175         int random = rand() % property.size();
    176         return property[random];
    177 }
    178 std::string RegexGen::getCharacterName(){
    179         int random = rand() % 30547;
    180         ifstream file;
    181         file.open("../icgrep/combine/UnicodeNames.txt");
    182         string line;
    183         for (int i = 0; i <= random ; i++){
    184                 if (!getline(file, line)) {
    185                         cerr << "Error in extracting Unicode property names!\n";
    186                 }
    187         }
    188         return line;
    189 }
    190 std::string RegexGen::getProperty(){
    191         if (syntax == re::RE_Syntax::PCRE) {
    192                 return "\\p{" + getPropertyValue() + "}" ;
    193         }
    194         else {
    195                 return "p";
    196         }
    197 }
    198 std::string RegexGen::getNotProperty(){
    199         if (syntax == re::RE_Syntax::PCRE) {
    200                 return "\\P{" + getPropertyValue() + "}" ;
    201         }
    202         else {
    203                 return "P";
    204         }
    205 }
    206 std::string RegexGen::getName(){
    207         if (syntax == re::RE_Syntax::PCRE) {
    208                 return "\\N{" + getCharacterName() + "}" ;
    209         }
    210         else {
    211                 return "N";
    212         }
    213 }
     311        else if (syntax == re::RE_Syntax::ERE){
     312                if(cc1.find("[")!= string::npos) cc1 = "1";
     313                if(cc2.find("[")!= string::npos) cc2 = "2";
     314                if(cc3.find("[")!= string::npos) cc3 = "3";
     315
     316        }
     317        string ret = "[^" + cc1 + cc2 + cc3 + "]";
     318        if (getAssertionCoating(ret) != ret){
     319                return ret;
     320        }
     321        return ret;
     322}
     323
     324
    214325string RegexGen::getZeroOrOne(string cc){
    215326        if (syntax == re::RE_Syntax::BRE) {
     
    231342        }
    232343}
    233 string RegexGen::getRep(string cc, int rep){
     344string RegexGen::getRep(string cc, string size){
     345        int rep;
     346        if (size == "small"){
     347                rep = rand() % 10 + 1;
     348        }
     349        else if (size == "medium"){
     350                rep = rand() % 100 + 1;
     351        }
     352        else if (syntax != re::RE_Syntax::PCRE){
     353                rep = rand() % 255 + 1;
     354        }
     355        else {
     356                rep = rand() % 1000 + 1;
     357        }
     358
    234359        if (syntax == re::RE_Syntax::BRE) {
    235360                return cc + "\\{" + to_string(rep) + "\\}";
     
    239364        }
    240365}
    241 string RegexGen::getRep(string cc, int lb, int ub){
     366string RegexGen::getRepNM(string cc, string size){
     367        int lb;
     368        int ub;
     369        if (size == "small-small"){
     370                lb = rand() % 10;
     371                ub = rand() % 10 + 1;
     372        }
     373        else if (size == "small- medium"){
     374                lb = rand() % 10;
     375                ub = rand() % 100 + 1;
     376        }
     377        else if (size == "small-large"){
     378                lb = rand() % 10;
     379                ub = rand() % 255 + 1;
     380        }
     381        else if (size == "medium-meduim"){
     382                lb = rand() % 100;
     383                ub = rand() % 100 + 1;
     384        }
     385        else if (size == "medium-large"){
     386                lb = rand() % 100;
     387                if (syntax != re::RE_Syntax::PCRE){
     388                        ub = rand() % 255 + 1;
     389                }
     390                else {
     391                        ub = rand() % 1000 + 1;
     392                }
     393        }
     394        else {
     395                if (syntax != re::RE_Syntax::PCRE){
     396                        lb = rand() % 255;
     397                        ub = rand() % 255 + 1;
     398                }
     399                else {
     400                        lb = rand() % 1000;
     401                        ub = rand() % 1000 + 1;
     402                }
     403
     404        }
    242405        if (lb > ub) {
    243406                std::swap(lb, ub);
     
    250413        }
    251414}
    252 string RegexGen::getRepMore(string cc, int rep){
    253         if (syntax == re::RE_Syntax::BRE) {
    254                 return cc + "\\{" + to_string(rep) + ",\\}";
    255         }
    256         else {
    257                 return cc + "{" + to_string(rep) + ",}";
     415string RegexGen::getRepMore(string cc, string size){
     416        int lb;
     417        if (size == "small"){
     418                lb = rand() % 10 + 1;
     419        }
     420        else if (size == "medium"){
     421                lb = rand() % 100 + 1;
     422        }
     423        else {
     424                if (syntax != re::RE_Syntax::PCRE){
     425                        lb = rand() % 255 + 1;
     426                }
     427                else {
     428                        lb = rand() % 1000 + 1;
     429                }
     430        }
     431
     432        if (syntax == re::RE_Syntax::BRE) {
     433                return cc + "\\{" + to_string(lb) + ",\\}";
     434        }
     435        else {
     436                return cc + "{" + to_string(lb) + ",}";
    258437        }
    259438}
     
    273452                return "(" + cc + ")";
    274453        }
    275        
     454
    276455}
    277456string RegexGen::getAssertionCoating(string cc){
    278         if (cc.find("\\p{") == 0
    279                 || cc.find("\\N{") == 0
    280                 || cc.find("\\u") == 0){
    281                 re::RE * re_ast = re::RE_Parser::parse(cc, 0);
    282                 StringGenerator strGen;
    283                 std::vector<string> set = strGen.generate(re_ast);
    284                 if (!set.empty()){
    285                         int random = rand() % set.size();
    286                         return set[random];
    287                 }
    288                 else return cc;
    289         }
    290457        return cc;
    291458}
     
    317484        }
    318485        else {
    319                
    320                 re::RE * re_ast = re::RE_Parser::parse(cc, 0);
    321                 StringGenerator strGen;
    322                 std::vector<string> set = strGen.generate(re::makeDiff(re::makeAny(),re_ast));
    323                 if (!set.empty()){
    324                         int random = rand() % set.size();
    325                         return set[random];
    326                 }
    327                 else {
    328                         cerr << "No compliment for " << cc << "to coat the assertion!\n";
    329                         return cc;
    330                 }
     486                return "";
    331487        }
    332488}
     
    361517}
    362518
     519string RegexGen::getWordBegin(){
     520        if (syntax == re::RE_Syntax::PCRE){
     521                return "\\W\\<\\w";
     522        }
     523        else return "wb";
     524}
     525string RegexGen::getWordEnd(){
     526        if (syntax == re::RE_Syntax::PCRE){
     527                return "\\w\\>\\W";
     528        }
     529        else return "we";
     530}
     531
    363532
    364533bool RegexGen::usesCC(std::string op){
    365         std::vector<string> set = {"zeroOrOne","zeroOrMore","oneOrMore","repeat_n","repeat_nm","repeat_n_more","repeat_m_less", 
    366                                                         "backref", "join", "look_ahead", "mlook_ahead", "look_behind", "nlook_behind" "look_ahead",
     534        std::vector<string> set = {"zeroOrOne","zeroOrMore","oneOrMore","repeat_n","repeat_nm","repeat_n_more","repeat_m_less",
     535                                                        "list", "nList", "backref", "join", "look_ahead", "mlook_ahead", "look_behind", "nlook_behind" "look_ahead",
    367536                                                        "mlook_ahead", "look_behind", "nlook_behind"};
    368537
     
    373542}
    374543
    375 re::RE_Syntax RegexGen::setSyntax(std::vector<string> header, std::vector<string> row){
     544re::RE_Syntax RegexGen::getSyntax(){
    376545        int colnum = 0;
    377         for(auto col : row){
    378                 if (header[colnum] == "syntax") {
     546        for(auto col : mValues){
     547                if (mParameters[colnum] == "syntax") {
    379548                        if (col == "-G"){
    380549                                return re::RE_Syntax::BRE;
     
    383552                                return re::RE_Syntax::ERE;
    384553                        }
     554                        else if (col == "-P"){
     555                                return re::RE_Syntax::PCRE;
     556                        }
     557                        else if (col == "-F"){
     558                                return re::RE_Syntax::FixedStrings;
     559                        }
    385560                }
    386561                colnum++;
     
    388563        return re::RE_Syntax::PCRE;
    389564}
    390 
    391 
    392 
    393 std::vector<string> RegexGen::parseCC(std::vector<string> header, std::vector<string> row){
    394         std::vector<string> ccList;
    395 
     565RegexGen::FileType RegexGen::getFileTy(){
    396566        int colnum = 0;
    397         for(auto col : row){
    398                 if (col != "false"){
    399                         string cc;
    400                         if (header[colnum] == "wordC") {
    401                                 cc = getWord();
    402                                 ccList.push_back(getWord());
    403                         }
    404                         else if (header[colnum] == "notWordC") {
    405                                 cc = getNotWord();
    406                                 ccList.push_back(getNotWord());
    407                         }
    408                         else if (header[colnum] == "whitespace") {
    409                                 cc = getWhitespace();
    410                                 ccList.push_back(getWhitespace());
    411                         }
    412                         else if (header[colnum] == "notWhitespace") {
    413                                 cc = getNotWhitespace();
    414                                 ccList.push_back(getNotWhitespace());
    415                         }
    416                         else if (header[colnum] == "tab") {
    417                                 cc = getTab();
    418                                 ccList.push_back(getTab());
    419                         }
    420                         else if (header[colnum] == "digit") {
    421                                 cc = getDigit();
    422                                 ccList.push_back(getDigit());
    423                         }
    424                         else if (header[colnum] == "notDigit") {
    425                                 cc = getNotDigit();
    426                                 ccList.push_back(getNotDigit());
    427                         }
    428                         else if (header[colnum] == "any") {
    429                                 cc = getWord();
    430                                 ccList.push_back(getAny());
    431                         }
    432                         else if (header[colnum] == "unicodeC"){
    433                                 cc = getUnicode();
    434                                 ccList.push_back(getUnicode());
    435                         }
    436                         else if (header[colnum] == "list"){
    437                                 cc = getList();
    438                                 ccList.push_back(getList());
    439                         }
    440                         else if (header[colnum] == "nList"){
    441                                 cc = getNList();
    442                                 ccList.push_back(getNList());
    443                         }
    444                         else if (header[colnum] == "range"){
    445                                 cc = getRange();
    446                                 ccList.push_back(getRange());
    447                         }
    448                         else if (header[colnum] == "posix"){
    449                                 if (col != "off"){
    450                                         cc = getPosix(col);
    451                                         ccList.push_back(getPosix(col));
    452                                 }
    453                         }
    454                         else if (header[colnum] == "property") {
    455                                 cc = getProperty();
    456                                 ccList.push_back(getProperty());
    457                         }
    458                         else if (header[colnum] == "notProperty") {
    459                                 cc = getProperty();
    460                                 ccList.push_back(getNotProperty());
    461                         }
    462                         else if (header[colnum] == "nameProperty") {
    463                                 cc = getName();
    464                                 ccList.push_back(getName());
    465                         }
    466                 }
    467                 ++colnum;
    468         }
    469         return ccList;
    470 }
    471 
    472 std::string RegexGen::parseRE(std::vector<string> header, std::vector<string> row){
    473         srand (time(NULL));
     567        for(auto col : mValues){
     568                if (mParameters[colnum] == "fileType") {
     569                        if (col == "s"){
     570                                return FileType::SMALL;
     571                        }
     572                        else if (col == "m"){
     573                                return FileType::MEDIUM;
     574                        }
     575                        else if (col == "l"){
     576                                return FileType::LARGE;
     577                        }
     578                }
     579                colnum++;
     580        }
     581        //default
     582        return FileType::SMALL;
     583}
     584
     585
     586std::string RegexGen::parseRE(){
     587
    474588        std::vector<string> fullRE;
    475589        std::vector<string> assertions;
    476         CC ccHandler(header,row, syntax);
     590        CC ccHandler(mParameters,mValues, syntax);
    477591        int random;
    478592        bool bref = false;
    479593        string first = "";
    480594        string last = "";
    481         int colnum = 0;
    482595        std::string re;
    483         for (auto col : row){
    484                 if (col != "false"){
     596        for (int colnum = 0; colnum < mValues.size(); colnum++){
     597                auto col = mValues[colnum];
     598                if (col != "false" && col != "off"){
    485599                        string cc;
    486                         if (usesCC(header[colnum])){
     600                        if (usesCC(mParameters[colnum])){
    487601
    488602                                cc = ccHandler.getCC();
    489                                 if (header[colnum] == "zeroOrOne"  ){
     603                                if (mParameters[colnum] == "zeroOrOne"  ){
    490604                                        re = getZeroOrOne(cc);
    491605                                        if (!re.empty())
    492606                                        fullRE.push_back(re);
    493607                                }
    494                                 else if (header[colnum] == "zeroOrMore"){
     608                                else if (mParameters[colnum] == "zeroOrMore"){
    495609                                        re = getZeroOrMore(cc);
    496610                                        if (!re.empty())
    497611                                        fullRE.push_back(re);
    498                                 } 
    499                                 else if (header[colnum] == "oneOrMore"){
     612                                }
     613                                else if (mParameters[colnum] == "oneOrMore"){
    500614                                        re = getOneOrMore(cc);
    501                                         // std::string nestDepth = row[colnum+1];
    502                                         // int depth = std::stoi(nestDepth);
    503                                         // while(depth>0){
    504                                         //      std::string cc2;
    505                                         //      cc2 = ccHandler.getCC();
    506                                         //      re = '(' + re + cc2 + ')' + header[colnum];
    507                                         //      --depth;
    508                                         // }
    509615                                        if (!re.empty())
    510616                                        fullRE.push_back(re);
    511617                                }
    512                                 else if (header[colnum] == "repeat_n"){
    513                                         random = rand() % 200 + 1;
    514                                         re = getRep(cc, random);
    515                                         // std::string nestDepth = row[colnum+1];
    516                                         // int depth = std::stoi(nestDepth);
    517                                         // while(depth>0){
    518                                         //      std::string cc2;
    519                                         //      cc2 = ccHandler.getCC();
    520                                         //      random = rand() % 200;
    521                                         //      re = '(?:' + re + cc2 + ')' + '{' + to_string(random) + '}';
    522                                         //      --depth;
    523                                         // }
     618                                else if (mParameters[colnum] == "repeat_n"){
     619                                        re = getRep(cc, col);
    524620                                        if (!re.empty())
    525621                                        fullRE.push_back(re);
    526622                                }
    527                                 else if (header[colnum] == "repeat_nm" ){
    528                                         int r1 = rand() % 200;
    529                                         int r2 = rand() % 200;
    530                                         while ((r1 == 0) && (r2 == 0)){
    531                                                 r2 = rand() % 200;
    532                                         }
    533                                         re = getRep(cc, r1, r2);
    534                                         // std::string nestDepth = row[colnum+1];
    535                                         // int depth = std::stoi(nestDepth);
    536                                         // while(depth>0){
    537                                         //      std::string cc2 = ccHandler.getCC();
    538                                         //      std::vector<int> randoms;
    539                                         //      randoms.push_back(rand() % 200);
    540                                         //      randoms.push_back(rand() % 200);
    541                                         //      sort(randoms.begin(), randoms.end());
    542                                         //      re = '(?:' + re + cc2 + ')' + '{' + to_string(randoms[0]) + ',' + to_string(randoms[1]) + '}';
    543                                         //      --depth;
    544                                         // }
     623                                else if (mParameters[colnum] == "repeat_nm" ){
     624                                        re = getRepNM(cc, col);
    545625                                        if (!re.empty())
    546626                                        fullRE.push_back(re);
    547627                                }
    548                                 else if (header[colnum] == "repeat_n_more" ){
    549                                         random = rand() % 200;
    550                                         re = getRepMore(cc, random);
     628                                else if (mParameters[colnum] == "repeat_n_more" ){
     629                                        re = getRepMore(cc, col);
    551630                                        if (!re.empty())
    552631                                        fullRE.push_back(re);
    553632                                }
    554                                 else if (header[colnum] == "backref"){
     633                                else if (mParameters[colnum] == "list"){
     634                                        string cc1 = ccHandler.getCC();
     635                                        string cc2 = ccHandler.getCC();
     636                                        fullRE.push_back(getList(cc, cc1, cc2));
     637                                }
     638                                else if (mParameters[colnum] == "nList"){
     639                                        string cc1 = ccHandler.getCC();
     640                                        string cc2 = ccHandler.getCC();
     641                                        auto ret = getNList(cc, cc1, cc2);
     642                                        if (ret!= "")
     643                                                fullRE.push_back(ret);
     644                                }
     645                                else if (mParameters[colnum] == "backref"){
    555646                                        bref = true;
    556647                                }
    557                                 else if (header[colnum] == "join" ){
     648                                else if (mParameters[colnum] == "join" ){
    558649                                        std::string cc2 = ccHandler.getCC();
    559650                                        re = getJoin(cc, cc2);
     
    561652                                        fullRE.push_back(re);
    562653                                }
    563                                 else if (header[colnum] == "look_ahead"){
     654                                else if (mParameters[colnum] == "look_ahead"){
    564655                                        re = getLookAhead(cc);
    565656                                        if (!re.empty())
    566657                                        assertions.push_back(re);
    567658                                }
    568                                 else if (header[colnum] == "nlook_ahead"){
     659                                else if (mParameters[colnum] == "nlook_ahead"){
    569660                                        if (cc == ".") {
    570661                                                continue;
     
    576667                                        }
    577668                                }
    578                                 else if (header[colnum] == "look_behind"){
     669                                else if (mParameters[colnum] == "look_behind"){
    579670                                        re = getLookBehind(cc);
    580671                                        if (!re.empty())
    581672                                        assertions.push_back(re);
    582673                                }
    583                                 else if (header[colnum] == "nlook_behind"){
     674                                else if (mParameters[colnum] == "nlook_behind"){
    584675                                        if (cc == ".") {
    585676                                                continue;
     
    594685                        else {
    595686
    596                                 // if (header[colnum] == "boundary") {
    597                                 //      re = getBoundary();
    598                                 //      if (!re.empty())
    599                                 //      assertions.push_back(re +"\\s");
    600                                 // }
    601                                 // else if (header[colnum] == "notBoundary") {
    602                                 //      std::string front = getAssertionCoating("[^\\s\\t\\n]");
    603                                 //      re = getNotBoundary();
    604                                 //      if (!re.empty())
    605                                 //      assertions.push_back(re + front);
    606                                 // }
    607                                 if (header[colnum] == "start"){
     687                                if (mParameters[colnum] == "start"){
    608688                                                first = "^";
    609689                                }
    610                                 else if (header[colnum] == "end"){
     690                                else if (mParameters[colnum] == "end"){
    611691                                                last = "$";
    612692                                }
    613                         }
    614 
    615                 }
    616                 colnum++;
     693                                else if (mParameters[colnum] == "word_begin") {
     694                                        fullRE.push_back(getWordBegin());
     695                                }
     696                                else if (mParameters[colnum] == "word_end") {
     697                                        fullRE.push_back(getWordEnd());
     698                                }
     699                        }
     700                }
    617701        }
    618702
     
    643727}
    644728
    645 std::vector<string> RegexGen::parseFlags(std::vector<string> header, std::vector<string> row){
     729std::vector<string> RegexGen::parseFlags(){
    646730        std::vector<string> flags;
    647         int colnum = 0;
    648         for (auto col : row){
    649                 if (col != "false"){
    650                         if (//header[colnum] == "-c"
    651                                 header[colnum] == "-i"
    652                                 // || header[colnum] == "-w"
    653                                 // || header[colnum] == "-x"
    654                                 || header[colnum] == "-e"
    655                                 || header[colnum] == "-f"){
    656                                 flags.push_back(header[colnum]);
    657                         }
    658                         else if (header[colnum] == "-t"){
    659                                 if (col != "off"){
     731        for (int colnum = 0; colnum < mValues.size(); colnum++){
     732                auto col = mValues[colnum];
     733                if ((col != "false") && (col != "off")){
     734                        if (mParameters[colnum] == "-c"
     735                         || mParameters[colnum] == "-i"
     736                         || mParameters[colnum] == "-v"
     737                         || mParameters[colnum] == "-x"
     738                         || mParameters[colnum] == "-w"
     739                         || mParameters[colnum] == "-e"
     740                         || mParameters[colnum] == "-f"){
     741                                flags.push_back(mParameters[colnum]);
     742                        }
     743                        else if (mParameters[colnum] == "-t"){
    660744                                        flags.push_back("-t=" + col);
    661                                 }
    662                         }
    663                         else if (header[colnum] == "-BlockSize"){
    664                                 if (col != "off"){
     745                        }
     746                        else if (mParameters[colnum] == "-BlockSize"){
    665747                                        flags.push_back("-BlockSize=" + col);
    666                                 }
    667                         }
    668                         else if (header[colnum] == "syntax"){
    669                                 flags.push_back(col);
    670                         }
    671                 }
    672                 colnum++;
    673         }
    674         flags.push_back("-c");
     748                        }
     749                        else if (mParameters[colnum] == "syntax"){
     750                                        flags.push_back(col);
     751                        }
     752                }
     753        }
    675754        return flags;
    676755}
    677 
Note: See TracChangeset for help on using the changeset viewer.