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

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

The framework for the unicode categories is in place. The static c++ code for each of the categories just needs to be placed into the stub unicode categories class.

File size: 23.4 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        name->setType(Name::UnicodeCategory);
455        result_retVal = parse_unicode_category1(s.substr(1,1), s.substr(2, s.length() - 2), name);
456    }
457    else
458    {
459        result_retVal.result = new ParseFailure("Incorrect Unicode character class format!");
460        result_retVal.remaining = "";
461    }
462
463    return result_retVal;
464}
465
466parse_result_retVal RE_Parser::parse_unicode_category1(std::string character, std::string s, Name* name_sofar)
467{
468    parse_result_retVal unicode_cat1_retVal;
469
470    if (s.length() == 0)
471    {
472        delete name_sofar;
473        unicode_cat1_retVal.result = new ParseFailure("Unclosed Unicode character class!");
474        unicode_cat1_retVal.remaining = "";
475    }
476    else if (s.operator [](0) == '}')
477    {
478        name_sofar->setName(name_sofar->getName() + character);
479        if (isValidUnicodeCategoryName(name_sofar))
480        {
481            unicode_cat1_retVal.result = new ParseSuccess(name_sofar);
482            unicode_cat1_retVal.remaining = s.substr(1, s.length() - 1);
483        }
484        else
485        {
486            unicode_cat1_retVal.result = new ParseFailure("Unknown Unicode character class!");
487            unicode_cat1_retVal.remaining = s.substr(1, s.length() - 1);
488        }
489    }
490    else
491    {
492        name_sofar->setName(name_sofar->getName() + character);
493        unicode_cat1_retVal = parse_unicode_category1(s.substr(0,1), s.substr(1, s.length() - 1), name_sofar);
494    }
495
496    return unicode_cat1_retVal;
497}
498
499parse_result_retVal RE_Parser::parse_cc_body(std::string s)
500{
501    parse_result_retVal result_retVal;
502
503    if (s.length() == 0)
504    {
505        result_retVal.result = new ParseFailure("Unclosed character class!");
506        result_retVal.remaining = "";
507    }
508    else
509    {
510        CC* cc = new CC();
511        result_retVal = parse_cc_body1(s.operator [](0), s.substr(1, s.length() - 1), cc);
512    }
513
514    return result_retVal;
515}
516
517parse_result_retVal RE_Parser::parse_cc_body0(std::string s, CC* cc_sofar)
518{
519    parse_result_retVal cc_body0_retVal;
520
521    if (s.length() == 0)
522    {
523        delete cc_sofar;
524        cc_body0_retVal.result = new ParseFailure("Unclosed character class!");
525        cc_body0_retVal.remaining = "";
526    }
527    else if (s.operator [](0) == ']')
528    {
529        cc_body0_retVal.result = new ParseSuccess(cc_sofar);
530        cc_body0_retVal.remaining = s.substr(1, s.length() - 1);
531    }
532    else if ((s.operator [](0) == '-') && (s.operator [](1) == ']'))
533    {
534        cc_sofar->insert1('-');
535        cc_body0_retVal.result = new ParseSuccess(cc_sofar);
536        cc_body0_retVal.remaining = s.substr(2, s.length() - 2);
537    }
538    else if (s.operator [](0) == '-')
539    {
540        delete cc_sofar;
541        cc_body0_retVal.result = new ParseFailure("Bad range in character class!");
542        cc_body0_retVal.remaining = s.substr(1, s.length() - 1);
543    }
544    else
545    {
546        cc_body0_retVal = parse_cc_body1(s.operator [](0), s.substr(1, s.length() - 1), cc_sofar);
547    }
548
549    return cc_body0_retVal;
550}
551
552parse_result_retVal RE_Parser::parse_cc_body1(int chr, std::string s, CC* cc_sofar)
553{
554    parse_result_retVal cc_body1_retVal;
555
556    if (s.length() == 0)
557    {
558        delete cc_sofar;
559        cc_body1_retVal.result = new ParseFailure("Unclosed character class!");
560        cc_body1_retVal.remaining = "";
561    }
562    else if (s.operator [](0) == ']')
563    {
564        cc_sofar->insert1(chr);
565        cc_body1_retVal.result = new ParseSuccess(cc_sofar);
566        cc_body1_retVal.remaining = s.substr(1, s.length() - 1);
567    }
568    else if (s.length() == 1)
569    {
570        delete cc_sofar;
571        cc_body1_retVal.result = new ParseFailure("Unclosed character class!");
572        cc_body1_retVal.remaining = "";
573    }
574    else if ((s.operator [](0) == '-') && (s.operator [](1) == ']'))
575    {
576        cc_sofar->insert1(chr);
577        cc_sofar->insert1('-');
578        cc_body1_retVal = parse_cc_body0(s, cc_sofar);
579    }
580    else if ((s.operator [](0) == '-') && (s.operator [](1) == '\\') && (s.operator [](2) == 'u'))
581    {
582        parse_int_retVal int_retVal = parse_hex(s.substr(3, s.length() - 3));
583
584        if (int_retVal.i == -1)
585        {
586            cc_body1_retVal.result = new ParseFailure("Bad Unicode hex notation!");
587            cc_body1_retVal.remaining = "";
588        }
589        else
590        {
591            cc_sofar->insert_range(chr, int_retVal.i);
592            cc_body1_retVal = parse_cc_body0(int_retVal.remaining, cc_sofar);
593        }
594    }
595    else if ((s.operator [](0) == '-') && ( s.length() > 1))
596    {
597        cc_sofar->insert_range(chr, s.operator [](1));
598        cc_body1_retVal = parse_cc_body0(s.substr(2, s.length() - 2), cc_sofar);
599    }
600    else if ((s.operator [](0) == 'u') && ( s.length() > 1))
601    {
602        parse_int_retVal int_retVal = parse_hex(s.substr(1, s.length() - 1));
603
604        if (int_retVal.i == -1)
605        {
606            cc_body1_retVal.result = new ParseFailure("Bad Unicode hex notation!");
607            cc_body1_retVal.remaining = "";
608        }
609        else
610        {
611            cc_body1_retVal = parse_cc_body1(int_retVal.i, int_retVal.remaining, cc_sofar);
612        }
613    }
614    else
615    {
616        cc_sofar->insert1(chr);
617        cc_body1_retVal = parse_cc_body1(s.operator [](0), s.substr(1, s.length() - 1), cc_sofar);
618    }
619
620    return cc_body1_retVal;
621}
622
623parse_int_retVal RE_Parser::parse_hex(std::string s)
624{
625    parse_int_retVal int_retVal;
626
627    if (s.operator [](0) == '{')
628    {
629        int hexval_sofar = 0;
630        int_retVal = parse_hex_body(hexval_sofar, s.substr(1, s.length() - 1));
631    }
632    else
633    {
634        int_retVal.i = -1;
635        int_retVal.remaining = s;
636    }
637
638    return int_retVal;
639}
640
641parse_int_retVal RE_Parser::parse_hex_body(int i, std::string s)
642{
643    parse_int_retVal int_retVal;
644
645    if (s.length() == 0)
646    {
647        int_retVal.i = i;
648        int_retVal.remaining = "";
649    }
650    else if (s.operator [](0) == '}')
651    {
652        int_retVal.i = i;
653        int_retVal.remaining = s.substr(1, s.length() - 1);
654    }
655    else if ((s.operator [](0) >= '0') && (s.operator [](0) <= '9'))
656    {
657        int_retVal = parse_hex_body(parse_hex_body1(i, s.substr(0,1)), s.substr(1, s.length() - 1));
658    }
659    else if ((s.operator [](0) >= 'a') && (s.operator [](0) <= 'f'))
660    {
661        int_retVal = parse_hex_body(parse_hex_body1(i, s.substr(0,1)), s.substr(1, s.length() - 1));
662    }
663    else if ((s.operator [](0) >= 'A') && (s.operator [](0) <= 'F'))
664    {
665        int_retVal = parse_hex_body(parse_hex_body1(i, s.substr(0,1)), s.substr(1, s.length() - 1));
666    }
667    else
668    {
669        int_retVal.i = -1;
670        int_retVal.remaining = s;
671    }
672
673    return int_retVal;
674}
675
676int RE_Parser::parse_hex_body1(int i, std::string hex_str)
677{
678    int retVal = 0;
679    int newVal = 0;
680
681    retVal = i << 4;
682
683    std::stringstream ss(hex_str);
684    ss >> std::hex >> newVal;
685
686    retVal = retVal | newVal;
687
688    return retVal;
689}
690
691parse_int_retVal RE_Parser::parse_int(std::string s)
692{
693    parse_int_retVal int_retVal;
694
695    if (isdigit(s.operator [](0)))
696    {
697        int_retVal = parse_int1(s.operator [](0) - 48, s.substr(1, s.length() - 1));
698    }
699    else
700    {
701        int_retVal.i = -1;
702        int_retVal.remaining = s;
703    }
704
705    return int_retVal;
706}
707
708parse_int_retVal RE_Parser::parse_int1(int i, std::string s)
709{
710    parse_int_retVal int1_retVal;
711
712    if (s.length() == 0)
713    {
714        int1_retVal.i = i;
715        int1_retVal.remaining = "";
716    }
717    else if (isdigit(s.operator [](0)))
718    {
719        int1_retVal = parse_int1(i * 10 + (s.operator [](0) - 48), s.substr(1, s.length() - 1));
720    }
721    else
722    {
723        int1_retVal.i = i;
724        int1_retVal.remaining = s;
725    }
726
727    return int1_retVal;
728}
729
730parse_result_retVal RE_Parser::negate_cc_result(parse_result_retVal cc_result)
731{
732    if (ParseSuccess* success = dynamic_cast<ParseSuccess*>(cc_result.result))
733    {
734        if (CC* cc = dynamic_cast<CC*>(success->getRE()))
735        {
736            cc->negate_class();
737            //Remove any new-line.
738            cc->remove1(10);
739        }
740    }
741
742    return cc_result;
743}
744
745bool RE_Parser::isValidUnicodeCategoryName(Name* name)
746{
747    std::string cat_name = name->getName();
748
749    if (cat_name == "Cc")
750        return true;
751    else if (cat_name == "Cf")
752        return true;
753    else if (cat_name == "Cn")
754        return true;
755    else if (cat_name == "Co")
756        return true;
757    else if (cat_name == "Cs")
758        return true;
759    else if (cat_name == "C")
760        return true;
761    else if (cat_name == "Ll")
762        return true;
763    else if (cat_name == "Lt")
764        return true;
765    else if (cat_name == "Lu")
766        return true;
767    else if (cat_name == "L&")
768        return true;
769    else if (cat_name == "Lc")
770        return true;
771    else if (cat_name == "Lm")
772        return true;
773    else if (cat_name == "Lo")
774        return true;
775    else if (cat_name == "L")
776        return true;
777    else if (cat_name == "Mc")
778        return true;
779    else if (cat_name == "Me")
780        return true;
781    else if (cat_name == "Mn")
782        return true;
783    else if (cat_name == "M")
784        return true;
785    else if (cat_name == "Nd")
786        return true;
787    else if (cat_name == "Nl")
788        return true;
789    else if (cat_name == "No")
790        return true;
791    else if (cat_name == "N")
792        return true;
793    else if (cat_name == "Pc")
794        return true;
795    else if (cat_name == "Pd")
796        return true;
797    else if (cat_name == "Pe")
798        return true;
799    else if (cat_name == "Pf")
800        return true;
801    else if (cat_name == "Pi")
802        return true;
803    else if (cat_name == "Po")
804        return true;
805    else if (cat_name == "Ps")
806        return true;
807    else if (cat_name == "P")
808        return true;
809    else if (cat_name == "Sc")
810        return true;
811    else if (cat_name == "Sk")
812        return true;
813    else if (cat_name == "Sm")
814        return true;
815    else if (cat_name == "So")
816        return true;
817    else if (cat_name == "S")
818        return true;
819    else if (cat_name == "Zl")
820        return true;
821    else if (cat_name == "Zp")
822        return true;
823    else if (cat_name == "Zs")
824        return true;
825    else if (cat_name == "Z")
826        return true;
827    else
828        return false;
829}
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
Note: See TracBrowser for help on using the repository browser.