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

Last change on this file since 3994 was 3993, checked in by cameron, 5 years ago

Parse negated classes \P{}

File size: 23.6 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), /* negated = */ false);
334        }
335        else if (s.operator [](1) == 'P')
336        {
337            return cc_retVal = parse_unicode_category(s.substr(2, s.length() - 2), /* negated = */ true);
338        }
339        else
340        {
341            cc_retVal.result = new ParseFailure("Illegal backslash escape!");
342            cc_retVal.remaining = s.substr(1, s.length() - 1);
343
344            return cc_retVal;
345        }
346
347        cc_retVal.remaining = s.substr(2, s.length() - 2);
348
349        return cc_retVal;
350    }
351
352    if (s.operator [](0) == '.')
353    {       
354        CC* cc = new CC();
355        cc->insert_range(0, 9);
356        cc->insert_range(11, 127);
357        cc_retVal.result = new ParseSuccess(cc);
358        cc_retVal.remaining = s.substr(1, s.length() - 1);
359
360        return cc_retVal;
361    }
362
363    if (s.operator [](0) == '[')
364    {
365        if (s.operator[](1) == '^')
366        {
367            cc_retVal = negate_cc_result(parse_cc_body(s.substr(2, s.length() - 2)));
368        }
369        else
370        {
371            cc_retVal = parse_cc_body(s.substr(1, s.length() - 1));
372        }
373
374        return cc_retVal;
375    }
376
377    std::string metacharacters = "?+*(){}[]|";
378    std::string c = s.substr(0,1);
379
380    if (metacharacters.find(c) == std::string::npos)
381    {
382        cc_retVal.result = new ParseSuccess(new CC(s.operator [](0)));
383        cc_retVal.remaining = s.substr(1, s.length() - 1);
384    }
385    else
386    {
387        cc_retVal.result = new ParseFailure("Metacharacter alone!");
388        cc_retVal.remaining = s;
389    }
390
391    int next_byte = (s.operator [](0) & 0xFF);
392
393    if ((next_byte >= 0xC0) && (next_byte <= 0xDF))
394    {       
395        cc_retVal = parse_utf8_bytes(1, s);
396    }
397    else if ((next_byte >= 0xE0) && (next_byte <= 0xEF))
398    {
399        cc_retVal = parse_utf8_bytes(2, s);
400    }
401    else if((next_byte >= 0xF0) && (next_byte <= 0xFF))
402    {
403        cc_retVal = parse_utf8_bytes(3, s);
404    }
405
406    return cc_retVal;
407}
408
409parse_result_retVal RE_Parser::parse_utf8_bytes(int suffix_count, std::string s)
410{
411    CC* cc = new CC((s.operator [](0) & 0xFF));
412    Seq* seq = new Seq();
413    seq->setType(Seq::Byte);
414    seq->AddREListItem(cc);
415
416    return parse_utf8_suffix_byte(suffix_count, s.substr(1, s.length() - 1), seq);
417}
418
419parse_result_retVal RE_Parser::parse_utf8_suffix_byte(int suffix_byte_num, std::string s, Seq *seq_sofar)
420{
421    parse_result_retVal result_RetVal;
422
423    if (suffix_byte_num == 0)
424    {
425        result_RetVal.result = new ParseSuccess(seq_sofar);
426        result_RetVal.remaining = s;
427    }
428    else if (s.length() == 0)
429    {
430        result_RetVal.result = new ParseFailure("Invalid UTF-8 encoding!");
431        result_RetVal.remaining = "";
432    }
433    else
434    {
435        if ((s.operator [](0) & 0xC0) == 0x80)
436        {
437            CC* cc = new CC((s.operator [](0) & 0xFF));
438            seq_sofar->AddREListItem(cc);
439            suffix_byte_num--;
440            result_RetVal = parse_utf8_suffix_byte(suffix_byte_num, s.substr(1, s.length() - 1), seq_sofar);
441        }
442        else
443        {
444            result_RetVal.result = new ParseFailure("Invalid UTF-8 encoding!");
445            result_RetVal.remaining = s;
446        }
447    }
448
449    return result_RetVal;
450}
451
452parse_result_retVal RE_Parser::parse_unicode_category(std::string s, bool negated)
453{
454    parse_result_retVal result_retVal;
455
456    if (s.operator [](0) == '{')
457    {
458        Name* name = new Name();
459        name->setType(Name::UnicodeCategory);
460        name->setNegated(negated);
461        result_retVal = parse_unicode_category1(s.substr(1,1), s.substr(2, s.length() - 2), name);
462    }
463    else
464    {
465        result_retVal.result = new ParseFailure("Incorrect Unicode character class format!");
466        result_retVal.remaining = "";
467    }
468
469    return result_retVal;
470}
471
472parse_result_retVal RE_Parser::parse_unicode_category1(std::string character, std::string s, Name* name_sofar)
473{
474    parse_result_retVal unicode_cat1_retVal;
475
476    if (s.length() == 0)
477    {
478        delete name_sofar;
479        unicode_cat1_retVal.result = new ParseFailure("Unclosed Unicode character class!");
480        unicode_cat1_retVal.remaining = "";
481    }
482    else if (s.operator [](0) == '}')
483    {
484        name_sofar->setName(name_sofar->getName() + character);
485        if (isValidUnicodeCategoryName(name_sofar))
486        {
487            unicode_cat1_retVal.result = new ParseSuccess(name_sofar);
488            unicode_cat1_retVal.remaining = s.substr(1, s.length() - 1);
489        }
490        else
491        {
492            unicode_cat1_retVal.result = new ParseFailure("Unknown Unicode character class!");
493            unicode_cat1_retVal.remaining = s.substr(1, s.length() - 1);
494        }
495    }
496    else
497    {
498        name_sofar->setName(name_sofar->getName() + character);
499        unicode_cat1_retVal = parse_unicode_category1(s.substr(0,1), s.substr(1, s.length() - 1), name_sofar);
500    }
501
502    return unicode_cat1_retVal;
503}
504
505parse_result_retVal RE_Parser::parse_cc_body(std::string s)
506{
507    parse_result_retVal result_retVal;
508
509    if (s.length() == 0)
510    {
511        result_retVal.result = new ParseFailure("Unclosed character class!");
512        result_retVal.remaining = "";
513    }
514    else
515    {
516        CC* cc = new CC();
517        result_retVal = parse_cc_body1(s.operator [](0), s.substr(1, s.length() - 1), cc);
518    }
519
520    return result_retVal;
521}
522
523parse_result_retVal RE_Parser::parse_cc_body0(std::string s, CC* cc_sofar)
524{
525    parse_result_retVal cc_body0_retVal;
526
527    if (s.length() == 0)
528    {
529        delete cc_sofar;
530        cc_body0_retVal.result = new ParseFailure("Unclosed character class!");
531        cc_body0_retVal.remaining = "";
532    }
533    else if (s.operator [](0) == ']')
534    {
535        cc_body0_retVal.result = new ParseSuccess(cc_sofar);
536        cc_body0_retVal.remaining = s.substr(1, s.length() - 1);
537    }
538    else if ((s.operator [](0) == '-') && (s.operator [](1) == ']'))
539    {
540        cc_sofar->insert1('-');
541        cc_body0_retVal.result = new ParseSuccess(cc_sofar);
542        cc_body0_retVal.remaining = s.substr(2, s.length() - 2);
543    }
544    else if (s.operator [](0) == '-')
545    {
546        delete cc_sofar;
547        cc_body0_retVal.result = new ParseFailure("Bad range in character class!");
548        cc_body0_retVal.remaining = s.substr(1, s.length() - 1);
549    }
550    else
551    {
552        cc_body0_retVal = parse_cc_body1(s.operator [](0), s.substr(1, s.length() - 1), cc_sofar);
553    }
554
555    return cc_body0_retVal;
556}
557
558parse_result_retVal RE_Parser::parse_cc_body1(int chr, std::string s, CC* cc_sofar)
559{
560    parse_result_retVal cc_body1_retVal;
561
562    if (s.length() == 0)
563    {
564        delete cc_sofar;
565        cc_body1_retVal.result = new ParseFailure("Unclosed character class!");
566        cc_body1_retVal.remaining = "";
567    }
568    else if (s.operator [](0) == ']')
569    {
570        cc_sofar->insert1(chr);
571        cc_body1_retVal.result = new ParseSuccess(cc_sofar);
572        cc_body1_retVal.remaining = s.substr(1, s.length() - 1);
573    }
574    else if (s.length() == 1)
575    {
576        delete cc_sofar;
577        cc_body1_retVal.result = new ParseFailure("Unclosed character class!");
578        cc_body1_retVal.remaining = "";
579    }
580    else if ((s.operator [](0) == '-') && (s.operator [](1) == ']'))
581    {
582        cc_sofar->insert1(chr);
583        cc_sofar->insert1('-');
584        cc_body1_retVal = parse_cc_body0(s, cc_sofar);
585    }
586    else if ((s.operator [](0) == '-') && (s.operator [](1) == '\\') && (s.operator [](2) == 'u'))
587    {
588        parse_int_retVal int_retVal = parse_hex(s.substr(3, s.length() - 3));
589
590        if (int_retVal.i == -1)
591        {
592            cc_body1_retVal.result = new ParseFailure("Bad Unicode hex notation!");
593            cc_body1_retVal.remaining = "";
594        }
595        else
596        {
597            cc_sofar->insert_range(chr, int_retVal.i);
598            cc_body1_retVal = parse_cc_body0(int_retVal.remaining, cc_sofar);
599        }
600    }
601    else if ((s.operator [](0) == '-') && ( s.length() > 1))
602    {
603        cc_sofar->insert_range(chr, s.operator [](1));
604        cc_body1_retVal = parse_cc_body0(s.substr(2, s.length() - 2), cc_sofar);
605    }
606    else if ((s.operator [](0) == 'u') && ( s.length() > 1))
607    {
608        parse_int_retVal int_retVal = parse_hex(s.substr(1, s.length() - 1));
609
610        if (int_retVal.i == -1)
611        {
612            cc_body1_retVal.result = new ParseFailure("Bad Unicode hex notation!");
613            cc_body1_retVal.remaining = "";
614        }
615        else
616        {
617            cc_body1_retVal = parse_cc_body1(int_retVal.i, int_retVal.remaining, cc_sofar);
618        }
619    }
620    else
621    {
622        cc_sofar->insert1(chr);
623        cc_body1_retVal = parse_cc_body1(s.operator [](0), s.substr(1, s.length() - 1), cc_sofar);
624    }
625
626    return cc_body1_retVal;
627}
628
629parse_int_retVal RE_Parser::parse_hex(std::string s)
630{
631    parse_int_retVal int_retVal;
632
633    if (s.operator [](0) == '{')
634    {
635        int hexval_sofar = 0;
636        int_retVal = parse_hex_body(hexval_sofar, s.substr(1, s.length() - 1));
637    }
638    else
639    {
640        int_retVal.i = -1;
641        int_retVal.remaining = s;
642    }
643
644    return int_retVal;
645}
646
647parse_int_retVal RE_Parser::parse_hex_body(int i, std::string s)
648{
649    parse_int_retVal int_retVal;
650
651    if (s.length() == 0)
652    {
653        int_retVal.i = i;
654        int_retVal.remaining = "";
655    }
656    else if (s.operator [](0) == '}')
657    {
658        int_retVal.i = i;
659        int_retVal.remaining = s.substr(1, s.length() - 1);
660    }
661    else if ((s.operator [](0) >= '0') && (s.operator [](0) <= '9'))
662    {
663        int_retVal = parse_hex_body(parse_hex_body1(i, s.substr(0,1)), s.substr(1, s.length() - 1));
664    }
665    else if ((s.operator [](0) >= 'a') && (s.operator [](0) <= 'f'))
666    {
667        int_retVal = parse_hex_body(parse_hex_body1(i, s.substr(0,1)), s.substr(1, s.length() - 1));
668    }
669    else if ((s.operator [](0) >= 'A') && (s.operator [](0) <= 'F'))
670    {
671        int_retVal = parse_hex_body(parse_hex_body1(i, s.substr(0,1)), s.substr(1, s.length() - 1));
672    }
673    else
674    {
675        int_retVal.i = -1;
676        int_retVal.remaining = s;
677    }
678
679    return int_retVal;
680}
681
682int RE_Parser::parse_hex_body1(int i, std::string hex_str)
683{
684    int retVal = 0;
685    int newVal = 0;
686
687    retVal = i << 4;
688
689    std::stringstream ss(hex_str);
690    ss >> std::hex >> newVal;
691
692    retVal = retVal | newVal;
693
694    return retVal;
695}
696
697parse_int_retVal RE_Parser::parse_int(std::string s)
698{
699    parse_int_retVal int_retVal;
700
701    if (isdigit(s.operator [](0)))
702    {
703        int_retVal = parse_int1(s.operator [](0) - 48, s.substr(1, s.length() - 1));
704    }
705    else
706    {
707        int_retVal.i = -1;
708        int_retVal.remaining = s;
709    }
710
711    return int_retVal;
712}
713
714parse_int_retVal RE_Parser::parse_int1(int i, std::string s)
715{
716    parse_int_retVal int1_retVal;
717
718    if (s.length() == 0)
719    {
720        int1_retVal.i = i;
721        int1_retVal.remaining = "";
722    }
723    else if (isdigit(s.operator [](0)))
724    {
725        int1_retVal = parse_int1(i * 10 + (s.operator [](0) - 48), s.substr(1, s.length() - 1));
726    }
727    else
728    {
729        int1_retVal.i = i;
730        int1_retVal.remaining = s;
731    }
732
733    return int1_retVal;
734}
735
736parse_result_retVal RE_Parser::negate_cc_result(parse_result_retVal cc_result)
737{
738    if (ParseSuccess* success = dynamic_cast<ParseSuccess*>(cc_result.result))
739    {
740        if (CC* cc = dynamic_cast<CC*>(success->getRE()))
741        {
742            cc->negate_class();
743            //Remove any new-line.
744            cc->remove1(10);
745        }
746    }
747
748    return cc_result;
749}
750
751bool RE_Parser::isValidUnicodeCategoryName(Name* name)
752{
753    std::string cat_name = name->getName();
754
755    if (cat_name == "Cc")
756        return true;
757    else if (cat_name == "Cf")
758        return true;
759    else if (cat_name == "Cn")
760        return true;
761    else if (cat_name == "Co")
762        return true;
763    else if (cat_name == "Cs")
764        return true;
765    else if (cat_name == "C")
766        return true;
767    else if (cat_name == "Ll")
768        return true;
769    else if (cat_name == "Lt")
770        return true;
771    else if (cat_name == "Lu")
772        return true;
773    else if (cat_name == "L&")
774        return true;
775    else if (cat_name == "Lc")
776        return true;
777    else if (cat_name == "Lm")
778        return true;
779    else if (cat_name == "Lo")
780        return true;
781    else if (cat_name == "L")
782        return true;
783    else if (cat_name == "Mc")
784        return true;
785    else if (cat_name == "Me")
786        return true;
787    else if (cat_name == "Mn")
788        return true;
789    else if (cat_name == "M")
790        return true;
791    else if (cat_name == "Nd")
792        return true;
793    else if (cat_name == "Nl")
794        return true;
795    else if (cat_name == "No")
796        return true;
797    else if (cat_name == "N")
798        return true;
799    else if (cat_name == "Pc")
800        return true;
801    else if (cat_name == "Pd")
802        return true;
803    else if (cat_name == "Pe")
804        return true;
805    else if (cat_name == "Pf")
806        return true;
807    else if (cat_name == "Pi")
808        return true;
809    else if (cat_name == "Po")
810        return true;
811    else if (cat_name == "Ps")
812        return true;
813    else if (cat_name == "P")
814        return true;
815    else if (cat_name == "Sc")
816        return true;
817    else if (cat_name == "Sk")
818        return true;
819    else if (cat_name == "Sm")
820        return true;
821    else if (cat_name == "So")
822        return true;
823    else if (cat_name == "S")
824        return true;
825    else if (cat_name == "Zl")
826        return true;
827    else if (cat_name == "Zp")
828        return true;
829    else if (cat_name == "Zs")
830        return true;
831    else if (cat_name == "Z")
832        return true;
833    else
834        return false;
835}
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
Note: See TracBrowser for help on using the repository browser.