Debian Codegraph @

Source/Parser/FunctionalJAVACC/OWL2FunctionalStyleParser.cpp

raw
1 /* OWL2FunctionalStyleParser.cc */
2 #include "OWL2FunctionalStyleParser.h"
3 namespace Konclude {
4 namespace Parser {
5 namespace FunctionalJAVACC {
6 unsigned int jj_la1_0[] = {
7 0x0,0x0,0x200,0x0,0x0,0x800,0x40000,0x0,0x0,0x100,0x3f000,0x80000,0x800000,0x800000,0x0,0x0,0xff000000,0x0,0xff000000,0xff000000,0xff000000,0x800000,0x800000,0x800000,0x40000,0x0,0x0,0xff000000,0x0,0x180000,0x80000,0x0,0x0,0x80000,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,};
8 unsigned int jj_la1_1[] = {
9 0x0,0x0,0x0,0x0,0x0,0x0,0xffffe000,0x0,0x0,0x0,0x0,0x0,0x78,0x78,0x0,0x0,0x1f87,0x0,0x1f87,0x1f87,0x1f87,0x78,0x78,0x78,0xffffe000,0x0,0x1e000,0x1f87,0x3ffe0000,0x0,0x0,0xc0000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
10 unsigned int jj_la1_2[] = {
11 0x40100000,0x2000,0x0,0x40100000,0x40100000,0x0,0x3dfff,0x40500000,0x80000,0x0,0x0,0x40100000,0x40100000,0x40100000,0x0,0x40100000,0x40100000,0x40500000,0x40100000,0x40100000,0x40100000,0x40100000,0x40100000,0x40100000,0x3dfff,0x2000,0x0,0x40100000,0x0,0x40100000,0x40100000,0xf,0x40100000,0x40100000,0x40100000,0x1fc0,0x40500000,0x2000,0x40500000,0x3c000,0x40500000,};
12 unsigned int jj_la1_3[] = {
13 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,};
14
15 /** Constructor with user supplied TokenManager. */
16
17
18
19 QString OWL2FunctionalStyleParser::languageTag() {Token* t;if (!hasError) {
20
21 t = jj_consume_token(LANGTAG);
22 }
23
24 return JAVACC_TO_QSTRING(t->image);
25 assert(false);
26 }
27
28
29 QString OWL2FunctionalStyleParser::nodeId() {Token* t;if (!hasError) {
30
31 jj_consume_token(BLANK_NODE_PREFIX);
32 }
33 if (!hasError) {
34
35 t = jj_consume_token(PN_LOCAL);
36 }
37
38 return JAVACC_TO_QSTRING(t->image);
39 assert(false);
40 }
41
42
43 QString OWL2FunctionalStyleParser::fullIri() {Token* t;if (!hasError) {
44
45 t = jj_consume_token(FULL_IRI);
46 }
47
48 return JAVACC_TO_QSTRING(t->image);
49 assert(false);
50 }
51
52
53 QString OWL2FunctionalStyleParser::iri() {QString x;if (!hasError) {
54
55 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
56 case FULL_IRI:{if (!hasError) {
57
58 x = fullIri();
59 }
60
61 break;
62 }
63 case PNAME_NS:{if (!hasError) {
64
65 x = abbreviatedIri();
66 }
67
68 break;
69 }
70 default:
71 jj_la1[0] = jj_gen;
72 jj_consume_token(-1);
73 errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
74 }
75 }
76
77 return x;
78 assert(false);
79 }
80
81
82 QString OWL2FunctionalStyleParser::abbreviatedIri() {Token* t;
83 QString abbName;if (!hasError) {
84
85 abbName = prefixName();
86 }
87 if (!hasError) {
88
89 t = jj_consume_token(PN_LOCAL);
90 }
91
92 return getBuilder()->resolveAbbreviationName(abbName+JAVACC_TO_QSTRING(t->image));
93 assert(false);
94 }
95
96
97 QString OWL2FunctionalStyleParser::prefixName() {Token* t = nullptr;if (!hasError) {
98
99 t = jj_consume_token(PNAME_NS);
100 }
101
102 return JAVACC_TO_QSTRING(t->image);
103 assert(false);
104 }
105
106
107 void OWL2FunctionalStyleParser::ontologyAnnotations() {if (!hasError) {
108
109 while (!hasError) {
110 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
111 case ANNOTATION:{
112 ;
113 break;
114 }
115 default:
116 jj_la1[1] = jj_gen;
117 goto end_label_1;
118 }if (!hasError) {
119
120 annotation();
121 }
122
123 }
124 end_label_1: ;
125 }
126
127 }
128
129
130 void OWL2FunctionalStyleParser::ontologyDocument() {if (!hasError) {
131
132 while (!hasError) {
133 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
134 case PREFIX:{
135 ;
136 break;
137 }
138 default:
139 jj_la1[2] = jj_gen;
140 goto end_label_2;
141 }if (!hasError) {
142
143 prefixDeclaration();
144 }
145
146 }
147 end_label_2: ;
148 }
149 if (!hasError) {
150
151 ontology();
152 }
153
154 }
155
156
157 void OWL2FunctionalStyleParser::prefixDeclaration() {QString abbName;
158 QString fullName;if (!hasError) {
159
160 jj_consume_token(PREFIX);
161 }
162 if (!hasError) {
163
164 jj_consume_token(OPEN_BRACKET);
165 }
166 if (!hasError) {
167
168 abbName = prefixName();
169 }
170 if (!hasError) {
171
172 jj_consume_token(EQUALS);
173 }
174 if (!hasError) {
175
176 fullName = fullIri();
177 }
178 if (!hasError) {
179
180 jj_consume_token(CLOSE_BRACKET);
181 }
182
183 if (abbName.endsWith(":")) {
184 abbName = abbName.remove(abbName.length()-1,1);
185 }
186 getBuilder()->addNameAbbreviation(fullName,abbName);
187 }
188
189
190 void OWL2FunctionalStyleParser::ontology() {if (!hasError) {
191
192 jj_consume_token(ONTOLOGY);
193 }
194 if (!hasError) {
195
196 jj_consume_token(OPEN_BRACKET);
197 }
198 if (!hasError) {
199
200 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
201 case PNAME_NS:
202 case FULL_IRI:{if (!hasError) {
203
204 ontologyIri();
205 }
206 if (!hasError) {
207
208 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
209 case PNAME_NS:
210 case FULL_IRI:{if (!hasError) {
211
212 versionIri();
213 }
214
215 break;
216 }
217 default:
218 jj_la1[3] = jj_gen;
219 ;
220 }
221 }
222
223 break;
224 }
225 default:
226 jj_la1[4] = jj_gen;
227 ;
228 }
229 }
230 if (!hasError) {
231
232 directlyImportsDocuments();
233 }
234 if (!hasError) {
235
236 ontologyAnnotations();
237 }
238 if (!hasError) {
239
240 axioms();
241 }
242 if (!hasError) {
243
244 jj_consume_token(CLOSE_BRACKET);
245 }
246
247 }
248
249
250 QString OWL2FunctionalStyleParser::ontologyIri() {QString x;if (!hasError) {
251
252 x = iri();
253 }
254
255 return x;
256 assert(false);
257 }
258
259
260 QString OWL2FunctionalStyleParser::versionIri() {QString x;if (!hasError) {
261
262 x = iri();
263 }
264
265 return x;
266 assert(false);
267 }
268
269
270 void OWL2FunctionalStyleParser::directlyImportsDocuments() {QString x;if (!hasError) {
271
272 while (!hasError) {
273 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
274 case IMPORT:{
275 ;
276 break;
277 }
278 default:
279 jj_la1[5] = jj_gen;
280 goto end_label_3;
281 }if (!hasError) {
282
283 jj_consume_token(IMPORT);
284 }
285 if (!hasError) {
286
287 jj_consume_token(OPEN_BRACKET);
288 }
289 if (!hasError) {
290
291 x = iri();
292 }
293 if (!hasError) {
294
295 getBuilder()->addOntologyImport(x);
296 }
297 if (!hasError) {
298
299 jj_consume_token(CLOSE_BRACKET);
300 }
301
302 }
303 end_label_3: ;
304 }
305
306 }
307
308
309 void OWL2FunctionalStyleParser::axioms() {CBuildExpressionPtr x;if (!hasError) {
310
311 while (!hasError) {
312 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
313 case DECLARATION:
314 case SUB_CLASS_OF:
315 case EQUIVALENT_CLASSES:
316 case DISJOINT_CLASSES:
317 case DISJOINT_UNION:
318 case SUB_OBJECT_PROPERTY_OF:
319 case EQUIVALENT_OBJECT_PROPERTIES:
320 case DISJOINT_OBJECT_PROPERTIES:
321 case OBJECT_PROPERTY_DOMAIN:
322 case OBJECT_PROPERTY_RANGE:
323 case INVERSE_OBJECT_PROPERTIES:
324 case FUNCTIONAL_OBJECT_PROPERTY:
325 case INVERSE_FUNCTIONAL_OBJECT_PROPERTY:
326 case REFLEXIVE_OBJECT_PROPERTY:
327 case IRREFLEXIVE_OBJECT_PROPERTY:
328 case SYMMETRIC_OBJECT_PROPERTY:
329 case ASYMMETRIC_OBJECT_PROPERTY:
330 case TRANSITIVE_OBJECT_PROPERTY:
331 case SUB_DATA_PROPERTY_OF:
332 case EQUIVALENT_DATA_PROPERTIES:
333 case DISJOINT_DATA_PROPERTIES:
334 case DATA_PROPERTY_DOMAIN:
335 case DATA_PROPERTY_RANGE:
336 case FUNCTIONAL_DATA_PROPERTY:
337 case DATATYPE_DEFINITION:
338 case HAS_KEY:
339 case SAME_INDIVIDUAL:
340 case DIFFERENT_INDIVIDUALS:
341 case CLASS_ASSERTION:
342 case OBJECT_PROPERTY_ASSERTION:
343 case NEGATIVE_OBJECT_PROPERTY_ASSERTION:
344 case DATA_PROPERTY_ASSERTION:
345 case NEGATIVE_DATA_PROPERTY_ASSERTION:
346 case ANNOTATION_ASSERTION:
347 case SUB_ANNOTATION_PROPERTY_OF:
348 case ANNOTATION_PROPERTY_DOMAIN:
349 case ANNOTATION_PROPERTY_RANGE:{
350 ;
351 break;
352 }
353 default:
354 jj_la1[6] = jj_gen;
355 goto end_label_4;
356 }if (!hasError) {
357
358 x = axiom();
359 }
360 if (!hasError) {
361
362 getBuilder()->tellOntologyAxiom(x);
363 }
364
365 }
366 end_label_4: ;
367 }
368
369 }
370
371
372 CBuildExpressionPtr OWL2FunctionalStyleParser::owlClass() {QString x;if (!hasError) {
373
374 x = iri();
375 }
376
377 return getBuilder()->getClass(x);
378 assert(false);
379 }
380
381
382 CBuildExpressionPtr OWL2FunctionalStyleParser::datatype() {QString x;if (!hasError) {
383
384 x = iri();
385 }
386
387 return getBuilder()->getDatatype(x);
388 assert(false);
389 }
390
391
392 CBuildExpressionPtr OWL2FunctionalStyleParser::objectProperty() {QString x;if (!hasError) {
393
394 x = iri();
395 }
396
397 return getBuilder()->getObjectProberty(x);
398 assert(false);
399 }
400
401
402 CBuildExpressionPtr OWL2FunctionalStyleParser::dataProperty() {QString x;if (!hasError) {
403
404 x = iri();
405 }
406
407 return getBuilder()->getDataProberty(x);
408 assert(false);
409 }
410
411
412 CBuildExpressionPtr OWL2FunctionalStyleParser::annotationProperty() {QString x;if (!hasError) {
413
414 x = iri();
415 }
416
417 return nullptr;
418 assert(false);
419 }
420
421
422 CBuildExpressionPtr OWL2FunctionalStyleParser::individual() {CBuildExpressionPtr x;if (!hasError) {
423
424 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
425 case PNAME_NS:
426 case FULL_IRI:{if (!hasError) {
427
428 x = namedIndividual();
429 }
430
431 break;
432 }
433 case BLANK_NODE_PREFIX:{if (!hasError) {
434
435 x = anonymousIndividual();
436 }
437
438 break;
439 }
440 default:
441 jj_la1[7] = jj_gen;
442 jj_consume_token(-1);
443 errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
444 }
445 }
446
447 return x;
448 assert(false);
449 }
450
451
452 CBuildExpressionPtr OWL2FunctionalStyleParser::namedIndividual() {QString x;if (!hasError) {
453
454 x = iri();
455 }
456
457 return getBuilder()->getNamedIndividual(x);
458 assert(false);
459 }
460
461
462 CBuildExpressionPtr OWL2FunctionalStyleParser::anonymousIndividual() {QString x;if (!hasError) {
463
464 x = nodeId();
465 }
466
467 return getBuilder()->getAnonymousIndividual(getBuilder()->getAnonymousOntologyIdentifier(),x);
468 assert(false);
469 }
470
471
472 CBuildExpressionPtr OWL2FunctionalStyleParser::literal(bool annotation) {QString x,l;
473 CBuildExpressionPtr d = nullptr;if (!hasError) {
474
475 x = quotedQString();
476 }
477 if (!hasError) {
478
479 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
480 case REFERENCE:{if (!hasError) {
481
482 jj_consume_token(REFERENCE);
483 }
484 if (!hasError) {
485
486 d = datatype();
487 }
488
489 break;
490 }
491 default:
492 jj_la1[9] = jj_gen;if (!hasError) {
493
494 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
495 case LANGTAG:{if (!hasError) {
496
497 l = languageTag();
498 }
499
500 break;
501 }
502 default:
503 jj_la1[8] = jj_gen;
504 ;
505 }
506 }
507
508 }
509 }
510
511 if (annotation) {
512 return nullptr;
513 }
514 if (d == nullptr) {
515 d = getBuilder()->getDatatype("http://www.w3.org/1999/02/22-rdf-syntax-ns#PlainLiteral");
516 if (l.isEmpty()) {
517 x += "@";
518 } else {
519 x += l;
520 }
521 }
522 CBuildExpressionPtr y = getBuilder()->getDataLexicalValue(x);
523 return getBuilder()->getDataLiteral((CDataLexicalValueExpressionPtr)y,(CDatatypeExpressionPtr)d);
524 assert(false);
525 }
526
527
528 QString OWL2FunctionalStyleParser::quotedQString() {Token* t;if (!hasError) {
529
530 t = jj_consume_token(QUOTED_QString);
531 }
532
533 return JAVACC_TO_QSTRING(t->image);
534 assert(false);
535 }
536
537
538 CBuildExpressionPtr OWL2FunctionalStyleParser::declaration() {CBuildExpressionPtr x;if (!hasError) {
539
540 jj_consume_token(DECLARATION);
541 }
542 if (!hasError) {
543
544 jj_consume_token(OPEN_BRACKET);
545 }
546 if (!hasError) {
547
548 axiomAnnotations();
549 }
550 if (!hasError) {
551
552 x = entity();
553 }
554 if (!hasError) {
555
556 jj_consume_token(CLOSE_BRACKET);
557 }
558
559 return getBuilder()->getDeclaration(x);
560 assert(false);
561 }
562
563
564 CBuildExpressionPtr OWL2FunctionalStyleParser::entity() {CBuildExpressionPtr x = nullptr;if (!hasError) {
565
566 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
567 case CLASS:{if (!hasError) {
568
569 jj_consume_token(CLASS);
570 }
571 if (!hasError) {
572
573 jj_consume_token(OPEN_BRACKET);
574 }
575 if (!hasError) {
576
577 x = owlClass();
578 }
579 if (!hasError) {
580
581 jj_consume_token(CLOSE_BRACKET);
582 }
583
584 break;
585 }
586 case DATATYPE:{if (!hasError) {
587
588 jj_consume_token(DATATYPE);
589 }
590 if (!hasError) {
591
592 jj_consume_token(OPEN_BRACKET);
593 }
594 if (!hasError) {
595
596 x = datatype();
597 }
598 if (!hasError) {
599
600 jj_consume_token(CLOSE_BRACKET);
601 }
602
603 break;
604 }
605 case OBJECT_PROPERTY:{if (!hasError) {
606
607 jj_consume_token(OBJECT_PROPERTY);
608 }
609 if (!hasError) {
610
611 jj_consume_token(OPEN_BRACKET);
612 }
613 if (!hasError) {
614
615 x = objectProperty();
616 }
617 if (!hasError) {
618
619 jj_consume_token(CLOSE_BRACKET);
620 }
621
622 break;
623 }
624 case DATA_PROPERTY:{if (!hasError) {
625
626 jj_consume_token(DATA_PROPERTY);
627 }
628 if (!hasError) {
629
630 jj_consume_token(OPEN_BRACKET);
631 }
632 if (!hasError) {
633
634 x = dataProperty();
635 }
636 if (!hasError) {
637
638 jj_consume_token(CLOSE_BRACKET);
639 }
640
641 break;
642 }
643 case ANNOTATION_PROPERTY:{if (!hasError) {
644
645 jj_consume_token(ANNOTATION_PROPERTY);
646 }
647 if (!hasError) {
648
649 jj_consume_token(OPEN_BRACKET);
650 }
651 if (!hasError) {
652
653 x = annotationProperty();
654 }
655 if (!hasError) {
656
657 jj_consume_token(CLOSE_BRACKET);
658 }
659
660 break;
661 }
662 case NAMED_INDIVIDUAL:{if (!hasError) {
663
664 jj_consume_token(NAMED_INDIVIDUAL);
665 }
666 if (!hasError) {
667
668 jj_consume_token(OPEN_BRACKET);
669 }
670 if (!hasError) {
671
672 x = namedIndividual();
673 }
674 if (!hasError) {
675
676 jj_consume_token(CLOSE_BRACKET);
677 }
678
679 break;
680 }
681 default:
682 jj_la1[10] = jj_gen;
683 jj_consume_token(-1);
684 errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
685 }
686 }
687
688 return x;
689 assert(false);
690 }
691
692
693 CBuildExpressionPtr OWL2FunctionalStyleParser::objectPropertyExpression() {CBuildExpressionPtr x;if (!hasError) {
694
695 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
696 case PNAME_NS:
697 case FULL_IRI:{if (!hasError) {
698
699 x = objectProperty();
700 }
701
702 break;
703 }
704 case OBJECT_INVERSE_OF:{if (!hasError) {
705
706 x = inverseObjectProperty();
707 }
708
709 break;
710 }
711 default:
712 jj_la1[11] = jj_gen;
713 jj_consume_token(-1);
714 errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
715 }
716 }
717
718 return x;
719 assert(false);
720 }
721
722
723 CBuildExpressionPtr OWL2FunctionalStyleParser::inverseObjectProperty() {CBuildExpressionPtr x;if (!hasError) {
724
725 jj_consume_token(OBJECT_INVERSE_OF);
726 }
727 if (!hasError) {
728
729 jj_consume_token(OPEN_BRACKET);
730 }
731 if (!hasError) {
732
733 x = objectProperty();
734 }
735 if (!hasError) {
736
737 jj_consume_token(CLOSE_BRACKET);
738 }
739
740 return getBuilder()->getInverseObjectPropertyOf(x);
741 assert(false);
742 }
743
744
745 CBuildExpressionPtr OWL2FunctionalStyleParser::dataPropertyExpression() {CBuildExpressionPtr x;if (!hasError) {
746
747 x = dataProperty();
748 }
749
750 return x;
751 assert(false);
752 }
753
754
755 CBuildExpressionPtr OWL2FunctionalStyleParser::dataRange() {CBuildExpressionPtr x;if (!hasError) {
756
757 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
758 case PNAME_NS:
759 case FULL_IRI:{if (!hasError) {
760
761 x = datatype();
762 }
763
764 break;
765 }
766 case DATA_INTERSECTION_OF:{if (!hasError) {
767
768 x = dataIntersectionOf();
769 }
770
771 break;
772 }
773 case DATA_UNION_OF:{if (!hasError) {
774
775 x = dataUnionOf();
776 }
777
778 break;
779 }
780 case DATA_COMPLEMENT_OF:{if (!hasError) {
781
782 x = dataComplementOf();
783 }
784
785 break;
786 }
787 case DATA_ONE_OF:{if (!hasError) {
788
789 x = dataOneOf();
790 }
791
792 break;
793 }
794 case DATATYPE_RESTRICTION:{if (!hasError) {
795
796 x = datatypeRestriction();
797 }
798
799 break;
800 }
801 default:
802 jj_la1[12] = jj_gen;
803 jj_consume_token(-1);
804 errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
805 }
806 }
807
808 return x;
809 assert(false);
810 }
811
812
813 CEXPRESSIONLIST <CBuildExpressionPtr> OWL2FunctionalStyleParser::dataRangeList() {CBuildExpressionPtr x;
814 CEXPRESSIONLIST<CBuildExpressionPtr> v;if (!hasError) {
815
816 while (!hasError) {if (!hasError) {
817
818 x = dataRange();
819 }
820 if (!hasError) {
821
822 v.append(x);
823 }
824
825 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
826 case DATATYPE_RESTRICTION:
827 case DATA_INTERSECTION_OF:
828 case DATA_UNION_OF:
829 case DATA_COMPLEMENT_OF:
830 case DATA_ONE_OF:
831 case PNAME_NS:
832 case FULL_IRI:{
833 ;
834 break;
835 }
836 default:
837 jj_la1[13] = jj_gen;
838 goto end_label_5;
839 }
840 }
841 end_label_5: ;
842 }
843
844 return v;
845 assert(false);
846 }
847
848
849 CBuildExpressionPtr OWL2FunctionalStyleParser::dataIntersectionOf() {CEXPRESSIONLIST<CBuildExpressionPtr> v;if (!hasError) {
850
851 jj_consume_token(DATA_INTERSECTION_OF);
852 }
853 if (!hasError) {
854
855 jj_consume_token(OPEN_BRACKET);
856 }
857 if (!hasError) {
858
859 v = dataRangeList();
860 }
861 if (!hasError) {
862
863 jj_consume_token(CLOSE_BRACKET);
864 }
865
866 return getBuilder()->getDataIntersectionOf(v);
867 assert(false);
868 }
869
870
871 CBuildExpressionPtr OWL2FunctionalStyleParser::dataUnionOf() {CEXPRESSIONLIST<CBuildExpressionPtr> v;if (!hasError) {
872
873 jj_consume_token(DATA_UNION_OF);
874 }
875 if (!hasError) {
876
877 jj_consume_token(OPEN_BRACKET);
878 }
879 if (!hasError) {
880
881 v = dataRangeList();
882 }
883 if (!hasError) {
884
885 jj_consume_token(CLOSE_BRACKET);
886 }
887
888 return getBuilder()->getDataUnionOf(v);
889 assert(false);
890 }
891
892
893 CBuildExpressionPtr OWL2FunctionalStyleParser::dataComplementOf() {CBuildExpressionPtr x;if (!hasError) {
894
895 jj_consume_token(DATA_COMPLEMENT_OF);
896 }
897 if (!hasError) {
898
899 jj_consume_token(OPEN_BRACKET);
900 }
901 if (!hasError) {
902
903 x = dataRange();
904 }
905 if (!hasError) {
906
907 jj_consume_token(CLOSE_BRACKET);
908 }
909
910 return getBuilder()->getDataComplementOf(x);
911 assert(false);
912 }
913
914
915 CBuildExpressionPtr OWL2FunctionalStyleParser::dataOneOf() {CBuildExpressionPtr x;
916 CEXPRESSIONLIST<CBuildExpressionPtr> v;if (!hasError) {
917
918 jj_consume_token(DATA_ONE_OF);
919 }
920 if (!hasError) {
921
922 jj_consume_token(OPEN_BRACKET);
923 }
924 if (!hasError) {
925
926 while (!hasError) {if (!hasError) {
927
928 x = literal(false);
929 }
930 if (!hasError) {
931
932 v.append(x);
933 }
934
935 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
936 case QUOTED_QString:{
937 ;
938 break;
939 }
940 default:
941 jj_la1[14] = jj_gen;
942 goto end_label_6;
943 }
944 }
945 end_label_6: ;
946 }
947 if (!hasError) {
948
949 jj_consume_token(CLOSE_BRACKET);
950 }
951
952 return getBuilder()->getDataOneOf(v);
953 assert(false);
954 }
955
956
957 CBuildExpressionPtr OWL2FunctionalStyleParser::datatypeRestriction() {CBuildExpressionPtr x;
958 CEXPRESSIONLIST<CBuildExpressionPtr> v;if (!hasError) {
959
960 jj_consume_token(DATATYPE_RESTRICTION);
961 }
962 if (!hasError) {
963
964 jj_consume_token(OPEN_BRACKET);
965 }
966 if (!hasError) {
967
968 x = datatype();
969 }
970 if (!hasError) {
971
972 v = facetRestrictionList();
973 }
974 if (!hasError) {
975
976 jj_consume_token(CLOSE_BRACKET);
977 }
978
979 v.append(x);
980 return getBuilder()->getDatatypeRestriction(v);
981 assert(false);
982 }
983
984
985 CEXPRESSIONLIST <CBuildExpressionPtr> OWL2FunctionalStyleParser::facetRestrictionList() {CBuildExpressionPtr x;
986 CEXPRESSIONLIST<CBuildExpressionPtr> v;if (!hasError) {
987
988 while (!hasError) {if (!hasError) {
989
990 x = facetRestriction();
991 }
992 if (!hasError) {
993
994 v.append(x);
995 }
996
997 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
998 case PNAME_NS:
999 case FULL_IRI:{
1000 ;
1001 break;
1002 }
1003 default:
1004 jj_la1[15] = jj_gen;
1005 goto end_label_7;
1006 }
1007 }
1008 end_label_7: ;
1009 }
1010
1011 return v;
1012 assert(false);
1013 }
1014
1015
1016 CBuildExpressionPtr OWL2FunctionalStyleParser::facetRestriction() {QString f;
1017 CBuildExpressionPtr l;if (!hasError) {
1018
1019 f = iri();
1020 }
1021 if (!hasError) {
1022
1023 l = literal(false);
1024 }
1025
1026 CBuildExpressionPtr x = getBuilder()->getDataFacet(f);
1027 return getBuilder()->getDataFacetRestriction(l,x);
1028 assert(false);
1029 }
1030
1031
1032 CBuildExpressionPtr OWL2FunctionalStyleParser::classExpression() {CBuildExpressionPtr x;if (!hasError) {
1033
1034 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1035 case PNAME_NS:
1036 case FULL_IRI:{if (!hasError) {
1037
1038 x = owlClass();
1039 }
1040
1041 break;
1042 }
1043 case OBJECT_INTERSECTION_OF:{if (!hasError) {
1044
1045 x = objectIntersectionOf();
1046 }
1047
1048 break;
1049 }
1050 case OBJECT_UNION_OF:{if (!hasError) {
1051
1052 x = objectUnionOf();
1053 }
1054
1055 break;
1056 }
1057 case OBJECT_COMPLEMENT_OF:{if (!hasError) {
1058
1059 x = objectComplementOf();
1060 }
1061
1062 break;
1063 }
1064 case OBJECT_ONE_OF:{if (!hasError) {
1065
1066 x = objectOneOf();
1067 }
1068
1069 break;
1070 }
1071 case OBJECT_SOME_VALUES_FROM:{if (!hasError) {
1072
1073 x = objectSomeValuesFrom();
1074 }
1075
1076 break;
1077 }
1078 case OBJECT_ALL_VALUES_FROM:{if (!hasError) {
1079
1080 x = objectAllValuesFrom();
1081 }
1082
1083 break;
1084 }
1085 case OBJECT_HAS_VALUE:{if (!hasError) {
1086
1087 x = objectHasValue();
1088 }
1089
1090 break;
1091 }
1092 case OBJECT_HAS_SELF:{if (!hasError) {
1093
1094 x = objectHasSelf();
1095 }
1096
1097 break;
1098 }
1099 case OBJECT_MIN_CARDINALITY:{if (!hasError) {
1100
1101 x = objectMinCardinality();
1102 }
1103
1104 break;
1105 }
1106 case OBJECT_MAX_CARDINALITY:{if (!hasError) {
1107
1108 x = objectMaxCardinality();
1109 }
1110
1111 break;
1112 }
1113 case OBJECT_EXACT_CARDINALITY:{if (!hasError) {
1114
1115 x = objectExactCardinality();
1116 }
1117
1118 break;
1119 }
1120 case DATA_SOME_VALUES_FROM:{if (!hasError) {
1121
1122 x = dataSomeValuesFrom();
1123 }
1124
1125 break;
1126 }
1127 case DATA_ALL_VALUES_FROM:{if (!hasError) {
1128
1129 x = dataAllValuesFrom();
1130 }
1131
1132 break;
1133 }
1134 case DATA_HAS_VALUE:{if (!hasError) {
1135
1136 x = dataHasValue();
1137 }
1138
1139 break;
1140 }
1141 case DATA_MIN_CARDINALITY:{if (!hasError) {
1142
1143 x = dataMinCardinality();
1144 }
1145
1146 break;
1147 }
1148 case DATA_MAX_CARDINALITY:{if (!hasError) {
1149
1150 x = dataMaxCardinality();
1151 }
1152
1153 break;
1154 }
1155 case DATA_EXACT_CARDINALITY:{if (!hasError) {
1156
1157 x = dataExactCardinality();
1158 }
1159
1160 break;
1161 }
1162 default:
1163 jj_la1[16] = jj_gen;
1164 jj_consume_token(-1);
1165 errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
1166 }
1167 }
1168
1169 return x;
1170 assert(false);
1171 }
1172
1173
1174 CBuildExpressionPtr OWL2FunctionalStyleParser::objectIntersectionOf() {CEXPRESSIONLIST<CBuildExpressionPtr> v;if (!hasError) {
1175
1176 jj_consume_token(OBJECT_INTERSECTION_OF);
1177 }
1178 if (!hasError) {
1179
1180 jj_consume_token(OPEN_BRACKET);
1181 }
1182 if (!hasError) {
1183
1184 v = classExpressionList();
1185 }
1186 if (!hasError) {
1187
1188 jj_consume_token(CLOSE_BRACKET);
1189 }
1190
1191 return getBuilder()->getObjectIntersectionOf(v);
1192 assert(false);
1193 }
1194
1195
1196 CBuildExpressionPtr OWL2FunctionalStyleParser::objectUnionOf() {CEXPRESSIONLIST<CBuildExpressionPtr> v;if (!hasError) {
1197
1198 jj_consume_token(OBJECT_UNION_OF);
1199 }
1200 if (!hasError) {
1201
1202 jj_consume_token(OPEN_BRACKET);
1203 }
1204 if (!hasError) {
1205
1206 v = classExpressionList();
1207 }
1208 if (!hasError) {
1209
1210 jj_consume_token(CLOSE_BRACKET);
1211 }
1212
1213 return getBuilder()->getObjectUnionOf(v);
1214 assert(false);
1215 }
1216
1217
1218 CBuildExpressionPtr OWL2FunctionalStyleParser::objectComplementOf() {CBuildExpressionPtr x;if (!hasError) {
1219
1220 jj_consume_token(OBJECT_COMPLEMENT_OF);
1221 }
1222 if (!hasError) {
1223
1224 jj_consume_token(OPEN_BRACKET);
1225 }
1226 if (!hasError) {
1227
1228 x = classExpression();
1229 }
1230 if (!hasError) {
1231
1232 jj_consume_token(CLOSE_BRACKET);
1233 }
1234
1235 return getBuilder()->getObjectComplementOf(x);
1236 assert(false);
1237 }
1238
1239
1240 CBuildExpressionPtr OWL2FunctionalStyleParser::objectOneOf() {CBuildExpressionPtr x;
1241 CEXPRESSIONLIST<CBuildExpressionPtr> v;if (!hasError) {
1242
1243 jj_consume_token(OBJECT_ONE_OF);
1244 }
1245 if (!hasError) {
1246
1247 jj_consume_token(OPEN_BRACKET);
1248 }
1249 if (!hasError) {
1250
1251 while (!hasError) {if (!hasError) {
1252
1253 x = individual();
1254 }
1255 if (!hasError) {
1256
1257 v.append(x);
1258 }
1259
1260 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1261 case PNAME_NS:
1262 case BLANK_NODE_PREFIX:
1263 case FULL_IRI:{
1264 ;
1265 break;
1266 }
1267 default:
1268 jj_la1[17] = jj_gen;
1269 goto end_label_8;
1270 }
1271 }
1272 end_label_8: ;
1273 }
1274 if (!hasError) {
1275
1276 jj_consume_token(CLOSE_BRACKET);
1277 }
1278
1279 return getBuilder()->getObjectOneOf(v);
1280 assert(false);
1281 }
1282
1283
1284 CBuildExpressionPtr OWL2FunctionalStyleParser::objectSomeValuesFrom() {CBuildExpressionPtr x;
1285 CBuildExpressionPtr y;if (!hasError) {
1286
1287 jj_consume_token(OBJECT_SOME_VALUES_FROM);
1288 }
1289 if (!hasError) {
1290
1291 jj_consume_token(OPEN_BRACKET);
1292 }
1293 if (!hasError) {
1294
1295 x = objectPropertyExpression();
1296 }
1297 if (!hasError) {
1298
1299 y = classExpression();
1300 }
1301 if (!hasError) {
1302
1303 jj_consume_token(CLOSE_BRACKET);
1304 }
1305
1306 return getBuilder()->getObjectSomeValuesFrom(x,y);
1307 assert(false);
1308 }
1309
1310
1311 CBuildExpressionPtr OWL2FunctionalStyleParser::objectAllValuesFrom() {CBuildExpressionPtr x;
1312 CBuildExpressionPtr y;if (!hasError) {
1313
1314 jj_consume_token(OBJECT_ALL_VALUES_FROM);
1315 }
1316 if (!hasError) {
1317
1318 jj_consume_token(OPEN_BRACKET);
1319 }
1320 if (!hasError) {
1321
1322 x = objectPropertyExpression();
1323 }
1324 if (!hasError) {
1325
1326 y = classExpression();
1327 }
1328 if (!hasError) {
1329
1330 jj_consume_token(CLOSE_BRACKET);
1331 }
1332
1333 return getBuilder()->getObjectAllValuesFrom(x,y);
1334 assert(false);
1335 }
1336
1337
1338 CBuildExpressionPtr OWL2FunctionalStyleParser::objectHasValue() {CBuildExpressionPtr x;
1339 CBuildExpressionPtr y;if (!hasError) {
1340
1341 jj_consume_token(OBJECT_HAS_VALUE);
1342 }
1343 if (!hasError) {
1344
1345 jj_consume_token(OPEN_BRACKET);
1346 }
1347 if (!hasError) {
1348
1349 x = objectPropertyExpression();
1350 }
1351 if (!hasError) {
1352
1353 y = individual();
1354 }
1355 if (!hasError) {
1356
1357 jj_consume_token(CLOSE_BRACKET);
1358 }
1359
1360 return getBuilder()->getObjectHasValue(x,y);
1361 assert(false);
1362 }
1363
1364
1365 CBuildExpressionPtr OWL2FunctionalStyleParser::objectHasSelf() {CBuildExpressionPtr x;if (!hasError) {
1366
1367 jj_consume_token(OBJECT_HAS_SELF);
1368 }
1369 if (!hasError) {
1370
1371 jj_consume_token(OPEN_BRACKET);
1372 }
1373 if (!hasError) {
1374
1375 x = objectPropertyExpression();
1376 }
1377 if (!hasError) {
1378
1379 jj_consume_token(CLOSE_BRACKET);
1380 }
1381
1382 return getBuilder()->getObjectHasSelf(x);
1383 assert(false);
1384 }
1385
1386
1387 CBuildExpressionPtr OWL2FunctionalStyleParser::objectMinCardinality() {Token* n;
1388 CBuildExpressionPtr x;
1389 CBuildExpressionPtr y = nullptr;if (!hasError) {
1390
1391 jj_consume_token(OBJECT_MIN_CARDINALITY);
1392 }
1393 if (!hasError) {
1394
1395 jj_consume_token(OPEN_BRACKET);
1396 }
1397 if (!hasError) {
1398
1399 n = jj_consume_token(NON_NEGATIVE_INTEGER);
1400 }
1401 if (!hasError) {
1402
1403 x = objectPropertyExpression();
1404 }
1405 if (!hasError) {
1406
1407 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1408 case OBJECT_INTERSECTION_OF:
1409 case OBJECT_UNION_OF:
1410 case OBJECT_COMPLEMENT_OF:
1411 case OBJECT_ONE_OF:
1412 case OBJECT_SOME_VALUES_FROM:
1413 case OBJECT_ALL_VALUES_FROM:
1414 case OBJECT_HAS_VALUE:
1415 case OBJECT_HAS_SELF:
1416 case OBJECT_MIN_CARDINALITY:
1417 case OBJECT_MAX_CARDINALITY:
1418 case OBJECT_EXACT_CARDINALITY:
1419 case DATA_SOME_VALUES_FROM:
1420 case DATA_ALL_VALUES_FROM:
1421 case DATA_HAS_VALUE:
1422 case DATA_MIN_CARDINALITY:
1423 case DATA_MAX_CARDINALITY:
1424 case DATA_EXACT_CARDINALITY:
1425 case PNAME_NS:
1426 case FULL_IRI:{if (!hasError) {
1427
1428 y = classExpression();
1429 }
1430
1431 break;
1432 }
1433 default:
1434 jj_la1[18] = jj_gen;
1435 ;
1436 }
1437 }
1438 if (!hasError) {
1439
1440 jj_consume_token(CLOSE_BRACKET);
1441 }
1442
1443 if (y == nullptr) {
1444 y = getBuilder()->getTopClass();
1445 }
1446 cint64 cardinality = JAVACC_TO_QSTRING(n->image).toLongLong();
1447 return getBuilder()->getObjectMinCardinality(x,y,cardinality);
1448 assert(false);
1449 }
1450
1451
1452 CBuildExpressionPtr OWL2FunctionalStyleParser::objectMaxCardinality() {Token* n;
1453 CBuildExpressionPtr x;
1454 CBuildExpressionPtr y = nullptr;if (!hasError) {
1455
1456 jj_consume_token(OBJECT_MAX_CARDINALITY);
1457 }
1458 if (!hasError) {
1459
1460 jj_consume_token(OPEN_BRACKET);
1461 }
1462 if (!hasError) {
1463
1464 n = jj_consume_token(NON_NEGATIVE_INTEGER);
1465 }
1466 if (!hasError) {
1467
1468 x = objectPropertyExpression();
1469 }
1470 if (!hasError) {
1471
1472 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1473 case OBJECT_INTERSECTION_OF:
1474 case OBJECT_UNION_OF:
1475 case OBJECT_COMPLEMENT_OF:
1476 case OBJECT_ONE_OF:
1477 case OBJECT_SOME_VALUES_FROM:
1478 case OBJECT_ALL_VALUES_FROM:
1479 case OBJECT_HAS_VALUE:
1480 case OBJECT_HAS_SELF:
1481 case OBJECT_MIN_CARDINALITY:
1482 case OBJECT_MAX_CARDINALITY:
1483 case OBJECT_EXACT_CARDINALITY:
1484 case DATA_SOME_VALUES_FROM:
1485 case DATA_ALL_VALUES_FROM:
1486 case DATA_HAS_VALUE:
1487 case DATA_MIN_CARDINALITY:
1488 case DATA_MAX_CARDINALITY:
1489 case DATA_EXACT_CARDINALITY:
1490 case PNAME_NS:
1491 case FULL_IRI:{if (!hasError) {
1492
1493 y = classExpression();
1494 }
1495
1496 break;
1497 }
1498 default:
1499 jj_la1[19] = jj_gen;
1500 ;
1501 }
1502 }
1503 if (!hasError) {
1504
1505 jj_consume_token(CLOSE_BRACKET);
1506 }
1507
1508 if (y == nullptr) {
1509 y = getBuilder()->getTopClass();
1510 }
1511 cint64 cardinality = JAVACC_TO_QSTRING(n->image).toLongLong();
1512 return getBuilder()->getObjectMaxCardinality(x,y,cardinality);
1513 assert(false);
1514 }
1515
1516
1517 CBuildExpressionPtr OWL2FunctionalStyleParser::objectExactCardinality() {Token* n;
1518 CBuildExpressionPtr x;
1519 CBuildExpressionPtr y = nullptr;if (!hasError) {
1520
1521 jj_consume_token(OBJECT_EXACT_CARDINALITY);
1522 }
1523 if (!hasError) {
1524
1525 jj_consume_token(OPEN_BRACKET);
1526 }
1527 if (!hasError) {
1528
1529 n = jj_consume_token(NON_NEGATIVE_INTEGER);
1530 }
1531 if (!hasError) {
1532
1533 x = objectPropertyExpression();
1534 }
1535 if (!hasError) {
1536
1537 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1538 case OBJECT_INTERSECTION_OF:
1539 case OBJECT_UNION_OF:
1540 case OBJECT_COMPLEMENT_OF:
1541 case OBJECT_ONE_OF:
1542 case OBJECT_SOME_VALUES_FROM:
1543 case OBJECT_ALL_VALUES_FROM:
1544 case OBJECT_HAS_VALUE:
1545 case OBJECT_HAS_SELF:
1546 case OBJECT_MIN_CARDINALITY:
1547 case OBJECT_MAX_CARDINALITY:
1548 case OBJECT_EXACT_CARDINALITY:
1549 case DATA_SOME_VALUES_FROM:
1550 case DATA_ALL_VALUES_FROM:
1551 case DATA_HAS_VALUE:
1552 case DATA_MIN_CARDINALITY:
1553 case DATA_MAX_CARDINALITY:
1554 case DATA_EXACT_CARDINALITY:
1555 case PNAME_NS:
1556 case FULL_IRI:{if (!hasError) {
1557
1558 y = classExpression();
1559 }
1560
1561 break;
1562 }
1563 default:
1564 jj_la1[20] = jj_gen;
1565 ;
1566 }
1567 }
1568 if (!hasError) {
1569
1570 jj_consume_token(CLOSE_BRACKET);
1571 }
1572
1573 if (y == nullptr) {
1574 y = getBuilder()->getTopClass();
1575 }
1576 cint64 cardinality = JAVACC_TO_QSTRING(n->image).toLongLong();
1577 return getBuilder()->getObjectExactlyCardinality(x,y,cardinality);
1578 assert(false);
1579 }
1580
1581
1582 CBuildExpressionPtr OWL2FunctionalStyleParser::dataSomeValuesFrom() {CBuildExpressionPtr x, y;if (!hasError) {
1583
1584 jj_consume_token(DATA_SOME_VALUES_FROM);
1585 }
1586 if (!hasError) {
1587
1588 jj_consume_token(OPEN_BRACKET);
1589 }
1590 if (!hasError) {
1591
1592 x = dataProperty();
1593 }
1594 if (!hasError) {
1595
1596 y = dataRange();
1597 }
1598 if (!hasError) {
1599
1600 jj_consume_token(CLOSE_BRACKET);
1601 }
1602
1603 if (y == nullptr) {
1604 y = getBuilder()->getTopDataRange();
1605 }
1606 return getBuilder()->getDataSomeValuesFrom(x,y);
1607 assert(false);
1608 }
1609
1610
1611 CBuildExpressionPtr OWL2FunctionalStyleParser::dataAllValuesFrom() {CBuildExpressionPtr x, y;if (!hasError) {
1612
1613 jj_consume_token(DATA_ALL_VALUES_FROM);
1614 }
1615 if (!hasError) {
1616
1617 jj_consume_token(OPEN_BRACKET);
1618 }
1619 if (!hasError) {
1620
1621 x = dataProperty();
1622 }
1623 if (!hasError) {
1624
1625 y = dataRange();
1626 }
1627 if (!hasError) {
1628
1629 jj_consume_token(CLOSE_BRACKET);
1630 }
1631
1632 return getBuilder()->getDataAllValuesFrom(x,y);
1633 assert(false);
1634 }
1635
1636
1637 CBuildExpressionPtr OWL2FunctionalStyleParser::dataHasValue() {CBuildExpressionPtr x, y;if (!hasError) {
1638
1639 jj_consume_token(DATA_HAS_VALUE);
1640 }
1641 if (!hasError) {
1642
1643 jj_consume_token(OPEN_BRACKET);
1644 }
1645 if (!hasError) {
1646
1647 x = dataPropertyExpression();
1648 }
1649 if (!hasError) {
1650
1651 y = literal(false);
1652 }
1653 if (!hasError) {
1654
1655 jj_consume_token(CLOSE_BRACKET);
1656 }
1657
1658 return getBuilder()->getDataHasValue(x,y);
1659 assert(false);
1660 }
1661
1662
1663 CBuildExpressionPtr OWL2FunctionalStyleParser::dataMinCardinality() {Token* n;
1664 CBuildExpressionPtr x;
1665 CBuildExpressionPtr y = nullptr;if (!hasError) {
1666
1667 jj_consume_token(DATA_MIN_CARDINALITY);
1668 }
1669 if (!hasError) {
1670
1671 jj_consume_token(OPEN_BRACKET);
1672 }
1673 if (!hasError) {
1674
1675 n = jj_consume_token(NON_NEGATIVE_INTEGER);
1676 }
1677 if (!hasError) {
1678
1679 x = dataPropertyExpression();
1680 }
1681 if (!hasError) {
1682
1683 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1684 case DATATYPE_RESTRICTION:
1685 case DATA_INTERSECTION_OF:
1686 case DATA_UNION_OF:
1687 case DATA_COMPLEMENT_OF:
1688 case DATA_ONE_OF:
1689 case PNAME_NS:
1690 case FULL_IRI:{if (!hasError) {
1691
1692 y = dataRange();
1693 }
1694
1695 break;
1696 }
1697 default:
1698 jj_la1[21] = jj_gen;
1699 ;
1700 }
1701 }
1702 if (!hasError) {
1703
1704 jj_consume_token(CLOSE_BRACKET);
1705 }
1706
1707 if (y == nullptr) {
1708 y = getBuilder()->getTopDataRange();
1709 }
1710 cint64 cardinality = JAVACC_TO_QSTRING(n->image).toLongLong();
1711 return getBuilder()->getDataMinCardinality(x,y,cardinality);
1712 assert(false);
1713 }
1714
1715
1716 CBuildExpressionPtr OWL2FunctionalStyleParser::dataMaxCardinality() {Token* n;
1717 CBuildExpressionPtr x;
1718 CBuildExpressionPtr y = nullptr;if (!hasError) {
1719
1720 jj_consume_token(DATA_MAX_CARDINALITY);
1721 }
1722 if (!hasError) {
1723
1724 jj_consume_token(OPEN_BRACKET);
1725 }
1726 if (!hasError) {
1727
1728 n = jj_consume_token(NON_NEGATIVE_INTEGER);
1729 }
1730 if (!hasError) {
1731
1732 x = dataPropertyExpression();
1733 }
1734 if (!hasError) {
1735
1736 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1737 case DATATYPE_RESTRICTION:
1738 case DATA_INTERSECTION_OF:
1739 case DATA_UNION_OF:
1740 case DATA_COMPLEMENT_OF:
1741 case DATA_ONE_OF:
1742 case PNAME_NS:
1743 case FULL_IRI:{if (!hasError) {
1744
1745 y = dataRange();
1746 }
1747
1748 break;
1749 }
1750 default:
1751 jj_la1[22] = jj_gen;
1752 ;
1753 }
1754 }
1755 if (!hasError) {
1756
1757 jj_consume_token(CLOSE_BRACKET);
1758 }
1759
1760 if (y == nullptr) {
1761 y = getBuilder()->getTopDataRange();
1762 }
1763 cint64 cardinality = JAVACC_TO_QSTRING(n->image).toLongLong();
1764 return getBuilder()->getDataMaxCardinality(x,y,cardinality);
1765 assert(false);
1766 }
1767
1768
1769 CBuildExpressionPtr OWL2FunctionalStyleParser::dataExactCardinality() {Token* n;
1770 CBuildExpressionPtr x;
1771 CBuildExpressionPtr y = nullptr;if (!hasError) {
1772
1773 jj_consume_token(DATA_EXACT_CARDINALITY);
1774 }
1775 if (!hasError) {
1776
1777 jj_consume_token(OPEN_BRACKET);
1778 }
1779 if (!hasError) {
1780
1781 n = jj_consume_token(NON_NEGATIVE_INTEGER);
1782 }
1783 if (!hasError) {
1784
1785 x = dataPropertyExpression();
1786 }
1787 if (!hasError) {
1788
1789 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1790 case DATATYPE_RESTRICTION:
1791 case DATA_INTERSECTION_OF:
1792 case DATA_UNION_OF:
1793 case DATA_COMPLEMENT_OF:
1794 case DATA_ONE_OF:
1795 case PNAME_NS:
1796 case FULL_IRI:{if (!hasError) {
1797
1798 y = dataRange();
1799 }
1800
1801 break;
1802 }
1803 default:
1804 jj_la1[23] = jj_gen;
1805 ;
1806 }
1807 }
1808 if (!hasError) {
1809
1810 jj_consume_token(CLOSE_BRACKET);
1811 }
1812
1813 if (y == nullptr) {
1814 y = getBuilder()->getTopDataRange();
1815 }
1816 cint64 cardinality = JAVACC_TO_QSTRING(n->image).toLongLong();
1817 return getBuilder()->getDataExactCardinality(x,y,cardinality);
1818 assert(false);
1819 }
1820
1821
1822 CBuildExpressionPtr OWL2FunctionalStyleParser::axiom() {CBuildExpressionPtr x = nullptr;if (!hasError) {
1823
1824 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1825 case DECLARATION:{if (!hasError) {
1826
1827 x = declaration();
1828 }
1829
1830 break;
1831 }
1832 case SUB_CLASS_OF:
1833 case EQUIVALENT_CLASSES:
1834 case DISJOINT_CLASSES:
1835 case DISJOINT_UNION:{if (!hasError) {
1836
1837 x = classAxiom();
1838 }
1839
1840 break;
1841 }
1842 case SUB_OBJECT_PROPERTY_OF:
1843 case EQUIVALENT_OBJECT_PROPERTIES:
1844 case DISJOINT_OBJECT_PROPERTIES:
1845 case OBJECT_PROPERTY_DOMAIN:
1846 case OBJECT_PROPERTY_RANGE:
1847 case INVERSE_OBJECT_PROPERTIES:
1848 case FUNCTIONAL_OBJECT_PROPERTY:
1849 case INVERSE_FUNCTIONAL_OBJECT_PROPERTY:
1850 case REFLEXIVE_OBJECT_PROPERTY:
1851 case IRREFLEXIVE_OBJECT_PROPERTY:
1852 case SYMMETRIC_OBJECT_PROPERTY:
1853 case ASYMMETRIC_OBJECT_PROPERTY:
1854 case TRANSITIVE_OBJECT_PROPERTY:{if (!hasError) {
1855
1856 x = objectPropertyAxiom();
1857 }
1858
1859 break;
1860 }
1861 case SUB_DATA_PROPERTY_OF:
1862 case EQUIVALENT_DATA_PROPERTIES:
1863 case DISJOINT_DATA_PROPERTIES:
1864 case DATA_PROPERTY_DOMAIN:
1865 case DATA_PROPERTY_RANGE:
1866 case FUNCTIONAL_DATA_PROPERTY:{if (!hasError) {
1867
1868 x = dataPropertyAxiom();
1869 }
1870
1871 break;
1872 }
1873 case DATATYPE_DEFINITION:{if (!hasError) {
1874
1875 x = datatypeDefinition();
1876 }
1877
1878 break;
1879 }
1880 case HAS_KEY:{if (!hasError) {
1881
1882 x = hasKey();
1883 }
1884
1885 break;
1886 }
1887 case SAME_INDIVIDUAL:
1888 case DIFFERENT_INDIVIDUALS:
1889 case CLASS_ASSERTION:
1890 case OBJECT_PROPERTY_ASSERTION:
1891 case NEGATIVE_OBJECT_PROPERTY_ASSERTION:
1892 case DATA_PROPERTY_ASSERTION:
1893 case NEGATIVE_DATA_PROPERTY_ASSERTION:{if (!hasError) {
1894
1895 x = assertion();
1896 }
1897
1898 break;
1899 }
1900 case ANNOTATION_ASSERTION:
1901 case SUB_ANNOTATION_PROPERTY_OF:
1902 case ANNOTATION_PROPERTY_DOMAIN:
1903 case ANNOTATION_PROPERTY_RANGE:{if (!hasError) {
1904
1905 x = annotationAxiom();
1906 }
1907
1908 break;
1909 }
1910 default:
1911 jj_la1[24] = jj_gen;
1912 jj_consume_token(-1);
1913 errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
1914 }
1915 }
1916
1917 return x;
1918 assert(false);
1919 }
1920
1921
1922 void OWL2FunctionalStyleParser::axiomAnnotations() {if (!hasError) {
1923
1924 while (!hasError) {
1925 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1926 case ANNOTATION:{
1927 ;
1928 break;
1929 }
1930 default:
1931 jj_la1[25] = jj_gen;
1932 goto end_label_9;
1933 }if (!hasError) {
1934
1935 annotation();
1936 }
1937
1938 }
1939 end_label_9: ;
1940 }
1941
1942 }
1943
1944
1945 CBuildExpressionPtr OWL2FunctionalStyleParser::classAxiom() {CBuildExpressionPtr x;if (!hasError) {
1946
1947 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1948 case SUB_CLASS_OF:{if (!hasError) {
1949
1950 x = subClassOf();
1951 }
1952
1953 break;
1954 }
1955 case EQUIVALENT_CLASSES:{if (!hasError) {
1956
1957 x = equivalentClasses();
1958 }
1959
1960 break;
1961 }
1962 case DISJOINT_CLASSES:{if (!hasError) {
1963
1964 x = disjointClasses();
1965 }
1966
1967 break;
1968 }
1969 case DISJOINT_UNION:{if (!hasError) {
1970
1971 x = disjointUnion();
1972 }
1973
1974 break;
1975 }
1976 default:
1977 jj_la1[26] = jj_gen;
1978 jj_consume_token(-1);
1979 errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
1980 }
1981 }
1982
1983 return x;
1984 assert(false);
1985 }
1986
1987
1988 CBuildExpressionPtr OWL2FunctionalStyleParser::subClassOf() {CBuildExpressionPtr x, y;if (!hasError) {
1989
1990 jj_consume_token(SUB_CLASS_OF);
1991 }
1992 if (!hasError) {
1993
1994 jj_consume_token(OPEN_BRACKET);
1995 }
1996 if (!hasError) {
1997
1998 axiomAnnotations();
1999 }
2000 if (!hasError) {
2001
2002 x = classExpression();
2003 }
2004 if (!hasError) {
2005
2006 y = classExpression();
2007 }
2008 if (!hasError) {
2009
2010 jj_consume_token(CLOSE_BRACKET);
2011 }
2012
2013 return getBuilder()->getSubClassOf(x,y);
2014 assert(false);
2015 }
2016
2017
2018 CBuildExpressionPtr OWL2FunctionalStyleParser::equivalentClasses() {CEXPRESSIONLIST<CBuildExpressionPtr> v;if (!hasError) {
2019
2020 jj_consume_token(EQUIVALENT_CLASSES);
2021 }
2022 if (!hasError) {
2023
2024 jj_consume_token(OPEN_BRACKET);
2025 }
2026 if (!hasError) {
2027
2028 axiomAnnotations();
2029 }
2030 if (!hasError) {
2031
2032 v = classExpressionList();
2033 }
2034 if (!hasError) {
2035
2036 jj_consume_token(CLOSE_BRACKET);
2037 }
2038
2039 return getBuilder()->getEquivalentClasses(v);
2040 assert(false);
2041 }
2042
2043
2044 CBuildExpressionPtr OWL2FunctionalStyleParser::disjointClasses() {CEXPRESSIONLIST<CBuildExpressionPtr> v;if (!hasError) {
2045
2046 jj_consume_token(DISJOINT_CLASSES);
2047 }
2048 if (!hasError) {
2049
2050 jj_consume_token(OPEN_BRACKET);
2051 }
2052 if (!hasError) {
2053
2054 axiomAnnotations();
2055 }
2056 if (!hasError) {
2057
2058 v = classExpressionList();
2059 }
2060 if (!hasError) {
2061
2062 jj_consume_token(CLOSE_BRACKET);
2063 }
2064
2065 return getBuilder()->getDisjointClasses(v);
2066 assert(false);
2067 }
2068
2069
2070 CBuildExpressionPtr OWL2FunctionalStyleParser::disjointUnion() {CBuildExpressionPtr x;
2071 CEXPRESSIONLIST<CBuildExpressionPtr> v;if (!hasError) {
2072
2073 jj_consume_token(DISJOINT_UNION);
2074 }
2075 if (!hasError) {
2076
2077 jj_consume_token(OPEN_BRACKET);
2078 }
2079 if (!hasError) {
2080
2081 axiomAnnotations();
2082 }
2083 if (!hasError) {
2084
2085 x = owlClass();
2086 }
2087 if (!hasError) {
2088
2089 v = classExpressionList();
2090 }
2091 if (!hasError) {
2092
2093 jj_consume_token(CLOSE_BRACKET);
2094 }
2095
2096 v.prepend(x);
2097 return getBuilder()->getDisjointUnion(v);
2098 assert(false);
2099 }
2100
2101
2102 CEXPRESSIONLIST <CBuildExpressionPtr> OWL2FunctionalStyleParser::classExpressionList() {CBuildExpressionPtr x;
2103 CEXPRESSIONLIST<CBuildExpressionPtr> v;if (!hasError) {
2104
2105 while (!hasError) {if (!hasError) {
2106
2107 x = classExpression();
2108 }
2109 if (!hasError) {
2110
2111 v.append(x);
2112 }
2113
2114 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
2115 case OBJECT_INTERSECTION_OF:
2116 case OBJECT_UNION_OF:
2117 case OBJECT_COMPLEMENT_OF:
2118 case OBJECT_ONE_OF:
2119 case OBJECT_SOME_VALUES_FROM:
2120 case OBJECT_ALL_VALUES_FROM:
2121 case OBJECT_HAS_VALUE:
2122 case OBJECT_HAS_SELF:
2123 case OBJECT_MIN_CARDINALITY:
2124 case OBJECT_MAX_CARDINALITY:
2125 case OBJECT_EXACT_CARDINALITY:
2126 case DATA_SOME_VALUES_FROM:
2127 case DATA_ALL_VALUES_FROM:
2128 case DATA_HAS_VALUE:
2129 case DATA_MIN_CARDINALITY:
2130 case DATA_MAX_CARDINALITY:
2131 case DATA_EXACT_CARDINALITY:
2132 case PNAME_NS:
2133 case FULL_IRI:{
2134 ;
2135 break;
2136 }
2137 default:
2138 jj_la1[27] = jj_gen;
2139 goto end_label_10;
2140 }
2141 }
2142 end_label_10: ;
2143 }
2144
2145 return v;
2146 assert(false);
2147 }
2148
2149
2150 CBuildExpressionPtr OWL2FunctionalStyleParser::objectPropertyAxiom() {CBuildExpressionPtr x;if (!hasError) {
2151
2152 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
2153 case SUB_OBJECT_PROPERTY_OF:{if (!hasError) {
2154
2155 x = subObjectPropertyOf();
2156 }
2157
2158 break;
2159 }
2160 case EQUIVALENT_OBJECT_PROPERTIES:{if (!hasError) {
2161
2162 x = equivalentObjectProperties();
2163 }
2164
2165 break;
2166 }
2167 case DISJOINT_OBJECT_PROPERTIES:{if (!hasError) {
2168
2169 x = disjointObjectProperties();
2170 }
2171
2172 break;
2173 }
2174 case INVERSE_OBJECT_PROPERTIES:{if (!hasError) {
2175
2176 x = inverseObjectProperties();
2177 }
2178
2179 break;
2180 }
2181 case OBJECT_PROPERTY_DOMAIN:{if (!hasError) {
2182
2183 x = objectPropertyDomain();
2184 }
2185
2186 break;
2187 }
2188 case OBJECT_PROPERTY_RANGE:{if (!hasError) {
2189
2190 x = objectPropertyRange();
2191 }
2192
2193 break;
2194 }
2195 case FUNCTIONAL_OBJECT_PROPERTY:{if (!hasError) {
2196
2197 x = functionalObjectProperty();
2198 }
2199
2200 break;
2201 }
2202 case INVERSE_FUNCTIONAL_OBJECT_PROPERTY:{if (!hasError) {
2203
2204 x = inverseFunctionalObjectProperty();
2205 }
2206
2207 break;
2208 }
2209 case REFLEXIVE_OBJECT_PROPERTY:{if (!hasError) {
2210
2211 x = reflexiveObjectProperty();
2212 }
2213
2214 break;
2215 }
2216 case IRREFLEXIVE_OBJECT_PROPERTY:{if (!hasError) {
2217
2218 x = irreflexiveObjectProperty();
2219 }
2220
2221 break;
2222 }
2223 case SYMMETRIC_OBJECT_PROPERTY:{if (!hasError) {
2224
2225 x = symmetricObjectProperty();
2226 }
2227
2228 break;
2229 }
2230 case ASYMMETRIC_OBJECT_PROPERTY:{if (!hasError) {
2231
2232 x = asymmetricObjectProperty();
2233 }
2234
2235 break;
2236 }
2237 case TRANSITIVE_OBJECT_PROPERTY:{if (!hasError) {
2238
2239 x = transitiveObjectProperty();
2240 }
2241
2242 break;
2243 }
2244 default:
2245 jj_la1[28] = jj_gen;
2246 jj_consume_token(-1);
2247 errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
2248 }
2249 }
2250
2251 return x;
2252 assert(false);
2253 }
2254
2255
2256 CBuildExpressionPtr OWL2FunctionalStyleParser::subObjectPropertyOf() {CBuildExpressionPtr x = nullptr;
2257 CBuildExpressionPtr z;if (!hasError) {
2258
2259 jj_consume_token(SUB_OBJECT_PROPERTY_OF);
2260 }
2261 if (!hasError) {
2262
2263 jj_consume_token(OPEN_BRACKET);
2264 }
2265 if (!hasError) {
2266
2267 axiomAnnotations();
2268 }
2269 if (!hasError) {
2270
2271 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
2272 case OBJECT_INVERSE_OF:
2273 case PNAME_NS:
2274 case FULL_IRI:{if (!hasError) {
2275
2276 x = objectPropertyExpression();
2277 }
2278
2279 break;
2280 }
2281 case OBJECT_PROPERTY_CHAIN:{if (!hasError) {
2282
2283 x = propertyExpressionChain();
2284 }
2285
2286 break;
2287 }
2288 default:
2289 jj_la1[29] = jj_gen;
2290 jj_consume_token(-1);
2291 errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
2292 }
2293 }
2294 if (!hasError) {
2295
2296 z = objectPropertyExpression();
2297 }
2298 if (!hasError) {
2299
2300 jj_consume_token(CLOSE_BRACKET);
2301 }
2302
2303 return getBuilder()->getSubObjectPropertyOf(x,z);
2304 assert(false);
2305 }
2306
2307
2308 CBuildExpressionPtr OWL2FunctionalStyleParser::propertyExpressionChain() {CEXPRESSIONLIST<CBuildExpressionPtr> v;if (!hasError) {
2309
2310 jj_consume_token(OBJECT_PROPERTY_CHAIN);
2311 }
2312 if (!hasError) {
2313
2314 jj_consume_token(OPEN_BRACKET);
2315 }
2316 if (!hasError) {
2317
2318 v = objectPropertyExpressionList();
2319 }
2320 if (!hasError) {
2321
2322 jj_consume_token(CLOSE_BRACKET);
2323 }
2324
2325 return getBuilder()->getObjectPropertyChain(v);
2326 assert(false);
2327 }
2328
2329
2330 CBuildExpressionPtr OWL2FunctionalStyleParser::equivalentObjectProperties() {CEXPRESSIONLIST<CBuildExpressionPtr> v;if (!hasError) {
2331
2332 jj_consume_token(EQUIVALENT_OBJECT_PROPERTIES);
2333 }
2334 if (!hasError) {
2335
2336 jj_consume_token(OPEN_BRACKET);
2337 }
2338 if (!hasError) {
2339
2340 axiomAnnotations();
2341 }
2342 if (!hasError) {
2343
2344 v = objectPropertyExpressionList();
2345 }
2346 if (!hasError) {
2347
2348 jj_consume_token(CLOSE_BRACKET);
2349 }
2350
2351 return getBuilder()->getEquivalentObjectProperties(v);
2352 assert(false);
2353 }
2354
2355
2356 CBuildExpressionPtr OWL2FunctionalStyleParser::disjointObjectProperties() {CEXPRESSIONLIST<CBuildExpressionPtr> v;if (!hasError) {
2357
2358 jj_consume_token(DISJOINT_OBJECT_PROPERTIES);
2359 }
2360 if (!hasError) {
2361
2362 jj_consume_token(OPEN_BRACKET);
2363 }
2364 if (!hasError) {
2365
2366 axiomAnnotations();
2367 }
2368 if (!hasError) {
2369
2370 v = objectPropertyExpressionList();
2371 }
2372 if (!hasError) {
2373
2374 jj_consume_token(CLOSE_BRACKET);
2375 }
2376
2377 return getBuilder()->getDisjointObjectProperties(v);
2378 assert(false);
2379 }
2380
2381
2382 CEXPRESSIONLIST <CBuildExpressionPtr> OWL2FunctionalStyleParser::objectPropertyExpressionList() {CBuildExpressionPtr x;
2383 CEXPRESSIONLIST<CBuildExpressionPtr> v;if (!hasError) {
2384
2385 while (!hasError) {if (!hasError) {
2386
2387 x = objectPropertyExpression();
2388 }
2389 if (!hasError) {
2390
2391 v.append(x);
2392 }
2393
2394 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
2395 case OBJECT_INVERSE_OF:
2396 case PNAME_NS:
2397 case FULL_IRI:{
2398 ;
2399 break;
2400 }
2401 default:
2402 jj_la1[30] = jj_gen;
2403 goto end_label_11;
2404 }
2405 }
2406 end_label_11: ;
2407 }
2408
2409 return v;
2410 assert(false);
2411 }
2412
2413
2414 CBuildExpressionPtr OWL2FunctionalStyleParser::inverseObjectProperties() {CBuildExpressionPtr x, y;if (!hasError) {
2415
2416 jj_consume_token(INVERSE_OBJECT_PROPERTIES);
2417 }
2418 if (!hasError) {
2419
2420 jj_consume_token(OPEN_BRACKET);
2421 }
2422 if (!hasError) {
2423
2424 axiomAnnotations();
2425 }
2426 if (!hasError) {
2427
2428 x = objectPropertyExpression();
2429 }
2430 if (!hasError) {
2431
2432 y = objectPropertyExpression();
2433 }
2434 if (!hasError) {
2435
2436 jj_consume_token(CLOSE_BRACKET);
2437 }
2438
2439 return getBuilder()->getInverseObjectProperties(x,y);
2440 assert(false);
2441 }
2442
2443
2444 CBuildExpressionPtr OWL2FunctionalStyleParser::objectPropertyDomain() {CBuildExpressionPtr x, y;if (!hasError) {
2445
2446 jj_consume_token(OBJECT_PROPERTY_DOMAIN);
2447 }
2448 if (!hasError) {
2449
2450 jj_consume_token(OPEN_BRACKET);
2451 }
2452 if (!hasError) {
2453
2454 axiomAnnotations();
2455 }
2456 if (!hasError) {
2457
2458 x = objectPropertyExpression();
2459 }
2460 if (!hasError) {
2461
2462 y = classExpression();
2463 }
2464 if (!hasError) {
2465
2466 jj_consume_token(CLOSE_BRACKET);
2467 }
2468
2469 return getBuilder()->getObjectPropertyDomainExpression(x,y);
2470 assert(false);
2471 }
2472
2473
2474 CBuildExpressionPtr OWL2FunctionalStyleParser::objectPropertyRange() {CBuildExpressionPtr x, y;if (!hasError) {
2475
2476 jj_consume_token(OBJECT_PROPERTY_RANGE);
2477 }
2478 if (!hasError) {
2479
2480 jj_consume_token(OPEN_BRACKET);
2481 }
2482 if (!hasError) {
2483
2484 axiomAnnotations();
2485 }
2486 if (!hasError) {
2487
2488 x = objectPropertyExpression();
2489 }
2490 if (!hasError) {
2491
2492 y = classExpression();
2493 }
2494 if (!hasError) {
2495
2496 jj_consume_token(CLOSE_BRACKET);
2497 }
2498
2499 return getBuilder()->getObjectPropertyRangeExpression(x,y);
2500 assert(false);
2501 }
2502
2503
2504 CBuildExpressionPtr OWL2FunctionalStyleParser::functionalObjectProperty() {CBuildExpressionPtr x;if (!hasError) {
2505
2506 jj_consume_token(FUNCTIONAL_OBJECT_PROPERTY);
2507 }
2508 if (!hasError) {
2509
2510 jj_consume_token(OPEN_BRACKET);
2511 }
2512 if (!hasError) {
2513
2514 axiomAnnotations();
2515 }
2516 if (!hasError) {
2517
2518 x = objectPropertyExpression();
2519 }
2520 if (!hasError) {
2521
2522 jj_consume_token(CLOSE_BRACKET);
2523 }
2524
2525 return getBuilder()->getFunctionalObjectProperty(x);
2526 assert(false);
2527 }
2528
2529
2530 CBuildExpressionPtr OWL2FunctionalStyleParser::inverseFunctionalObjectProperty() {CBuildExpressionPtr x;if (!hasError) {
2531
2532 jj_consume_token(INVERSE_FUNCTIONAL_OBJECT_PROPERTY);
2533 }
2534 if (!hasError) {
2535
2536 jj_consume_token(OPEN_BRACKET);
2537 }
2538 if (!hasError) {
2539
2540 axiomAnnotations();
2541 }
2542 if (!hasError) {
2543
2544 x = objectPropertyExpression();
2545 }
2546 if (!hasError) {
2547
2548 jj_consume_token(CLOSE_BRACKET);
2549 }
2550
2551 return getBuilder()->getInverseFunctionalObjectProperty(x);
2552 assert(false);
2553 }
2554
2555
2556 CBuildExpressionPtr OWL2FunctionalStyleParser::reflexiveObjectProperty() {CBuildExpressionPtr x;if (!hasError) {
2557
2558 jj_consume_token(REFLEXIVE_OBJECT_PROPERTY);
2559 }
2560 if (!hasError) {
2561
2562 jj_consume_token(OPEN_BRACKET);
2563 }
2564 if (!hasError) {
2565
2566 axiomAnnotations();
2567 }
2568 if (!hasError) {
2569
2570 x = objectPropertyExpression();
2571 }
2572 if (!hasError) {
2573
2574 jj_consume_token(CLOSE_BRACKET);
2575 }
2576
2577 return getBuilder()->getReflexiveObjectProperty(x);
2578 assert(false);
2579 }
2580
2581
2582 CBuildExpressionPtr OWL2FunctionalStyleParser::irreflexiveObjectProperty() {CBuildExpressionPtr x;if (!hasError) {
2583
2584 jj_consume_token(IRREFLEXIVE_OBJECT_PROPERTY);
2585 }
2586 if (!hasError) {
2587
2588 jj_consume_token(OPEN_BRACKET);
2589 }
2590 if (!hasError) {
2591
2592 axiomAnnotations();
2593 }
2594 if (!hasError) {
2595
2596 x = objectPropertyExpression();
2597 }
2598 if (!hasError) {
2599
2600 jj_consume_token(CLOSE_BRACKET);
2601 }
2602
2603 return getBuilder()->getIrreflexiveObjectProperty(x);
2604 assert(false);
2605 }
2606
2607
2608 CBuildExpressionPtr OWL2FunctionalStyleParser::symmetricObjectProperty() {CBuildExpressionPtr x;if (!hasError) {
2609
2610 jj_consume_token(SYMMETRIC_OBJECT_PROPERTY);
2611 }
2612 if (!hasError) {
2613
2614 jj_consume_token(OPEN_BRACKET);
2615 }
2616 if (!hasError) {
2617
2618 axiomAnnotations();
2619 }
2620 if (!hasError) {
2621
2622 x = objectPropertyExpression();
2623 }
2624 if (!hasError) {
2625
2626 jj_consume_token(CLOSE_BRACKET);
2627 }
2628
2629 return getBuilder()->getSymmetricObjectProperty(x);
2630 assert(false);
2631 }
2632
2633
2634 CBuildExpressionPtr OWL2FunctionalStyleParser::asymmetricObjectProperty() {CBuildExpressionPtr x;if (!hasError) {
2635
2636 jj_consume_token(ASYMMETRIC_OBJECT_PROPERTY);
2637 }
2638 if (!hasError) {
2639
2640 jj_consume_token(OPEN_BRACKET);
2641 }
2642 if (!hasError) {
2643
2644 axiomAnnotations();
2645 }
2646 if (!hasError) {
2647
2648 x = objectPropertyExpression();
2649 }
2650 if (!hasError) {
2651
2652 jj_consume_token(CLOSE_BRACKET);
2653 }
2654
2655 return getBuilder()->getAsymmetricObjectProperty(x);
2656 assert(false);
2657 }
2658
2659
2660 CBuildExpressionPtr OWL2FunctionalStyleParser::transitiveObjectProperty() {CBuildExpressionPtr x;if (!hasError) {
2661
2662 jj_consume_token(TRANSITIVE_OBJECT_PROPERTY);
2663 }
2664 if (!hasError) {
2665
2666 jj_consume_token(OPEN_BRACKET);
2667 }
2668 if (!hasError) {
2669
2670 axiomAnnotations();
2671 }
2672 if (!hasError) {
2673
2674 x = objectPropertyExpression();
2675 }
2676 if (!hasError) {
2677
2678 jj_consume_token(CLOSE_BRACKET);
2679 }
2680
2681 return getBuilder()->getTransetiveObjectProperty(x);
2682 assert(false);
2683 }
2684
2685
2686 CBuildExpressionPtr OWL2FunctionalStyleParser::dataPropertyAxiom() {CBuildExpressionPtr x;if (!hasError) {
2687
2688 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
2689 case SUB_DATA_PROPERTY_OF:{if (!hasError) {
2690
2691 x = subDataPropertyOf();
2692 }
2693
2694 break;
2695 }
2696 case EQUIVALENT_DATA_PROPERTIES:{if (!hasError) {
2697
2698 x = equivalentDataProperties();
2699 }
2700
2701 break;
2702 }
2703 case DISJOINT_DATA_PROPERTIES:{if (!hasError) {
2704
2705 x = disjointDataProperties();
2706 }
2707
2708 break;
2709 }
2710 case DATA_PROPERTY_DOMAIN:{if (!hasError) {
2711
2712 x = dataPropertyDomain();
2713 }
2714
2715 break;
2716 }
2717 case DATA_PROPERTY_RANGE:{if (!hasError) {
2718
2719 x = dataPropertyRange();
2720 }
2721
2722 break;
2723 }
2724 case FUNCTIONAL_DATA_PROPERTY:{if (!hasError) {
2725
2726 x = functionalDataProperty();
2727 }
2728
2729 break;
2730 }
2731 default:
2732 jj_la1[31] = jj_gen;
2733 jj_consume_token(-1);
2734 errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
2735 }
2736 }
2737
2738 return x;
2739 assert(false);
2740 }
2741
2742
2743 CBuildExpressionPtr OWL2FunctionalStyleParser::subDataPropertyOf() {CBuildExpressionPtr x,y;if (!hasError) {
2744
2745 jj_consume_token(SUB_DATA_PROPERTY_OF);
2746 }
2747 if (!hasError) {
2748
2749 jj_consume_token(OPEN_BRACKET);
2750 }
2751 if (!hasError) {
2752
2753 axiomAnnotations();
2754 }
2755 if (!hasError) {
2756
2757 x = dataPropertyExpression();
2758 }
2759 if (!hasError) {
2760
2761 y = dataPropertyExpression();
2762 }
2763 if (!hasError) {
2764
2765 jj_consume_token(CLOSE_BRACKET);
2766 }
2767
2768 return getBuilder()->getSubDataPropertyOf(x,y);
2769 assert(false);
2770 }
2771
2772
2773 CBuildExpressionPtr OWL2FunctionalStyleParser::equivalentDataProperties() {CEXPRESSIONLIST<CBuildExpressionPtr> v;if (!hasError) {
2774
2775 jj_consume_token(EQUIVALENT_DATA_PROPERTIES);
2776 }
2777 if (!hasError) {
2778
2779 jj_consume_token(OPEN_BRACKET);
2780 }
2781 if (!hasError) {
2782
2783 axiomAnnotations();
2784 }
2785 if (!hasError) {
2786
2787 v = dataPropertyExpressionList();
2788 }
2789 if (!hasError) {
2790
2791 jj_consume_token(CLOSE_BRACKET);
2792 }
2793
2794 return getBuilder()->getEquivalentDataProperties(v);
2795 assert(false);
2796 }
2797
2798
2799 CBuildExpressionPtr OWL2FunctionalStyleParser::disjointDataProperties() {CEXPRESSIONLIST<CBuildExpressionPtr> v;if (!hasError) {
2800
2801 jj_consume_token(DISJOINT_DATA_PROPERTIES);
2802 }
2803 if (!hasError) {
2804
2805 jj_consume_token(OPEN_BRACKET);
2806 }
2807 if (!hasError) {
2808
2809 axiomAnnotations();
2810 }
2811 if (!hasError) {
2812
2813 v = dataPropertyExpressionList();
2814 }
2815 if (!hasError) {
2816
2817 jj_consume_token(CLOSE_BRACKET);
2818 }
2819
2820 return getBuilder()->getDisjointDataProperties(v);
2821 assert(false);
2822 }
2823
2824
2825 CEXPRESSIONLIST <CBuildExpressionPtr> OWL2FunctionalStyleParser::dataPropertyExpressionList() {CBuildExpressionPtr x;
2826 CEXPRESSIONLIST<CBuildExpressionPtr> v;if (!hasError) {
2827
2828 while (!hasError) {if (!hasError) {
2829
2830 x = dataPropertyExpression();
2831 }
2832 if (!hasError) {
2833
2834 v.append(x);
2835 }
2836
2837 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
2838 case PNAME_NS:
2839 case FULL_IRI:{
2840 ;
2841 break;
2842 }
2843 default:
2844 jj_la1[32] = jj_gen;
2845 goto end_label_12;
2846 }
2847 }
2848 end_label_12: ;
2849 }
2850
2851 return v;
2852 assert(false);
2853 }
2854
2855
2856 CBuildExpressionPtr OWL2FunctionalStyleParser::dataPropertyDomain() {CBuildExpressionPtr x, y;if (!hasError) {
2857
2858 jj_consume_token(DATA_PROPERTY_DOMAIN);
2859 }
2860 if (!hasError) {
2861
2862 jj_consume_token(OPEN_BRACKET);
2863 }
2864 if (!hasError) {
2865
2866 axiomAnnotations();
2867 }
2868 if (!hasError) {
2869
2870 x = dataPropertyExpression();
2871 }
2872 if (!hasError) {
2873
2874 y = classExpression();
2875 }
2876 if (!hasError) {
2877
2878 jj_consume_token(CLOSE_BRACKET);
2879 }
2880
2881 return getBuilder()->getDataPropertyDomainExpression(x,y);
2882 assert(false);
2883 }
2884
2885
2886 CBuildExpressionPtr OWL2FunctionalStyleParser::dataPropertyRange() {CBuildExpressionPtr x, y;if (!hasError) {
2887
2888 jj_consume_token(DATA_PROPERTY_RANGE);
2889 }
2890 if (!hasError) {
2891
2892 jj_consume_token(OPEN_BRACKET);
2893 }
2894 if (!hasError) {
2895
2896 axiomAnnotations();
2897 }
2898 if (!hasError) {
2899
2900 x = dataPropertyExpression();
2901 }
2902 if (!hasError) {
2903
2904 y = dataRange();
2905 }
2906 if (!hasError) {
2907
2908 jj_consume_token(CLOSE_BRACKET);
2909 }
2910
2911 return getBuilder()->getDataPropertyRangeExpression(x,y);
2912 assert(false);
2913 }
2914
2915
2916 CBuildExpressionPtr OWL2FunctionalStyleParser::functionalDataProperty() {CBuildExpressionPtr x;if (!hasError) {
2917
2918 jj_consume_token(FUNCTIONAL_DATA_PROPERTY);
2919 }
2920 if (!hasError) {
2921
2922 jj_consume_token(OPEN_BRACKET);
2923 }
2924 if (!hasError) {
2925
2926 axiomAnnotations();
2927 }
2928 if (!hasError) {
2929
2930 x = dataPropertyExpression();
2931 }
2932 if (!hasError) {
2933
2934 jj_consume_token(CLOSE_BRACKET);
2935 }
2936
2937 return getBuilder()->getFunctionalDataProperty(x);
2938 assert(false);
2939 }
2940
2941
2942 CBuildExpressionPtr OWL2FunctionalStyleParser::datatypeDefinition() {if (!hasError) {
2943
2944 jj_consume_token(DATATYPE_DEFINITION);
2945 }
2946 if (!hasError) {
2947
2948 jj_consume_token(OPEN_BRACKET);
2949 }
2950 if (!hasError) {
2951
2952 axiomAnnotations();
2953 }
2954 if (!hasError) {
2955
2956 datatype();
2957 }
2958 if (!hasError) {
2959
2960 dataRange();
2961 }
2962 if (!hasError) {
2963
2964 jj_consume_token(CLOSE_BRACKET);
2965 }
2966
2967 return nullptr;
2968 assert(false);
2969 }
2970
2971
2972 CBuildExpressionPtr OWL2FunctionalStyleParser::hasKey() {if (!hasError) {
2973
2974 jj_consume_token(HAS_KEY);
2975 }
2976 if (!hasError) {
2977
2978 jj_consume_token(OPEN_BRACKET);
2979 }
2980 if (!hasError) {
2981
2982 axiomAnnotations();
2983 }
2984 if (!hasError) {
2985
2986 classExpression();
2987 }
2988 if (!hasError) {
2989
2990 jj_consume_token(OPEN_BRACKET);
2991 }
2992 if (!hasError) {
2993
2994 while (!hasError) {
2995 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
2996 case OBJECT_INVERSE_OF:
2997 case PNAME_NS:
2998 case FULL_IRI:{
2999 ;
3000 break;
3001 }
3002 default:
3003 jj_la1[33] = jj_gen;
3004 goto end_label_13;
3005 }if (!hasError) {
3006
3007 objectPropertyExpression();
3008 }
3009
3010 }
3011 end_label_13: ;
3012 }
3013 if (!hasError) {
3014
3015 jj_consume_token(CLOSE_BRACKET);
3016 }
3017 if (!hasError) {
3018
3019 jj_consume_token(OPEN_BRACKET);
3020 }
3021 if (!hasError) {
3022
3023 while (!hasError) {
3024 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
3025 case OBJECT_INVERSE_OF:
3026 case PNAME_NS:
3027 case FULL_IRI:{
3028 ;
3029 break;
3030 }
3031 default:
3032 jj_la1[34] = jj_gen;
3033 goto end_label_14;
3034 }if (!hasError) {
3035
3036 objectPropertyExpression();
3037 }
3038
3039 }
3040 end_label_14: ;
3041 }
3042 if (!hasError) {
3043
3044 jj_consume_token(CLOSE_BRACKET);
3045 }
3046 if (!hasError) {
3047
3048 jj_consume_token(CLOSE_BRACKET);
3049 }
3050
3051 return nullptr;
3052 assert(false);
3053 }
3054
3055
3056 CBuildExpressionPtr OWL2FunctionalStyleParser::assertion() {CBuildExpressionPtr x;if (!hasError) {
3057
3058 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
3059 case SAME_INDIVIDUAL:{if (!hasError) {
3060
3061 x = sameIndividual();
3062 }
3063
3064 break;
3065 }
3066 case DIFFERENT_INDIVIDUALS:{if (!hasError) {
3067
3068 x = differentIndividuals();
3069 }
3070
3071 break;
3072 }
3073 case CLASS_ASSERTION:{if (!hasError) {
3074
3075 x = classAssertion();
3076 }
3077
3078 break;
3079 }
3080 case OBJECT_PROPERTY_ASSERTION:{if (!hasError) {
3081
3082 x = objectPropertyAssertion();
3083 }
3084
3085 break;
3086 }
3087 case NEGATIVE_OBJECT_PROPERTY_ASSERTION:{if (!hasError) {
3088
3089 x = negativeObjectPropertyAssertion();
3090 }
3091
3092 break;
3093 }
3094 case DATA_PROPERTY_ASSERTION:{if (!hasError) {
3095
3096 x = dataPropertyAssertion();
3097 }
3098
3099 break;
3100 }
3101 case NEGATIVE_DATA_PROPERTY_ASSERTION:{if (!hasError) {
3102
3103 x = negativeDataPropertyAssertion();
3104 }
3105
3106 break;
3107 }
3108 default:
3109 jj_la1[35] = jj_gen;
3110 jj_consume_token(-1);
3111 errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
3112 }
3113 }
3114
3115 return x;
3116 assert(false);
3117 }
3118
3119
3120 CBuildExpressionPtr OWL2FunctionalStyleParser::sameIndividual() {CEXPRESSIONLIST<CBuildExpressionPtr> v;if (!hasError) {
3121
3122 jj_consume_token(SAME_INDIVIDUAL);
3123 }
3124 if (!hasError) {
3125
3126 jj_consume_token(OPEN_BRACKET);
3127 }
3128 if (!hasError) {
3129
3130 axiomAnnotations();
3131 }
3132 if (!hasError) {
3133
3134 v = individualList();
3135 }
3136 if (!hasError) {
3137
3138 jj_consume_token(CLOSE_BRACKET);
3139 }
3140
3141 return getBuilder()->getSameIndividual(v);
3142 assert(false);
3143 }
3144
3145
3146 CBuildExpressionPtr OWL2FunctionalStyleParser::differentIndividuals() {CEXPRESSIONLIST<CBuildExpressionPtr> v;if (!hasError) {
3147
3148 jj_consume_token(DIFFERENT_INDIVIDUALS);
3149 }
3150 if (!hasError) {
3151
3152 jj_consume_token(OPEN_BRACKET);
3153 }
3154 if (!hasError) {
3155
3156 axiomAnnotations();
3157 }
3158 if (!hasError) {
3159
3160 v = individualList();
3161 }
3162 if (!hasError) {
3163
3164 jj_consume_token(CLOSE_BRACKET);
3165 }
3166
3167 return getBuilder()->getDifferentIndividuals(v);
3168 assert(false);
3169 }
3170
3171
3172 CEXPRESSIONLIST <CBuildExpressionPtr> OWL2FunctionalStyleParser::individualList() {CBuildExpressionPtr x;
3173 CEXPRESSIONLIST<CBuildExpressionPtr> v;if (!hasError) {
3174
3175 while (!hasError) {if (!hasError) {
3176
3177 x = individual();
3178 }
3179 if (!hasError) {
3180
3181 v.append(x);
3182 }
3183
3184 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
3185 case PNAME_NS:
3186 case BLANK_NODE_PREFIX:
3187 case FULL_IRI:{
3188 ;
3189 break;
3190 }
3191 default:
3192 jj_la1[36] = jj_gen;
3193 goto end_label_15;
3194 }
3195 }
3196 end_label_15: ;
3197 }
3198
3199 return v;
3200 assert(false);
3201 }
3202
3203
3204 CBuildExpressionPtr OWL2FunctionalStyleParser::classAssertion() {CBuildExpressionPtr x, y;if (!hasError) {
3205
3206 jj_consume_token(CLASS_ASSERTION);
3207 }
3208 if (!hasError) {
3209
3210 jj_consume_token(OPEN_BRACKET);
3211 }
3212 if (!hasError) {
3213
3214 axiomAnnotations();
3215 }
3216 if (!hasError) {
3217
3218 x = classExpression();
3219 }
3220 if (!hasError) {
3221
3222 y = individual();
3223 }
3224 if (!hasError) {
3225
3226 jj_consume_token(CLOSE_BRACKET);
3227 }
3228
3229 return getBuilder()->getClassAssertion(x,y);
3230 assert(false);
3231 }
3232
3233
3234 CBuildExpressionPtr OWL2FunctionalStyleParser::objectPropertyAssertion() {CBuildExpressionPtr x, y, z;if (!hasError) {
3235
3236 jj_consume_token(OBJECT_PROPERTY_ASSERTION);
3237 }
3238 if (!hasError) {
3239
3240 jj_consume_token(OPEN_BRACKET);
3241 }
3242 if (!hasError) {
3243
3244 axiomAnnotations();
3245 }
3246 if (!hasError) {
3247
3248 x = objectPropertyExpression();
3249 }
3250 if (!hasError) {
3251
3252 y = individual();
3253 }
3254 if (!hasError) {
3255
3256 z = individual();
3257 }
3258 if (!hasError) {
3259
3260 jj_consume_token(CLOSE_BRACKET);
3261 }
3262
3263 return getBuilder()->getObjectPropertyAssertion(x,y,z);
3264 assert(false);
3265 }
3266
3267
3268 CBuildExpressionPtr OWL2FunctionalStyleParser::negativeObjectPropertyAssertion() {CBuildExpressionPtr x, y, z;if (!hasError) {
3269
3270 jj_consume_token(NEGATIVE_OBJECT_PROPERTY_ASSERTION);
3271 }
3272 if (!hasError) {
3273
3274 jj_consume_token(OPEN_BRACKET);
3275 }
3276 if (!hasError) {
3277
3278 axiomAnnotations();
3279 }
3280 if (!hasError) {
3281
3282 x = objectPropertyExpression();
3283 }
3284 if (!hasError) {
3285
3286 y = individual();
3287 }
3288 if (!hasError) {
3289
3290 z = individual();
3291 }
3292 if (!hasError) {
3293
3294 jj_consume_token(CLOSE_BRACKET);
3295 }
3296
3297 return getBuilder()->getNegativeObjectPropertyAssertion(x,y,z);
3298 assert(false);
3299 }
3300
3301
3302 CBuildExpressionPtr OWL2FunctionalStyleParser::dataPropertyAssertion() {CBuildExpressionPtr x, y, z;if (!hasError) {
3303
3304 jj_consume_token(DATA_PROPERTY_ASSERTION);
3305 }
3306 if (!hasError) {
3307
3308 jj_consume_token(OPEN_BRACKET);
3309 }
3310 if (!hasError) {
3311
3312 axiomAnnotations();
3313 }
3314 if (!hasError) {
3315
3316 x = dataPropertyExpression();
3317 }
3318 if (!hasError) {
3319
3320 y = individual();
3321 }
3322 if (!hasError) {
3323
3324 z = literal(false);
3325 }
3326 if (!hasError) {
3327
3328 jj_consume_token(CLOSE_BRACKET);
3329 }
3330
3331 return getBuilder()->getDataPropertyAssertion(x,y,z);
3332 assert(false);
3333 }
3334
3335
3336 CBuildExpressionPtr OWL2FunctionalStyleParser::negativeDataPropertyAssertion() {CBuildExpressionPtr x, y, z;if (!hasError) {
3337
3338 jj_consume_token(NEGATIVE_DATA_PROPERTY_ASSERTION);
3339 }
3340 if (!hasError) {
3341
3342 jj_consume_token(OPEN_BRACKET);
3343 }
3344 if (!hasError) {
3345
3346 axiomAnnotations();
3347 }
3348 if (!hasError) {
3349
3350 x = dataPropertyExpression();
3351 }
3352 if (!hasError) {
3353
3354 y = individual();
3355 }
3356 if (!hasError) {
3357
3358 z = literal(false);
3359 }
3360 if (!hasError) {
3361
3362 jj_consume_token(CLOSE_BRACKET);
3363 }
3364
3365 return getBuilder()->getNegativeDataPropertyAssertion(x,y,z);
3366 assert(false);
3367 }
3368
3369
3370 CBuildExpressionPtr OWL2FunctionalStyleParser::annotation() {if (!hasError) {
3371
3372 jj_consume_token(ANNOTATION);
3373 }
3374 if (!hasError) {
3375
3376 jj_consume_token(OPEN_BRACKET);
3377 }
3378 if (!hasError) {
3379
3380 annotationAnnotations();
3381 }
3382 if (!hasError) {
3383
3384 annotationProperty();
3385 }
3386 if (!hasError) {
3387
3388 annotationValue();
3389 }
3390 if (!hasError) {
3391
3392 jj_consume_token(CLOSE_BRACKET);
3393 }
3394
3395 return nullptr;
3396 assert(false);
3397 }
3398
3399
3400 void OWL2FunctionalStyleParser::annotationAnnotations() {if (!hasError) {
3401
3402 while (!hasError) {
3403 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
3404 case ANNOTATION:{
3405 ;
3406 break;
3407 }
3408 default:
3409 jj_la1[37] = jj_gen;
3410 goto end_label_16;
3411 }if (!hasError) {
3412
3413 annotation();
3414 }
3415
3416 }
3417 end_label_16: ;
3418 }
3419
3420 }
3421
3422
3423 CBuildExpressionPtr OWL2FunctionalStyleParser::annotationValue() {if (!hasError) {
3424
3425 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
3426 case BLANK_NODE_PREFIX:{if (!hasError) {
3427
3428 anonymousIndividual();
3429 }
3430
3431 break;
3432 }
3433 case PNAME_NS:
3434 case FULL_IRI:{if (!hasError) {
3435
3436 iri();
3437 }
3438
3439 break;
3440 }
3441 case QUOTED_QString:{if (!hasError) {
3442
3443 literal(true);
3444 }
3445
3446 break;
3447 }
3448 default:
3449 jj_la1[38] = jj_gen;
3450 jj_consume_token(-1);
3451 errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
3452 }
3453 }
3454
3455 return nullptr;
3456 assert(false);
3457 }
3458
3459
3460 CBuildExpressionPtr OWL2FunctionalStyleParser::annotationAxiom() {if (!hasError) {
3461
3462 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
3463 case ANNOTATION_ASSERTION:{if (!hasError) {
3464
3465 annotationAssertion();
3466 }
3467
3468 break;
3469 }
3470 case SUB_ANNOTATION_PROPERTY_OF:{if (!hasError) {
3471
3472 subAnnotationPropertyOf();
3473 }
3474
3475 break;
3476 }
3477 case ANNOTATION_PROPERTY_DOMAIN:{if (!hasError) {
3478
3479 annotationPropertyDomain();
3480 }
3481
3482 break;
3483 }
3484 case ANNOTATION_PROPERTY_RANGE:{if (!hasError) {
3485
3486 annotationPropertyRange();
3487 }
3488
3489 break;
3490 }
3491 default:
3492 jj_la1[39] = jj_gen;
3493 jj_consume_token(-1);
3494 errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
3495 }
3496 }
3497
3498 return nullptr;
3499 assert(false);
3500 }
3501
3502
3503 CBuildExpressionPtr OWL2FunctionalStyleParser::annotationAssertion() {if (!hasError) {
3504
3505 jj_consume_token(ANNOTATION_ASSERTION);
3506 }
3507 if (!hasError) {
3508
3509 jj_consume_token(OPEN_BRACKET);
3510 }
3511 if (!hasError) {
3512
3513 axiomAnnotations();
3514 }
3515 if (!hasError) {
3516
3517 annotationProperty();
3518 }
3519 if (!hasError) {
3520
3521 annotationSubject();
3522 }
3523 if (!hasError) {
3524
3525 annotationValue();
3526 }
3527 if (!hasError) {
3528
3529 jj_consume_token(CLOSE_BRACKET);
3530 }
3531
3532 return nullptr;
3533 assert(false);
3534 }
3535
3536
3537 CBuildExpressionPtr OWL2FunctionalStyleParser::annotationSubject() {if (!hasError) {
3538
3539 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
3540 case PNAME_NS:
3541 case FULL_IRI:{if (!hasError) {
3542
3543 iri();
3544 }
3545
3546 break;
3547 }
3548 case BLANK_NODE_PREFIX:{if (!hasError) {
3549
3550 anonymousIndividual();
3551 }
3552
3553 break;
3554 }
3555 default:
3556 jj_la1[40] = jj_gen;
3557 jj_consume_token(-1);
3558 errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
3559 }
3560 }
3561
3562 return nullptr;
3563 assert(false);
3564 }
3565
3566
3567 CBuildExpressionPtr OWL2FunctionalStyleParser::subAnnotationPropertyOf() {if (!hasError) {
3568
3569 jj_consume_token(SUB_ANNOTATION_PROPERTY_OF);
3570 }
3571 if (!hasError) {
3572
3573 jj_consume_token(OPEN_BRACKET);
3574 }
3575 if (!hasError) {
3576
3577 axiomAnnotations();
3578 }
3579 if (!hasError) {
3580
3581 annotationProperty();
3582 }
3583 if (!hasError) {
3584
3585 annotationProperty();
3586 }
3587 if (!hasError) {
3588
3589 jj_consume_token(CLOSE_BRACKET);
3590 }
3591
3592 return nullptr;
3593 assert(false);
3594 }
3595
3596
3597 CBuildExpressionPtr OWL2FunctionalStyleParser::annotationPropertyDomain() {if (!hasError) {
3598
3599 jj_consume_token(ANNOTATION_PROPERTY_DOMAIN);
3600 }
3601 if (!hasError) {
3602
3603 jj_consume_token(OPEN_BRACKET);
3604 }
3605 if (!hasError) {
3606
3607 axiomAnnotations();
3608 }
3609 if (!hasError) {
3610
3611 annotationProperty();
3612 }
3613 if (!hasError) {
3614
3615 iri();
3616 }
3617 if (!hasError) {
3618
3619 jj_consume_token(CLOSE_BRACKET);
3620 }
3621
3622 return nullptr;
3623 assert(false);
3624 }
3625
3626
3627 CBuildExpressionPtr OWL2FunctionalStyleParser::annotationPropertyRange() {if (!hasError) {
3628
3629 jj_consume_token(ANNOTATION_PROPERTY_RANGE);
3630 }
3631 if (!hasError) {
3632
3633 jj_consume_token(OPEN_BRACKET);
3634 }
3635 if (!hasError) {
3636
3637 axiomAnnotations();
3638 }
3639 if (!hasError) {
3640
3641 annotationProperty();
3642 }
3643 if (!hasError) {
3644
3645 iri();
3646 }
3647 if (!hasError) {
3648
3649 jj_consume_token(CLOSE_BRACKET);
3650 }
3651
3652 return nullptr;
3653 assert(false);
3654 }
3655
3656
3657 OWL2FunctionalStyleParser::OWL2FunctionalStyleParser(TokenManager *tm) : CJAVACCParser()
3658 {
3659 head = NULL;
3660 ReInit(tm);
3661 }
3662 OWL2FunctionalStyleParser::~OWL2FunctionalStyleParser()
3663 {
3664 if (token_source) delete token_source;
3665 if (head) {
3666 Token *next, *t = head;
3667 while (t) {
3668 next = t->next;
3669 delete t;
3670 t = next;
3671 }
3672 }
3673 if (errorHandlerCreated) {
3674 delete errorHandler;
3675 }
3676 }
3677
3678 void OWL2FunctionalStyleParser::ReInit(TokenManager *tm){
3679 if (head) delete head;
3680 errorHandler = new ErrorHandler();
3681 errorHandlerCreated = true;
3682 hasError = false;
3683 token_source = tm;
3684 head = token = new Token();
3685 token->kind = 0;
3686 token->next = NULL;
3687 jj_lookingAhead = false;
3688 jj_rescan = false;
3689 jj_done = false;
3690 jj_scanpos = jj_lastpos = NULL;
3691 jj_gc = 0;
3692 jj_kind = -1;
3693 trace_indent = 0;
3694 trace_enabled = false;
3695 jj_ntk = -1;
3696 jj_gen = 0;
3697 for (int i = 0; i < 41; i++) jj_la1[i] = -1;
3698 }
3699
3700
3701 Token * OWL2FunctionalStyleParser::jj_consume_token(int kind) {
3702 Token *oldToken;
3703 if ((oldToken = token)->next != NULL) token = token->next;
3704 else token = token->next = token_source->getNextToken();
3705 jj_ntk = -1;
3706 if (token->kind == kind) {
3707 jj_gen++;
3708 return token;
3709 }
3710 token = oldToken;
3711 jj_kind = kind;
3712 JAVACC_STRING_TYPE image = kind >= 0 ? tokenImage[kind] : tokenImage[0];
3713 errorHandler->handleUnexpectedToken(kind, image.substr(1, image.size() - 2), getToken(1), this), hasError = true;
3714 return token;
3715 }
3716
3717
3718 /** Get the next Token. */
3719
3720 Token * OWL2FunctionalStyleParser::getNextToken(){
3721 if (token->next != NULL) token = token->next;
3722 else token = token->next = token_source->getNextToken();
3723 jj_ntk = -1;
3724 jj_gen++;
3725 return token;
3726 }
3727
3728 /** Get the specific Token. */
3729
3730 Token * OWL2FunctionalStyleParser::getToken(int index){
3731 Token *t = token;
3732 for (int i = 0; i < index; i++) {
3733 if (t->next != NULL) t = t->next;
3734 else t = t->next = token_source->getNextToken();
3735 }
3736 return t;
3737 }
3738
3739
3740 int OWL2FunctionalStyleParser::jj_ntk_f(){
3741 if ((jj_nt=token->next) == NULL)
3742 return (jj_ntk = (token->next=token_source->getNextToken())->kind);
3743 else
3744 return (jj_ntk = jj_nt->kind);
3745 }
3746
3747
3748 void OWL2FunctionalStyleParser::parseError() {
3749 fprintf(stderr, "Parse error at: %d:%d, after token: %s encountered: %s\n", token->beginLine, token->beginColumn, addUnicodeEscapes(token->image).c_str(), addUnicodeEscapes(getToken(1)->image).c_str());
3750 }
3751
3752
3753 void OWL2FunctionalStyleParser::enable_tracing() {
3754 }
3755
3756 /** Disable tracing. */
3757
3758 void OWL2FunctionalStyleParser::disable_tracing() {
3759 }
3760
3761
3762 }
3763 }
3764 }