source: icGREP/icgrep-devel/icgrep/re_parser.cpp @ 3935

Last change on this file since 3935 was 3935, checked in by daled, 5 years ago

The parser is now able to parse unicode categories.

File size: 23.3 KB
Line 
1/*
2 *  Copyright (c) 2014 International Characters.
3 *  This software is licensed to the public under the Open Software License 3.0.
4 *  icgrep is a trademark of International Characters.
5 */
6
7#include "re_parser.h"
8
9
10ParseResult* RE_Parser::parse_re(std::string input_string)
11{
12    parse_result_retVal re_result = parse_re_helper(input_string);
13
14    if (re_result.remaining.length() == 0)
15    {
16        return re_result.result;
17    }
18    else if (ParseSuccess* re_success = dynamic_cast<ParseSuccess*>(re_result.result))
19    {
20        ParseFailure* failure = new ParseFailure("Junk remaining!");
21
22        return failure;
23    }
24    else if (ParseFailure* re_failure = dynamic_cast<ParseFailure*>(re_result.result))
25    {
26        return re_failure;
27    }
28    else
29    {
30        return 0;
31    }
32}
33
34parse_result_retVal RE_Parser::parse_re_helper(std::string s)
35{
36    parse_result_retVal result_retVal;
37
38    parse_re_list_retVal af_result = parse_re_alt_form_list(s);
39
40    if (af_result.re_list.size() == 0)
41    {
42        result_retVal.result = new ParseFailure("No regular expression found!");
43        result_retVal.remaining = s;
44    }
45    else if (af_result.re_list.size() == 1)
46    {
47        result_retVal.result = new ParseSuccess(af_result.re_list.front());
48        result_retVal.remaining = af_result.remaining;
49    }
50    else
51    {
52        result_retVal.result = new ParseSuccess(new Alt(&af_result.re_list));
53        result_retVal.remaining = af_result.remaining;
54    }
55
56    return result_retVal;
57}
58
59parse_re_list_retVal RE_Parser::parse_re_alt_form_list(std::string s)
60{
61    parse_re_list_retVal re_list_retVal;
62    parse_result_retVal form_result = parse_re_form(s);
63
64    if (ParseSuccess* re_success = dynamic_cast<ParseSuccess*>(form_result.result))
65    {
66        if (form_result.remaining.operator [](0) == '|')
67        {           
68            parse_re_list_retVal t1_re_list_retVal =
69                    parse_re_alt_form_list(form_result.remaining.substr(1, form_result.remaining.length() - 1));
70            std::list<RE*>::iterator it;
71            it=t1_re_list_retVal.re_list.begin();
72            re_list_retVal.re_list.assign(it, t1_re_list_retVal.re_list.end());
73            re_list_retVal.remaining = t1_re_list_retVal.remaining;
74        }
75        else
76        {
77            re_list_retVal.remaining = form_result.remaining;
78        }
79        re_list_retVal.re_list.push_back(re_success->getRE());
80    }
81    else
82    {
83        re_list_retVal.re_list.clear();
84        re_list_retVal.remaining = s;
85    }
86
87    return re_list_retVal;
88}
89
90parse_result_retVal RE_Parser::parse_re_form(std::string s)
91{
92    parse_result_retVal form_retVal;
93    parse_re_list_retVal item_list_result = parse_re_item_list(s);
94
95    if (item_list_result.re_list.size() == 0)
96    {
97        form_retVal.result = new ParseFailure("No Regular Expression Found!");
98        form_retVal.remaining = s;
99    }
100    else if (item_list_result.re_list.size() == 1)
101    {
102        form_retVal.result = new ParseSuccess(item_list_result.re_list.front());
103        form_retVal.remaining = item_list_result.remaining;
104    }
105    else
106    {
107        form_retVal.result = new ParseSuccess(new Seq(&item_list_result.re_list));
108        form_retVal.remaining = item_list_result.remaining;
109    }
110
111    return form_retVal;
112}
113
114parse_re_list_retVal RE_Parser::parse_re_item_list(std::string s)
115{
116    parse_re_list_retVal item_list_retVal;
117    parse_result_retVal item_result = parse_re_item(s);
118
119    if (ParseSuccess* re_success = dynamic_cast<ParseSuccess*>(item_result.result))
120    {
121        parse_re_list_retVal t1_item_list_retVal = parse_re_item_list(item_result.remaining);
122
123        std::list<RE*>::iterator it;
124        it=t1_item_list_retVal.re_list.begin();
125        item_list_retVal.re_list.assign(it, t1_item_list_retVal.re_list.end());
126        item_list_retVal.re_list.push_back(re_success->getRE());
127        item_list_retVal.remaining = t1_item_list_retVal.remaining;
128    }
129    else
130    {
131        item_list_retVal.re_list.clear();
132        item_list_retVal.remaining = s;
133    }
134
135    return item_list_retVal;
136}
137
138parse_result_retVal RE_Parser::parse_re_item(std::string s)
139{
140    parse_result_retVal item_retVal;
141    parse_result_retVal unit_result = parse_re_unit(s);
142
143    if (ParseSuccess* re_success = dynamic_cast<ParseSuccess*>(unit_result.result))
144    {
145        item_retVal = extend_item(re_success->getRE(), unit_result.remaining);
146    }
147    else
148    {
149        item_retVal.result = new ParseFailure("Parse item failure!");
150        item_retVal.remaining = s;
151    }
152
153    return item_retVal;
154}
155
156parse_result_retVal RE_Parser::parse_re_unit(std::string s)
157{
158    parse_result_retVal unit_retVal;
159
160    if (s.length() == 0)
161    {
162        unit_retVal.result = new ParseFailure("Incomplete regular expression! (parse_re_unit)");
163        unit_retVal.remaining = "";
164    }
165    else if (s.operator[](0) == '(')
166    {
167        parse_result_retVal t1_unit_retVal = parse_re_helper(s.substr(1, s.length() - 1));
168        ParseSuccess* success = dynamic_cast<ParseSuccess*>(t1_unit_retVal.result);
169        if ((success != 0) && (t1_unit_retVal.remaining.operator[](0) == ')'))
170        {
171            unit_retVal.result = success;
172            unit_retVal.remaining = t1_unit_retVal.remaining.substr(1, t1_unit_retVal.remaining.length() - 1);
173        }
174        else
175        {
176            unit_retVal.result = new ParseFailure("Bad parenthesized RE!");
177            unit_retVal.remaining = s.substr(1, s.length() - 1);
178        }
179    }
180    else if (s.operator [](0) == '^')
181    {
182        unit_retVal.result = new ParseSuccess(new Start);
183        unit_retVal.remaining = s.substr(1, s.length() - 1);
184    }
185    else if (s.operator[](0) == '$')
186    {
187        unit_retVal.result = new ParseSuccess(new End);
188        unit_retVal.remaining = s.substr(1, s.length() - 1);
189    }
190    else
191    {
192        unit_retVal = parse_cc(s);
193    }
194
195    return unit_retVal;
196}
197
198parse_result_retVal RE_Parser::extend_item(RE *re, std::string s)
199{
200     parse_result_retVal extend_item_retVal;
201
202     if (s.operator [](0) == '*')
203     {
204         return extend_item(new Rep(re, 0, unboundedRep), s.substr(1, s.length() - 1));
205     }
206     else if (s.operator[](0) == '?')
207     {
208         return extend_item(new Rep(re, 0, 1), s.substr(1, s.length() - 1));
209     }
210     else if (s.operator[](0) == '+')
211     {
212         return extend_item(new Rep(re, 1, unboundedRep), s.substr(1, s.length() - 1));
213     }
214     else if (s.operator[](0) == '{')
215     {
216        parse_int_retVal int_retVal = parse_int(s.substr(1, s.length() - 1));
217
218        if ((int_retVal.i != -1) && (int_retVal.remaining.operator [](0) == '}'))
219        {
220            extend_item_retVal =
221                    extend_item(new Rep(re, int_retVal.i, int_retVal.i), int_retVal.remaining.substr(1, int_retVal.remaining.length() - 1));
222
223        }
224        else if ((int_retVal.i != -1) && ((int_retVal.remaining.operator [](0) == ',') && (int_retVal.remaining.operator [](1) == '}')))
225        {
226            extend_item_retVal =
227                    extend_item(new Rep(re, int_retVal.i, unboundedRep), int_retVal.remaining.substr(2, int_retVal.remaining.length() - 2));
228
229        }
230        else if ((int_retVal.i != -1) && (int_retVal.remaining.operator [](0) == ','))
231        {
232            parse_int_retVal t1_int_retVal = parse_int(int_retVal.remaining.substr(1, int_retVal.remaining.length() - 1));
233
234            if ((t1_int_retVal.i != -1) && (t1_int_retVal.remaining.operator [](0) == '}'))
235            {
236                extend_item_retVal =
237                        extend_item(new Rep(re, int_retVal.i, t1_int_retVal.i), t1_int_retVal.remaining.substr(1, t1_int_retVal.remaining.length() - 1));
238            }
239            else
240            {
241                extend_item_retVal.result = new ParseFailure("Bad upper bound!");
242                extend_item_retVal.remaining = int_retVal.remaining.substr(1, int_retVal.remaining.length() - 1);
243            }
244        }
245        else
246        {
247            extend_item_retVal.result = new ParseFailure("Bad lower bound!");
248            extend_item_retVal.remaining = s.substr(1, s.length() - 1);
249        }
250     }
251     else
252     {
253         extend_item_retVal.result = new ParseSuccess(re);
254         extend_item_retVal.remaining = s;
255     }
256
257     return extend_item_retVal;
258}
259
260parse_result_retVal RE_Parser::parse_cc(std::string s)
261{
262    parse_result_retVal cc_retVal;
263
264    if (s.operator [](0) == '\\')
265    {
266        if (s.operator [](1) == '?')
267        {
268            cc_retVal.result = new ParseSuccess(new CC('?'));
269        }
270        else if (s.operator [](1) == '+')
271        {
272            cc_retVal.result = new ParseSuccess(new CC('+'));
273        }
274        else if (s.operator [](1) == '*')
275        {
276            cc_retVal.result = new ParseSuccess(new CC('*'));
277        }
278        else if (s.operator [](1) == '(')
279        {
280            cc_retVal.result = new ParseSuccess(new CC('('));
281        }
282        else if (s.operator [](1) == ')')
283        {
284            cc_retVal.result = new ParseSuccess(new CC(')'));
285        }
286        else if (s.operator [](1) == '{')
287        {
288            cc_retVal.result = new ParseSuccess(new CC('{'));
289        }
290        else if (s.operator [](1) == '}')
291        {
292            cc_retVal.result = new ParseSuccess(new CC('}'));
293        }
294        else if (s.operator [](1) == '[')
295        {
296            cc_retVal.result = new ParseSuccess(new CC('['));
297        }
298        else if (s.operator [](1) == ']')
299        {
300            cc_retVal.result = new ParseSuccess(new CC(']'));
301        }
302        else if (s.operator [](1) == '|')
303        {
304            cc_retVal.result = new ParseSuccess(new CC('|'));
305        }
306        else if (s.operator [](1) == '.')
307        {
308            cc_retVal.result = new ParseSuccess(new CC('.'));
309        }
310        else if (s.operator [](1) == '\\')
311        {
312            cc_retVal.result = new ParseSuccess(new CC('\\'));
313        }
314        else if (s.operator [](1) == 'u')
315        {
316            parse_int_retVal hex_val = parse_hex(s.substr(2, s.length() - 2));
317
318            if (hex_val.i == -1)
319            {
320                cc_retVal.result = new ParseFailure("Bad Unicode hex notation!");
321                cc_retVal.remaining = hex_val.remaining;
322            }
323            else
324            {
325                cc_retVal.result = new ParseSuccess(new CC(hex_val.i));
326                cc_retVal.remaining = hex_val.remaining;
327            }
328
329            return cc_retVal;
330        }
331        else if (s.operator [](1) == 'p')
332        {
333            return cc_retVal = parse_unicode_category(s.substr(2, s.length() - 2));
334        }
335        else
336        {
337            cc_retVal.result = new ParseFailure("Illegal backslash escape!");
338            cc_retVal.remaining = s.substr(1, s.length() - 1);
339
340            return cc_retVal;
341        }
342
343        cc_retVal.remaining = s.substr(2, s.length() - 2);
344
345        return cc_retVal;
346    }
347
348    if (s.operator [](0) == '.')
349    {       
350        CC* cc = new CC();
351        cc->insert_range(0, 9);
352        cc->insert_range(11, 127);
353        cc_retVal.result = new ParseSuccess(cc);
354        cc_retVal.remaining = s.substr(1, s.length() - 1);
355
356        return cc_retVal;
357    }
358
359    if (s.operator [](0) == '[')
360    {
361        if (s.operator[](1) == '^')
362        {
363            cc_retVal = negate_cc_result(parse_cc_body(s.substr(2, s.length() - 2)));
364        }
365        else
366        {
367            cc_retVal = parse_cc_body(s.substr(1, s.length() - 1));
368        }
369
370        return cc_retVal;
371    }
372
373    std::string metacharacters = "?+*(){}[]|";
374    std::string c = s.substr(0,1);
375
376    if (metacharacters.find(c) == std::string::npos)
377    {
378        cc_retVal.result = new ParseSuccess(new CC(s.operator [](0)));
379        cc_retVal.remaining = s.substr(1, s.length() - 1);
380    }
381    else
382    {
383        cc_retVal.result = new ParseFailure("Metacharacter alone!");
384        cc_retVal.remaining = s;
385    }
386
387    int next_byte = (s.operator [](0) & 0xFF);
388    if ((next_byte >= 0xC0) && (next_byte <= 0xDF))
389    {       
390        cc_retVal = parse_utf8_bytes(1, s);
391    }
392    else if ((next_byte >= 0xE0) && (next_byte <= 0xEF))
393    {
394        cc_retVal = parse_utf8_bytes(2, s);
395    }
396    else if((next_byte >= 0xF0) && (next_byte <= 0xFF))
397    {
398        cc_retVal = parse_utf8_bytes(3, s);
399    }
400
401    return cc_retVal;
402}
403
404parse_result_retVal RE_Parser::parse_utf8_bytes(int suffix_count, std::string s)
405{
406    CC* cc = new CC((s.operator [](0) & 0xFF));
407    Seq* seq = new Seq();
408    seq->setType(Seq::Byte);
409    seq->AddREListItem(cc);
410
411    return parse_utf8_suffix_byte(suffix_count, s.substr(1, s.length() - 1), seq);
412}
413
414parse_result_retVal RE_Parser::parse_utf8_suffix_byte(int suffix_byte_num, std::string s, Seq *seq_sofar)
415{
416    parse_result_retVal result_RetVal;
417
418    if (suffix_byte_num == 0)
419    {
420        result_RetVal.result = new ParseSuccess(seq_sofar);
421        result_RetVal.remaining = s;
422    }
423    else if (s.length() == 0)
424    {
425        result_RetVal.result = new ParseFailure("Invalid UTF-8 encoding!");
426        result_RetVal.remaining = "";
427    }
428    else
429    {
430        if ((s.operator [](0) & 0xC0) == 0x80)
431        {
432            CC* cc = new CC((s.operator [](0) & 0xFF));
433            seq_sofar->AddREListItem(cc);
434            suffix_byte_num--;
435            result_RetVal = parse_utf8_suffix_byte(suffix_byte_num, s.substr(1, s.length() - 1), seq_sofar);
436        }
437        else
438        {
439            result_RetVal.result = new ParseFailure("Invalid UTF-8 encoding!");
440            result_RetVal.remaining = s;
441        }
442    }
443
444    return result_RetVal;
445}
446
447parse_result_retVal RE_Parser::parse_unicode_category(std::string s)
448{
449    parse_result_retVal result_retVal;
450
451    if (s.operator [](0) == '{')
452    {
453        Name* name = new Name();
454        result_retVal = parse_unicode_category1(s.substr(1,1), s.substr(2, s.length() - 2), name);
455    }
456    else
457    {
458        result_retVal.result = new ParseFailure("Incorrect Unicode character class format!");
459        result_retVal.remaining = "";
460    }
461
462    return result_retVal;
463}
464
465parse_result_retVal RE_Parser::parse_unicode_category1(std::string character, std::string s, Name* name_sofar)
466{
467    parse_result_retVal unicode_cat1_retVal;
468
469    if (s.length() == 0)
470    {
471        delete name_sofar;
472        unicode_cat1_retVal.result = new ParseFailure("Unclosed Unicode character class!");
473        unicode_cat1_retVal.remaining = "";
474    }
475    else if (s.operator [](0) == '}')
476    {
477        name_sofar->setName(name_sofar->getName() + character);
478        if (isValidUnicodeCategoryName(name_sofar))
479        {
480            unicode_cat1_retVal.result = new ParseSuccess(name_sofar);
481            unicode_cat1_retVal.remaining = s.substr(1, s.length() - 1);
482        }
483        else
484        {
485            unicode_cat1_retVal.result = new ParseFailure("Unknown Unicode character class!");
486            unicode_cat1_retVal.remaining = s.substr(1, s.length() - 1);
487        }
488    }
489    else
490    {
491        name_sofar->setName(name_sofar->getName() + character);
492        unicode_cat1_retVal = parse_unicode_category1(s.substr(0,1), s.substr(1, s.length() - 1), name_sofar);
493    }
494
495    return unicode_cat1_retVal;
496}
497
498parse_result_retVal RE_Parser::parse_cc_body(std::string s)
499{
500    parse_result_retVal result_retVal;
501
502    if (s.length() == 0)
503    {
504        result_retVal.result = new ParseFailure("Unclosed character class!");
505        result_retVal.remaining = "";
506    }
507    else
508    {
509        CC* cc = new CC();
510        result_retVal = parse_cc_body1(s.operator [](0), s.substr(1, s.length() - 1), cc);
511    }
512
513    return result_retVal;
514}
515
516parse_result_retVal RE_Parser::parse_cc_body0(std::string s, CC* cc_sofar)
517{
518    parse_result_retVal cc_body0_retVal;
519
520    if (s.length() == 0)
521    {
522        delete cc_sofar;
523        cc_body0_retVal.result = new ParseFailure("Unclosed character class!");
524        cc_body0_retVal.remaining = "";
525    }
526    else if (s.operator [](0) == ']')
527    {
528        cc_body0_retVal.result = new ParseSuccess(cc_sofar);
529        cc_body0_retVal.remaining = s.substr(1, s.length() - 1);
530    }
531    else if ((s.operator [](0) == '-') && (s.operator [](1) == ']'))
532    {
533        cc_sofar->insert1('-');
534        cc_body0_retVal.result = new ParseSuccess(cc_sofar);
535        cc_body0_retVal.remaining = s.substr(2, s.length() - 2);
536    }
537    else if (s.operator [](0) == '-')
538    {
539        delete cc_sofar;
540        cc_body0_retVal.result = new ParseFailure("Bad range in character class!");
541        cc_body0_retVal.remaining = s.substr(1, s.length() - 1);
542    }
543    else
544    {
545        cc_body0_retVal = parse_cc_body1(s.operator [](0), s.substr(1, s.length() - 1), cc_sofar);
546    }
547
548    return cc_body0_retVal;
549}
550
551parse_result_retVal RE_Parser::parse_cc_body1(int chr, std::string s, CC* cc_sofar)
552{
553    parse_result_retVal cc_body1_retVal;
554
555    if (s.length() == 0)
556    {
557        delete cc_sofar;
558        cc_body1_retVal.result = new ParseFailure("Unclosed character class!");
559        cc_body1_retVal.remaining = "";
560    }
561    else if (s.operator [](0) == ']')
562    {
563        cc_sofar->insert1(chr);
564        cc_body1_retVal.result = new ParseSuccess(cc_sofar);
565        cc_body1_retVal.remaining = s.substr(1, s.length() - 1);
566    }
567    else if (s.length() == 1)
568    {
569        delete cc_sofar;
570        cc_body1_retVal.result = new ParseFailure("Unclosed character class!");
571        cc_body1_retVal.remaining = "";
572    }
573    else if ((s.operator [](0) == '-') && (s.operator [](1) == ']'))
574    {
575        cc_sofar->insert1(chr);
576        cc_sofar->insert1('-');
577        cc_body1_retVal = parse_cc_body0(s, cc_sofar);
578    }
579    else if ((s.operator [](0) == '-') && (s.operator [](1) == '\\') && (s.operator [](2) == 'u'))
580    {
581        parse_int_retVal int_retVal = parse_hex(s.substr(3, s.length() - 3));
582
583        if (int_retVal.i == -1)
584        {
585            cc_body1_retVal.result = new ParseFailure("Bad Unicode hex notation!");
586            cc_body1_retVal.remaining = "";
587        }
588        else
589        {
590            cc_sofar->insert_range(chr, int_retVal.i);
591            cc_body1_retVal = parse_cc_body0(int_retVal.remaining, cc_sofar);
592        }
593    }
594    else if ((s.operator [](0) == '-') && ( s.length() > 1))
595    {
596        cc_sofar->insert_range(chr, s.operator [](1));
597        cc_body1_retVal = parse_cc_body0(s.substr(2, s.length() - 2), cc_sofar);
598    }
599    else if ((s.operator [](0) == 'u') && ( s.length() > 1))
600    {
601        parse_int_retVal int_retVal = parse_hex(s.substr(1, s.length() - 1));
602
603        if (int_retVal.i == -1)
604        {
605            cc_body1_retVal.result = new ParseFailure("Bad Unicode hex notation!");
606            cc_body1_retVal.remaining = "";
607        }
608        else
609        {
610            cc_body1_retVal = parse_cc_body1(int_retVal.i, int_retVal.remaining, cc_sofar);
611        }
612    }
613    else
614    {
615        cc_sofar->insert1(chr);
616        cc_body1_retVal = parse_cc_body1(s.operator [](0), s.substr(1, s.length() - 1), cc_sofar);
617    }
618
619    return cc_body1_retVal;
620}
621
622parse_int_retVal RE_Parser::parse_hex(std::string s)
623{
624    parse_int_retVal int_retVal;
625
626    if (s.operator [](0) == '{')
627    {
628        int hexval_sofar = 0;
629        int_retVal = parse_hex_body(hexval_sofar, s.substr(1, s.length() - 1));
630    }
631    else
632    {
633        int_retVal.i = -1;
634        int_retVal.remaining = s;
635    }
636
637    return int_retVal;
638}
639
640parse_int_retVal RE_Parser::parse_hex_body(int i, std::string s)
641{
642    parse_int_retVal int_retVal;
643
644    if (s.length() == 0)
645    {
646        int_retVal.i = i;
647        int_retVal.remaining = "";
648    }
649    else if (s.operator [](0) == '}')
650    {
651        int_retVal.i = i;
652        int_retVal.remaining = s.substr(1, s.length() - 1);
653    }
654    else if ((s.operator [](0) >= '0') && (s.operator [](0) <= '9'))
655    {
656        int_retVal = parse_hex_body(parse_hex_body1(i, s.substr(0,1)), s.substr(1, s.length() - 1));
657    }
658    else if ((s.operator [](0) >= 'a') && (s.operator [](0) <= 'f'))
659    {
660        int_retVal = parse_hex_body(parse_hex_body1(i, s.substr(0,1)), s.substr(1, s.length() - 1));
661    }
662    else if ((s.operator [](0) >= 'A') && (s.operator [](0) <= 'F'))
663    {
664        int_retVal = parse_hex_body(parse_hex_body1(i, s.substr(0,1)), s.substr(1, s.length() - 1));
665    }
666    else
667    {
668        int_retVal.i = -1;
669        int_retVal.remaining = s;
670    }
671
672    return int_retVal;
673}
674
675int RE_Parser::parse_hex_body1(int i, std::string hex_str)
676{
677    int retVal = 0;
678    int newVal = 0;
679
680    retVal = i << 4;
681
682    std::stringstream ss(hex_str);
683    ss >> std::hex >> newVal;
684
685    retVal = retVal | newVal;
686
687    return retVal;
688}
689
690parse_int_retVal RE_Parser::parse_int(std::string s)
691{
692    parse_int_retVal int_retVal;
693
694    if (isdigit(s.operator [](0)))
695    {
696        int_retVal = parse_int1(s.operator [](0) - 48, s.substr(1, s.length() - 1));
697    }
698    else
699    {
700        int_retVal.i = -1;
701        int_retVal.remaining = s;
702    }
703
704    return int_retVal;
705}
706
707parse_int_retVal RE_Parser::parse_int1(int i, std::string s)
708{
709    parse_int_retVal int1_retVal;
710
711    if (s.length() == 0)
712    {
713        int1_retVal.i = i;
714        int1_retVal.remaining = "";
715    }
716    else if (isdigit(s.operator [](0)))
717    {
718        int1_retVal = parse_int1(i * 10 + (s.operator [](0) - 48), s.substr(1, s.length() - 1));
719    }
720    else
721    {
722        int1_retVal.i = i;
723        int1_retVal.remaining = s;
724    }
725
726    return int1_retVal;
727}
728
729parse_result_retVal RE_Parser::negate_cc_result(parse_result_retVal cc_result)
730{
731    if (ParseSuccess* success = dynamic_cast<ParseSuccess*>(cc_result.result))
732    {
733        if (CC* cc = dynamic_cast<CC*>(success->getRE()))
734        {
735            cc->negate_class();
736            //Remove any new-line.
737            cc->remove1(10);
738        }
739    }
740
741    return cc_result;
742}
743
744bool RE_Parser::isValidUnicodeCategoryName(Name* name)
745{
746    std::string cat_name = name->getName();
747
748    if (cat_name == "Cc")
749        return true;
750    else if (cat_name == "Cf")
751        return true;
752    else if (cat_name == "Cn")
753        return true;
754    else if (cat_name == "Co")
755        return true;
756    else if (cat_name == "Cs")
757        return true;
758    else if (cat_name == "C")
759        return true;
760    else if (cat_name == "Ll")
761        return true;
762    else if (cat_name == "Lt")
763        return true;
764    else if (cat_name == "Lu")
765        return true;
766    else if (cat_name == "L&")
767        return true;
768    else if (cat_name == "Lc")
769        return true;
770    else if (cat_name == "Lm")
771        return true;
772    else if (cat_name == "Lo")
773        return true;
774    else if (cat_name == "L")
775        return true;
776    else if (cat_name == "Mc")
777        return true;
778    else if (cat_name == "Me")
779        return true;
780    else if (cat_name == "Mn")
781        return true;
782    else if (cat_name == "M")
783        return true;
784    else if (cat_name == "Nd")
785        return true;
786    else if (cat_name == "Nl")
787        return true;
788    else if (cat_name == "No")
789        return true;
790    else if (cat_name == "N")
791        return true;
792    else if (cat_name == "Pc")
793        return true;
794    else if (cat_name == "Pd")
795        return true;
796    else if (cat_name == "Pe")
797        return true;
798    else if (cat_name == "Pf")
799        return true;
800    else if (cat_name == "Pi")
801        return true;
802    else if (cat_name == "Po")
803        return true;
804    else if (cat_name == "Ps")
805        return true;
806    else if (cat_name == "P")
807        return true;
808    else if (cat_name == "Sc")
809        return true;
810    else if (cat_name == "Sk")
811        return true;
812    else if (cat_name == "Sm")
813        return true;
814    else if (cat_name == "So")
815        return true;
816    else if (cat_name == "S")
817        return true;
818    else if (cat_name == "Zl")
819        return true;
820    else if (cat_name == "Zp")
821        return true;
822    else if (cat_name == "Zs")
823        return true;
824    else if (cat_name == "Z")
825        return true;
826    else
827        return false;
828}
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
Note: See TracBrowser for help on using the repository browser.