source: icGREP/icgrep-devel/icgrep/combine/stringGen.cpp @ 5613

Last change on this file since 5613 was 5613, checked in by faldebey, 20 months ago

different updates to CoRE

File size: 6.3 KB
Line 
1#include "stringGen.h"
2
3#include <re/re_re.h>
4#include <re/re_alt.h>
5#include <re/re_any.h>
6#include <re/re_cc.h>
7#include <re/re_name.h>
8#include <re/re_end.h>
9#include <re/re_rep.h>
10#include <re/re_seq.h>
11#include <re/re_start.h>
12#include <re/re_diff.h>
13#include <re/re_intersect.h>
14#include <re/re_assertion.h>
15#include <re/re_name_resolve.h>
16#include <boost/algorithm/string/predicate.hpp>
17#include <boost/lexical_cast.hpp>
18#include <sstream>
19#include <algorithm>
20#include <iostream>
21#include <re/re_parser.h>
22#include <functional>
23#include <locale>
24#include <codecvt>
25#include <stdlib.h>
26#include <time.h>
27#include <UCD/resolve_properties.h>
28#include <UCD/unicode_set.h>
29#include <UCD/PropertyObjects.h>
30
31
32using namespace std;
33using namespace re;
34using namespace llvm;
35
36
37const 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
48vector<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
53vector<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
66vector<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
79std::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
92string StringGenerator::stringifyVec(vector<string> elements, string separator){
93        string line = "";
94        bool sep = false;
95        for (auto e : elements){
96                line += sep? separator + e : e;
97                sep = true;
98        }
99        return line;
100}
101
102bool StringGenerator::hasFlag(string flag, std::vector<string> flags){
103        return (std::find(flags.begin(), flags.end(), flag) != flags.end()) ? true : false;
104}
105
106
107string 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
116std::vector<std::string> StringGenerator::generate(RE * re) {
117        srand (time(NULL));
118        std::vector<string> retVec;
119    if (re == nullptr) {
120        return retVec;
121    } 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               
129    } 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                }
136        }
137    } else if (Name* re_name = dyn_cast<Name>(re)) {
138
139        switch (re_name->getType()) {
140                case Name::Type::Byte:
141                case Name::Type::Unicode:
142                                retVec = generate(re_name->getDefinition()); 
143                                break;
144                        case Name::Type::UnicodeProperty: {
145                if (re_name->getName() == "whitespace"){
146                    retVec.push_back(" ");
147                    break;
148                }
149                                UCD::UnicodeSet ucs = UCD::resolveUnicodeSet(re_name);
150                                for (auto i : ucs){
151                                        for (auto cp = lo_codepoint(i); cp <= hi_codepoint(i); cp++){
152                                                std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> converter;
153                                        std::string u8str = converter.to_bytes(cp);
154                                                retVec.push_back(u8str);
155                                }
156                                }
157                                break;
158                        }
159                case Name::Type::Capture: {
160                        std::vector<string> set = generate(re_name->getDefinition());
161                        int random = rand() % set.size();
162                        string str = set[random];
163                        references.push_back(str);
164                        retVec.push_back(str);
165                        break;
166                }
167                        case Name::Type::Reference:
168                        {
169                bool found = false;
170                                for (unsigned i = 0; i < references.size(); i++){
171                                        string ref = "\\" + to_string(i+1);
172                                        if (ref == re_name->getName()){
173                                                retVec.push_back(references[i]);
174                        found = true;
175                                        }
176                                }
177                if (!found){
178                    cerr << "reference not found\n";
179                }
180                                break;
181                        }
182                        default: 
183                        retVec.push_back("Bad MyEnum");
184                 }
185    } else if (Assertion * a = dyn_cast<Assertion>(re)) {
186        //Do Nothing
187    } else if (Diff* diff = dyn_cast<Diff>(re)) {
188
189        std::vector<string> set = getDiff(generate(diff->getLH()), generate(diff->getRH()));
190        retVec = appendRtoL(retVec, set);
191
192    } else if (Intersect* x = dyn_cast<Intersect>(re)) {
193
194        std::vector<string> set = getIntersect(generate(x->getLH()), generate(x->getRH()));
195        retVec = appendRtoL(retVec, set);
196
197    } else if (Rep* re_rep = dyn_cast<Rep>(re)) {
198
199        int lb = re_rep->getLB();
200        int ub = (re_rep->getUB() == Rep::UNBOUNDED_REP) ? lb + 100 : re_rep->getUB();
201        string ret = "";
202       
203        int range = (ub - lb) + 1;
204        int random = (lb == 0)? rand() % ub : rand() % range + lb;
205       
206        std::vector<string> set = generate(re_rep->getRE());
207        for (auto i =0; i<random; ++i){
208                srand (time(NULL));
209                int random2 = rand() % set.size();
210                ret += set[random2];
211        }
212        retVec.push_back(ret);
213
214    } else if (Seq* re_seq = dyn_cast<Seq>(re)) {
215
216        for (RE * re : *re_seq) {
217            std::vector<string> set = generate(re);
218           
219            if (!set.empty()){
220                    int random = rand() % set.size();
221                    retVec.push_back(set[random]);
222                }
223        }
224    } else if (isa<Start>(re) || isa<End>(re)) {
225                retVec.push_back("");
226    } else if (isa<Any>(re)) {
227        retVec = getAllCodepoints();
228    } else {
229        cerr << "RE type not recognised\n";
230    }
231    return retVec;
232}
Note: See TracBrowser for help on using the repository browser.