Debian Codegraph @

Source/Parser/FunctionalJAVACC/OWL2FunctionalJAVACCGrammer.jj

raw
1 // OWL 2 Functional Grammer: http://www.w3.org/TR/owl2-syntax/#Appendix:_Complete_Grammar_.28Normative.29
2 // EBNF Grammer of OWL 2 Functional Style: http://answers.semanticweb.com/questions/19985/ebnf-grammar-for-owl2-functional-style-syntax
3
4
5 options
6 {
7 OUTPUT_LANGUAGE = "c++";
8 UNICODE_INPUT = true;
9 NAMESPACE = "Konclude::Parser::FunctionalJAVACC";
10 TOKEN_MANAGER_SUPER_CLASS = "CTokenManager";
11 TOKEN_MANAGER_INCLUDES = "CTokenManager.h";
12 PARSER_INCLUDES = "CJAVACCParser.h";
13 PARSER_SUPER_CLASS = "CJAVACCParser";
14 TOKEN_EXTENDS = "CTokenBase";
15 TOKEN_INCLUDES = "CTokenBase.h";
16
17
18 // CACHE_TOKENS = true;
19 // OUTPUT_DIRECTORY = "gen";
20 // STATIC = false;
21 }
22
23 PARSER_BEGIN(OWL2FunctionalStyleParser)
24
25 public:
26 inline COntologyBuilder* getBuilder() {
27 return mBuilder;
28 }
29
30 protected:
31 COntologyBuilder* mBuilder;
32
33
34
35 PARSER_END(OWL2FunctionalStyleParser)
36
37
38 SKIP :
39 {
40 " "
41 | "\t"
42 | "\n"
43 | "\r"
44 }
45
46 TOKEN :
47 {
48 < OPEN_BRACKET: "(" >
49 | < CLOSE_BRACKET: ")" >
50 | < EQUALS: "=" >
51 | < REFERENCE: "^^" >
52
53
54
55 /* Ontology Keywords */
56 | < PREFIX: "Prefix" >
57 | < ONTOLOGY: "Ontology" >
58 | < IMPORT: "Import" >
59
60 /* Entities and Literals */
61 | < CLASS: "Class" >
62 | < DATATYPE: "Datatype" >
63 | < OBJECT_PROPERTY: "ObjectProperty" >
64 | < DATA_PROPERTY: "DataProperty" >
65 | < ANNOTATION_PROPERTY: "AnnotationProperty" >
66 | < NAMED_INDIVIDUAL: "NamedIndividual" >
67
68 /* Declaration */
69 | < DECLARATION: "Declaration" >
70
71 /* Property Expressions */
72 | < OBJECT_INVERSE_OF: "ObjectInverseOf" >
73 | < OBJECT_PROPERTY_CHAIN: "ObjectPropertyChain" >
74
75 /* Data Ranges */
76 | < COMPLEMENT_OF: "ComplementOf" >
77 | < ONE_OF: "OneOf" >
78 | < DATATYPE_RESTRICTION: "DatatypeRestriction" >
79
80 /* Class Expressions */
81 | < OBJECT_INTERSECTION_OF: "ObjectIntersectionOf" >
82 | < OBJECT_UNION_OF: "ObjectUnionOf" >
83 | < OBJECT_COMPLEMENT_OF: "ObjectComplementOf" >
84 | < OBJECT_ONE_OF: "ObjectOneOf" >
85 | < OBJECT_SOME_VALUES_FROM: "ObjectSomeValuesFrom" >
86 | < OBJECT_ALL_VALUES_FROM: "ObjectAllValuesFrom" >
87 | < OBJECT_HAS_VALUE: "ObjectHasValue" >
88 | < OBJECT_HAS_SELF: "ObjectHasSelf" >
89 | < OBJECT_MIN_CARDINALITY: "ObjectMinCardinality" >
90 | < OBJECT_MAX_CARDINALITY: "ObjectMaxCardinality" >
91 | < OBJECT_EXACT_CARDINALITY: "ObjectExactCardinality" >
92 | < DATA_INTERSECTION_OF: "DataIntersectionOf" >
93 | < DATA_UNION_OF: "DataUnionOf" >
94 | < DATA_COMPLEMENT_OF: "DataComplementOf" >
95 | < DATA_ONE_OF: "DataOneOf" >
96 | < DATA_SOME_VALUES_FROM: "DataSomeValuesFrom" >
97 | < DATA_ALL_VALUES_FROM: "DataAllValuesFrom" >
98 | < DATA_HAS_VALUE: "DataHasValue" >
99 | < DATA_MIN_CARDINALITY: "DataMinCardinality" >
100 | < DATA_MAX_CARDINALITY: "DataMaxCardinality" >
101 | < DATA_EXACT_CARDINALITY: "DataExactCardinality" >
102
103 /* Class Expressions Axioms */
104 | < SUB_CLASS_OF: "SubClassOf" >
105 | < EQUIVALENT_CLASSES: "EquivalentClasses" >
106 | < DISJOINT_CLASSES: "DisjointClasses" >
107 | < DISJOINT_UNION: "DisjointUnion" >
108
109 /* Object Property Axioms */
110 | < SUB_OBJECT_PROPERTY_OF: "SubObjectPropertyOf" >
111 | < EQUIVALENT_OBJECT_PROPERTIES: "EquivalentObjectProperties" >
112 | < DISJOINT_OBJECT_PROPERTIES: "DisjointObjectProperties" >
113 | < OBJECT_PROPERTY_DOMAIN: "ObjectPropertyDomain" >
114 | < OBJECT_PROPERTY_RANGE: "ObjectPropertyRange" >
115 | < INVERSE_OBJECT_PROPERTIES: "InverseObjectProperties" >
116 | < FUNCTIONAL_OBJECT_PROPERTY: "FunctionalObjectProperty" >
117 | < INVERSE_FUNCTIONAL_OBJECT_PROPERTY: "InverseFunctionalObjectProperty" >
118 | < REFLEXIVE_OBJECT_PROPERTY: "ReflexiveObjectProperty" >
119 | < IRREFLEXIVE_OBJECT_PROPERTY: "IrreflexiveObjectProperty" >
120 | < SYMMETRIC_OBJECT_PROPERTY: "SymmetricObjectProperty" >
121 | < ASYMMETRIC_OBJECT_PROPERTY: "AsymmetricObjectProperty" >
122 | < TRANSITIVE_OBJECT_PROPERTY: "TransitiveObjectProperty" >
123
124 /* Data Property Axioms */
125 | < SUB_DATA_PROPERTY_OF: "SubDataPropertyOf" >
126 | < EQUIVALENT_DATA_PROPERTIES: "EquivalentDataProperties" >
127 | < DISJOINT_DATA_PROPERTIES: "DisjointDataProperties" >
128 | < DATA_PROPERTY_DOMAIN: "DataPropertyDomain" >
129 | < DATA_PROPERTY_RANGE: "DataPropertyRange" >
130 | < FUNCTIONAL_DATA_PROPERTY: "FunctionalDataProperty" >
131 | < DATATYPE_DEFINITION: "DatatypeDefinition" >
132
133 /* Keys */
134 | < HAS_KEY: "HasKey" >
135
136 /* Assertions */
137 | < SAME_INDIVIDUAL: "SameIndividual" >
138 | < DIFFERENT_INDIVIDUALS: "DifferentIndividuals" >
139 | < CLASS_ASSERTION: "ClassAssertion" >
140 | < OBJECT_PROPERTY_ASSERTION: "ObjectPropertyAssertion" >
141 | < NEGATIVE_OBJECT_PROPERTY_ASSERTION: "NegativeObjectPropertyAssertion" >
142 | < DATA_PROPERTY_ASSERTION: "DataPropertyAssertion" >
143 | < NEGATIVE_DATA_PROPERTY_ASSERTION: "NegativeDataPropertyAssertion" >
144
145 /* Annotations */
146 | < ANNOTATION: "Annotation" >
147 | < ANNOTATION_ASSERTION: "AnnotationAssertion" >
148 | < SUB_ANNOTATION_PROPERTY_OF: "SubAnnotationPropertyOf" >
149 | < ANNOTATION_PROPERTY_DOMAIN: "AnnotationPropertyDomain" >
150 | < ANNOTATION_PROPERTY_RANGE: "AnnotationPropertyRange" >
151
152 | < NON_NEGATIVE_INTEGER: (<DIGIT>)+ >
153 | < LANGTAG: "@" ( ["a"-"z","A"-"Z"])+ ("-" (["a"-"z","A"-"Z"]|<DIGIT>)+ )* >
154
155 | < PNAME_NS: (<PN_PREFIX>)? ":" > : AfterPrefix
156 | < #PN_PREFIX: <PN_CHARS_BASE> ( ( <PN_CHARS> | "." )* <PN_CHARS> )? >
157 | < BLANK_NODE_PREFIX: "_:" > : AfterPrefix
158 // | < PNAME_LN: <PNAME_NS> <PN_LOCAL> >
159 // | < BLANK_NODE_LABEL: "_:" <PN_LOCAL> >
160
161 /* Auxiliary character tokens */
162 | < #DIGIT: ["0"-"9"] >
163 | < #PN_CHARS_U: <PN_CHARS_BASE> | "_" >
164 | < #PN_CHARS:
165 <PN_CHARS_U>
166 | "-"
167 | <DIGIT>
168 | "\u00B7"
169 | ["\u0300"-"\u036F"]
170 | ["\u203F"-"\u2040"]
171 >
172 | < #PN_CHARS_BASE:
173 ["a"-"z"]
174 | ["A"-"Z"]
175 | ["\u00C0"-"\u00D6"]
176 | ["\u00D8"-"\u00F6"]
177 | ["\u00F8"-"\u02FF"]
178 | ["\u0370"-"\u037D"]
179 | ["\u037F"-"\u1FFF"]
180 | ["\u200C"-"\u200D"]
181 | ["\u2070"-"\u218F"]
182 | ["\u2C00"-"\u2FEF"]
183 | ["\u3001"-"\uD7FF"]
184 | ["\uF900"-"\uFDCF"]
185 | ["\uFDF0"-"\uFFFD"]
186 >
187 }
188
189 SKIP :
190 {
191 "<" : FullIri
192 | "\"" : QuotedQString
193 | "#" : Comment
194 }
195
196 <FullIri> TOKEN :
197 {
198 /* based on IRI_REF of [SPARQL] */
199 < FULL_IRI: ( ~["<",">","\"","{","}","|","^","`","\\","\u0000"-"\u0020"] )* > : FullIriEnd
200 }
201
202 <FullIriEnd> SKIP :
203 {
204 ">" : DEFAULT
205 }
206
207 <AfterPrefix> TOKEN :
208 {
209 < PN_LOCAL: ( <PN_CHARS_U> | <DIGIT> ) ( ( <PN_CHARS> | "." )* <PN_CHARS>)? > : DEFAULT
210 }
211
212
213 <AfterPrefix> SKIP :
214 {
215 "" : DEFAULT
216 }
217
218 <QuotedQString> TOKEN :
219 {
220 < QUOTED_QString: ( ~["\\","\""] | ("\\" ["\"","\'","\\"]) )* > : QuotedQStringEnd
221 }
222
223 <QuotedQStringEnd> SKIP :
224 {
225 "\"" : DEFAULT
226 }
227
228 <Comment> SKIP :
229 {
230 "\n": DEFAULT
231 | "\r": DEFAULT
232 }
233
234 <Comment> SKIP :
235 {
236 < ~[] >
237 }
238
239
240 /*------------------------------------------------------------------
241 * PARSER RULES
242 *------------------------------------------------------------------*/
243
244 /* 2 Preliminary Definitions */
245
246 /* 2.3 Integers, Characters, QStrings, Language Tags, and Node IDs */
247 /* @ (U+40) followed a nonempty sequence of characters matching the
248 * langtag production from [BCP 47]
249 */
250 QString languageTag():
251 {
252 Token* t;
253 }{
254 t = <LANGTAG> {
255 return JAVACC_TO_QSTRING(t->image);
256 }
257 }
258
259 /* See LANGTAG in [SPARQL] */
260 /* a finite sequence of characters matching the BLANK_NODE_LABEL
261 * production of [SPARQL]
262 */
263 QString nodeId():
264 {
265 Token* t;
266 }{
267 <BLANK_NODE_PREFIX> t = <PN_LOCAL> {
268 return JAVACC_TO_QSTRING(t->image);
269 }
270 }
271
272
273 /* 2.3 IRIs */
274 /* An iri as defined in [RFC3987], enclosed in a pair of < (U+3C) and >
275 * (U+3E) characters. See IRI_REF in [SPARQL].
276 * The function returns only the IRI part of the QString without the
277 * enclosing < >.
278 */
279 QString fullIri():
280 {
281 Token* t;
282 }{
283 t = <FULL_IRI> {
284 return JAVACC_TO_QSTRING(t->image);
285 }
286 }
287
288 /* Extract the actual IRI from a full IRI or abbreviated IRI */
289 QString iri():
290 {
291 QString x;
292 }{
293 (
294 x = fullIri()
295 | x = abbreviatedIri()
296 ) { return x; }
297 }
298
299 /*
300 * A finite sequence of characters matching the PNAME_LN production of
301 * [SPARQL]. The function returns the IRI that the abbreviation encodes
302 * based on the known prefix declarations.
303 */
304 QString abbreviatedIri():
305 {
306 Token* t;
307 QString abbName;
308 }{
309 abbName = prefixName()
310 t = <PN_LOCAL> {
311 return getBuilder()->resolveAbbreviationName(abbName+JAVACC_TO_QSTRING(t->image));
312 }
313 }
314
315 /* a finite sequence of characters matching the as PNAME_NS production of
316 * [SPARQL]
317 */
318 QString prefixName():
319 {
320 Token* t = nullptr;
321 }{
322 t = <PNAME_NS> {
323 return JAVACC_TO_QSTRING(t->image);
324 }
325 }
326
327
328 /* 3 Ontologies */
329
330 /* 3.5 Ontology Annotations */
331 void ontologyAnnotations():
332 {}{
333 ( annotation() )*
334 }
335
336 /* 3.7 Functional-Style Syntax */
337 void ontologyDocument() :
338 {}{
339 ( prefixDeclaration() )* ontology()
340 }
341
342 void prefixDeclaration() :
343 {
344 QString abbName;
345 QString fullName;
346 }{
347 <PREFIX> <OPEN_BRACKET>
348 abbName = prefixName()
349 <EQUALS>
350 fullName = fullIri()
351 <CLOSE_BRACKET> {
352 if (abbName.endsWith(":")) {
353 abbName = abbName.remove(abbName.length()-1,1);
354 }
355 getBuilder()->addNameAbbreviation(fullName,abbName);
356 }
357 }
358
359 void ontology() :
360 {}{
361 <ONTOLOGY> <OPEN_BRACKET> ( ontologyIri() ( versionIri() )? )?
362 directlyImportsDocuments()
363 ontologyAnnotations()
364 axioms()
365 <CLOSE_BRACKET>
366 }
367
368 QString ontologyIri():
369 {
370 QString x;
371 }{
372 x = iri() { return x; }
373 }
374
375 QString versionIri():
376 {
377 QString x;
378 }{
379 x = iri() { return x; }
380 }
381
382 void directlyImportsDocuments():
383 {
384 QString x;
385 }{
386 ( <IMPORT> <OPEN_BRACKET> x = iri() { getBuilder()->addOntologyImport(x); } <CLOSE_BRACKET> )*
387 }
388
389 void axioms() :
390 {
391 CBuildExpressionPtr x;
392 }{
393 ( x = axiom() { getBuilder()->tellOntologyAxiom(x); } )*
394 }
395
396
397
398
399
400
401
402
403 /* 5 Entities and Literals */
404
405 /* 5.1 Classes */
406 CBuildExpressionPtr owlClass():
407 {
408 QString x;
409 }{
410 x = iri() { return getBuilder()->getClass(x); }
411 }
412
413 /* 5.2 Datatypes */
414 CBuildExpressionPtr datatype():
415 {
416 QString x;
417 }{
418 x = iri() {
419 return getBuilder()->getDatatype(x);
420 }
421 }
422
423 /* 5.3 Object Properties */
424 CBuildExpressionPtr objectProperty():
425 {
426 QString x;
427 }{
428 x = iri() {
429 return getBuilder()->getObjectProberty(x);
430 }
431 }
432
433 /* 5.4 Data Properties */
434 CBuildExpressionPtr dataProperty():
435 {
436 QString x;
437 }{
438 x = iri() {
439 return getBuilder()->getDataProberty(x);
440 }
441 }
442
443 /* 5.5 Annotation Properties */
444 CBuildExpressionPtr annotationProperty():
445 {
446 QString x;
447 }{
448 x = iri() {
449 return nullptr;
450 }
451 // | <RDFS_LABEL>
452 // | <RDFS_COMMENT>
453 // | <RDFS_SEE_ALSO>
454 // | <RDFS_IS_DEFINED_BY>
455 // | <OWL_DEPRECATED>
456 // | <OWL_VERSION_INFO>
457 // | <OWL_PRIOR_VERSION>
458 // | <OWL_BACKWARD_COMPATIBLE_WITH>
459 // | <OWL_INCOMPATIBLE_WITH>
460 }
461
462 /* 5.6 Individuals */
463 CBuildExpressionPtr individual():
464 {
465 CBuildExpressionPtr x;
466 }{
467 (
468 x = namedIndividual()
469 | x = anonymousIndividual()
470 ) { return x; }
471 }
472
473 /* 5.6.1 Named Individuals */
474 CBuildExpressionPtr namedIndividual():
475 {
476 QString x;
477 }{
478 x = iri() {
479 return getBuilder()->getNamedIndividual(x);
480 }
481 }
482
483 /* 5.6.2 Anonymous Individuals */
484 CBuildExpressionPtr anonymousIndividual():
485 {
486 QString x;
487 }{
488 x = nodeId() {
489 return getBuilder()->getAnonymousIndividual(getBuilder()->getAnonymousOntologyIdentifier(),x);
490 }
491 }
492
493 /* 5.7 Literals */
494 CBuildExpressionPtr literal(bool annotation):
495 {
496 QString x,l;
497 CBuildExpressionPtr d = nullptr;
498 }{
499 x = quotedQString()
500 (
501 <REFERENCE> d = datatype()
502 | ( l = languageTag() )?
503 ) {
504 if (annotation) {
505 return nullptr;
506 }
507 if (d == nullptr) {
508 d = getBuilder()->getDatatype("http://www.w3.org/1999/02/22-rdf-syntax-ns#PlainLiteral");
509 if (l.isEmpty()) {
510 x += "@";
511 } else {
512 x += l;
513 }
514 }
515 CBuildExpressionPtr y = getBuilder()->getDataLexicalValue(x);
516 return getBuilder()->getDataLiteral((CDataLexicalValueExpressionPtr)y,(CDatatypeExpressionPtr)d);
517 }
518 }
519
520
521 /* Retrieve the content of a quoted QString. */
522 QString quotedQString():
523 {
524 Token* t;
525 }{
526 t = <QUOTED_QString> {
527 return JAVACC_TO_QSTRING(t->image);
528 }
529 }
530
531 /* 5.8 Entity Declarations and Typing */
532 CBuildExpressionPtr declaration():
533 {
534 CBuildExpressionPtr x;
535 }{
536 <DECLARATION> <OPEN_BRACKET> axiomAnnotations()
537 x = entity()
538 <CLOSE_BRACKET> {
539 return getBuilder()->getDeclaration(x);
540 }
541 }
542
543 CBuildExpressionPtr entity():
544 {
545 CBuildExpressionPtr x = nullptr;
546 }{ (
547 <CLASS> <OPEN_BRACKET> x = owlClass() <CLOSE_BRACKET>
548 | <DATATYPE> <OPEN_BRACKET> x = datatype() <CLOSE_BRACKET>
549 | <OBJECT_PROPERTY> <OPEN_BRACKET> x = objectProperty() <CLOSE_BRACKET>
550 | <DATA_PROPERTY> <OPEN_BRACKET> x = dataProperty() <CLOSE_BRACKET>
551 | <ANNOTATION_PROPERTY> <OPEN_BRACKET> x = annotationProperty() <CLOSE_BRACKET>
552 | <NAMED_INDIVIDUAL> <OPEN_BRACKET> x = namedIndividual() <CLOSE_BRACKET>
553 ) { return x; }
554 }
555
556 /* 6 Property Expressions */
557 CBuildExpressionPtr objectPropertyExpression():
558 {
559 CBuildExpressionPtr x;
560 }{
561 (
562 x = objectProperty()
563 | x = inverseObjectProperty()
564 ) { return x; }
565 }
566
567
568
569 /* 6.1.1 Inverse Object Properties */
570 CBuildExpressionPtr inverseObjectProperty():
571 {
572 CBuildExpressionPtr x;
573 }{
574 <OBJECT_INVERSE_OF> <OPEN_BRACKET>
575 x = objectProperty()
576 <CLOSE_BRACKET> {
577 return getBuilder()->getInverseObjectPropertyOf(x);
578 }
579 }
580
581 /* 6.2 Data Property Expressions */
582 CBuildExpressionPtr dataPropertyExpression():
583 {
584 CBuildExpressionPtr x;
585 }{
586 x = dataProperty() { return x; }
587 }
588
589
590
591 /* 7 Data Ranges */
592
593 CBuildExpressionPtr dataRange():
594 {
595 CBuildExpressionPtr x;
596 }{
597 (
598 x = datatype()
599 | x = dataIntersectionOf()
600 | x = dataUnionOf()
601 | x = dataComplementOf()
602 | x = dataOneOf()
603 | x = datatypeRestriction()
604 ) { return x; }
605 }
606
607 CEXPRESSIONLIST<CBuildExpressionPtr> dataRangeList():
608 {
609 CBuildExpressionPtr x;
610 CEXPRESSIONLIST<CBuildExpressionPtr> v;
611 }{
612 ( x = dataRange() { v.append(x); } )+
613 { return v; }
614 }
615
616 /* 7.1 Intersection of Data Ranges */
617 CBuildExpressionPtr dataIntersectionOf():
618 {
619 CEXPRESSIONLIST<CBuildExpressionPtr> v;
620 }{
621 <DATA_INTERSECTION_OF> <OPEN_BRACKET>
622 v = dataRangeList()
623 <CLOSE_BRACKET> {
624 return getBuilder()->getDataIntersectionOf(v);
625 }
626 }
627
628 /* 7.2 Union of Data Ranges */
629 CBuildExpressionPtr dataUnionOf():
630 {
631 CEXPRESSIONLIST<CBuildExpressionPtr> v;
632 }{
633 <DATA_UNION_OF> <OPEN_BRACKET>
634 v = dataRangeList()
635 <CLOSE_BRACKET>{
636 return getBuilder()->getDataUnionOf(v);
637 }
638 }
639
640 /* 7.3 Complement of Data Ranges */
641 CBuildExpressionPtr dataComplementOf():
642 {
643 CBuildExpressionPtr x;
644 }{
645 <DATA_COMPLEMENT_OF> <OPEN_BRACKET>
646 x = dataRange()
647 <CLOSE_BRACKET> {
648 return getBuilder()->getDataComplementOf(x);
649 }
650 }
651
652 /* 7.4 Enumeration of Literals */
653 CBuildExpressionPtr dataOneOf():
654 {
655 CBuildExpressionPtr x;
656 CEXPRESSIONLIST<CBuildExpressionPtr> v;
657 }{
658 <DATA_ONE_OF> <OPEN_BRACKET>
659 ( x = literal(false) { v.append(x); } )+
660 <CLOSE_BRACKET> {
661 return getBuilder()->getDataOneOf(v);
662 }
663 }
664
665 /* 7.5 Datatype Restrictions */
666 CBuildExpressionPtr datatypeRestriction():
667 {
668 CBuildExpressionPtr x;
669 CEXPRESSIONLIST<CBuildExpressionPtr> v;
670 }{
671 <DATATYPE_RESTRICTION> <OPEN_BRACKET>
672 x = datatype()
673 v = facetRestrictionList()
674 <CLOSE_BRACKET> {
675 v.append(x);
676 return getBuilder()->getDatatypeRestriction(v);
677 }
678 }
679
680
681 CEXPRESSIONLIST<CBuildExpressionPtr> facetRestrictionList():
682 {
683 CBuildExpressionPtr x;
684 CEXPRESSIONLIST<CBuildExpressionPtr> v;
685 }{
686 ( x = facetRestriction() { v.append(x); } )+
687 { return v; }
688 }
689
690
691
692 CBuildExpressionPtr facetRestriction():
693 {
694 QString f;
695 CBuildExpressionPtr l;
696 }{
697 f = iri()
698 l = literal(false)
699 {
700 CBuildExpressionPtr x = getBuilder()->getDataFacet(f);
701 return getBuilder()->getDataFacetRestriction(l,x);
702 }
703 }
704
705
706
707
708 /* 8 Class Expressions */
709 CBuildExpressionPtr classExpression():
710 {
711 CBuildExpressionPtr x;
712 }{ (
713 x = owlClass()
714 | x = objectIntersectionOf()
715 | x = objectUnionOf()
716 | x = objectComplementOf()
717 | x = objectOneOf()
718 | x = objectSomeValuesFrom()
719 | x = objectAllValuesFrom()
720 | x = objectHasValue()
721 | x = objectHasSelf()
722 | x = objectMinCardinality()
723 | x = objectMaxCardinality()
724 | x = objectExactCardinality()
725 | x = dataSomeValuesFrom()
726 | x = dataAllValuesFrom()
727 | x = dataHasValue()
728 | x = dataMinCardinality()
729 | x = dataMaxCardinality()
730 | x = dataExactCardinality()
731 ) { return x; }
732 }
733
734
735 /* 8.1 Propositional Connectives and Enumeration of Individuals */
736
737 /* 8.1.1 Intersection of Class Expressions */
738 CBuildExpressionPtr objectIntersectionOf():
739 {
740 CEXPRESSIONLIST<CBuildExpressionPtr> v;
741 }{
742 <OBJECT_INTERSECTION_OF> <OPEN_BRACKET>
743 v = classExpressionList()
744 <CLOSE_BRACKET> {
745 return getBuilder()->getObjectIntersectionOf(v);
746 }
747 }
748
749 /* 8.1.2 Union of Class Expressions */
750 CBuildExpressionPtr objectUnionOf():
751 {
752 CEXPRESSIONLIST<CBuildExpressionPtr> v;
753 }{
754 <OBJECT_UNION_OF> <OPEN_BRACKET>
755 v = classExpressionList()
756 <CLOSE_BRACKET> {
757 return getBuilder()->getObjectUnionOf(v);
758 }
759 }
760
761 /* 8.1.3 Complement of Class Expressions */
762 CBuildExpressionPtr objectComplementOf():
763 {
764 CBuildExpressionPtr x;
765 }{
766 <OBJECT_COMPLEMENT_OF> <OPEN_BRACKET>
767 x = classExpression()
768 <CLOSE_BRACKET> {
769 return getBuilder()->getObjectComplementOf(x);
770 }
771 }
772
773 /* 8.1.4 Enumeration of Individuals */
774 CBuildExpressionPtr objectOneOf():
775 {
776 CBuildExpressionPtr x;
777 CEXPRESSIONLIST<CBuildExpressionPtr> v;
778 }{
779 <OBJECT_ONE_OF> <OPEN_BRACKET>
780 ( x = individual() { v.append(x); } )+
781 <CLOSE_BRACKET> {
782 return getBuilder()->getObjectOneOf(v);
783 }
784 }
785
786
787 /* 8.2 Object Property Restrictions */
788
789 /* 8.2.1 Existential Quantification */
790 CBuildExpressionPtr objectSomeValuesFrom():
791 {
792 CBuildExpressionPtr x;
793 CBuildExpressionPtr y;
794 }{
795 <OBJECT_SOME_VALUES_FROM> <OPEN_BRACKET>
796 x = objectPropertyExpression()
797 y = classExpression()
798 <CLOSE_BRACKET> {
799 return getBuilder()->getObjectSomeValuesFrom(x,y);
800 }
801 }
802
803 /* 8.2.2 Universal Quantification */
804 CBuildExpressionPtr objectAllValuesFrom():
805 {
806 CBuildExpressionPtr x;
807 CBuildExpressionPtr y;
808 }{
809 <OBJECT_ALL_VALUES_FROM> <OPEN_BRACKET>
810 x = objectPropertyExpression()
811 y = classExpression()
812 <CLOSE_BRACKET> {
813 return getBuilder()->getObjectAllValuesFrom(x,y);
814 }
815 }
816
817 /* 8.2.3 Individual Value Restriction */
818 CBuildExpressionPtr objectHasValue():
819 {
820 CBuildExpressionPtr x;
821 CBuildExpressionPtr y;
822 }{
823 <OBJECT_HAS_VALUE> <OPEN_BRACKET>
824 x = objectPropertyExpression()
825 y = individual()
826 <CLOSE_BRACKET> {
827 return getBuilder()->getObjectHasValue(x,y);
828 }
829 }
830
831 /* 8.2.4 Self-Restriction */
832 CBuildExpressionPtr objectHasSelf():
833 {
834 CBuildExpressionPtr x;
835 }{
836 <OBJECT_HAS_SELF> <OPEN_BRACKET>
837 x = objectPropertyExpression()
838 <CLOSE_BRACKET> {
839 return getBuilder()->getObjectHasSelf(x);
840 }
841 }
842
843
844 /* 8.3 Object Property Cardinality Restrictions */
845
846 /* 8.3.1 Minimum Cardinality */
847 CBuildExpressionPtr objectMinCardinality():
848 {
849 Token* n;
850 CBuildExpressionPtr x;
851 CBuildExpressionPtr y = nullptr;
852 }{
853 <OBJECT_MIN_CARDINALITY> <OPEN_BRACKET>
854 n = <NON_NEGATIVE_INTEGER>
855 x = objectPropertyExpression()
856 ( y = classExpression() )?
857 <CLOSE_BRACKET> {
858 if (y == nullptr) {
859 y = getBuilder()->getTopClass();
860 }
861 cint64 cardinality = JAVACC_TO_QSTRING(n->image).toLongLong();
862 return getBuilder()->getObjectMinCardinality(x,y,cardinality);
863 }
864 }
865
866 /* 8.3.2 Maximum Cardinality */
867 CBuildExpressionPtr objectMaxCardinality():
868 {
869 Token* n;
870 CBuildExpressionPtr x;
871 CBuildExpressionPtr y = nullptr;
872 }{
873 <OBJECT_MAX_CARDINALITY> <OPEN_BRACKET>
874 n = <NON_NEGATIVE_INTEGER>
875 x = objectPropertyExpression()
876 ( y = classExpression() )?
877 <CLOSE_BRACKET> {
878 if (y == nullptr) {
879 y = getBuilder()->getTopClass();
880 }
881 cint64 cardinality = JAVACC_TO_QSTRING(n->image).toLongLong();
882 return getBuilder()->getObjectMaxCardinality(x,y,cardinality);
883 }
884 }
885
886 /* 8.3.3 Exact Cardinality */
887 CBuildExpressionPtr objectExactCardinality():
888 {
889 Token* n;
890 CBuildExpressionPtr x;
891 CBuildExpressionPtr y = nullptr;
892 }{
893 <OBJECT_EXACT_CARDINALITY> <OPEN_BRACKET>
894 n = <NON_NEGATIVE_INTEGER>
895 x = objectPropertyExpression()
896 ( y = classExpression() )?
897 <CLOSE_BRACKET> {
898 if (y == nullptr) {
899 y = getBuilder()->getTopClass();
900 }
901 cint64 cardinality = JAVACC_TO_QSTRING(n->image).toLongLong();
902 return getBuilder()->getObjectExactlyCardinality(x,y,cardinality);
903 }
904 }
905
906 /* 8.4 Data Property Restrictions */
907
908 /* 8.4.1 Existential Quantification */
909 CBuildExpressionPtr dataSomeValuesFrom():
910 {
911 CBuildExpressionPtr x, y;
912 }{
913 <DATA_SOME_VALUES_FROM> <OPEN_BRACKET>
914 x = dataProperty()
915 y = dataRange()
916 <CLOSE_BRACKET>
917 {
918 if (y == nullptr) {
919 y = getBuilder()->getTopDataRange();
920 }
921 return getBuilder()->getDataSomeValuesFrom(x,y);
922 }
923 }
924
925
926
927 /* 8.4.2 Universal Quantification */
928 CBuildExpressionPtr dataAllValuesFrom():
929 {
930 CBuildExpressionPtr x, y;
931 }{
932 <DATA_ALL_VALUES_FROM> <OPEN_BRACKET>
933 x = dataProperty()
934 y = dataRange()
935 <CLOSE_BRACKET>
936 {
937 return getBuilder()->getDataAllValuesFrom(x,y);
938 }
939 }
940
941
942 /* 8.4.3 Literal Value Restriction */
943 CBuildExpressionPtr dataHasValue():
944 {
945 CBuildExpressionPtr x, y;
946 }{
947 <DATA_HAS_VALUE> <OPEN_BRACKET>
948 x = dataPropertyExpression()
949 y = literal(false)
950 <CLOSE_BRACKET> {
951 return getBuilder()->getDataHasValue(x,y);
952 }
953 }
954
955
956 /* 8.5 Data Property Cardinality Restrictions */
957
958 /* 8.5.1 Minimum Cardinality */
959 CBuildExpressionPtr dataMinCardinality():
960 {
961 Token* n;
962 CBuildExpressionPtr x;
963 CBuildExpressionPtr y = nullptr;
964 }{
965 <DATA_MIN_CARDINALITY> <OPEN_BRACKET>
966 n = <NON_NEGATIVE_INTEGER>
967 x = dataPropertyExpression()
968 ( y = dataRange() )?
969 <CLOSE_BRACKET> {
970 if (y == nullptr) {
971 y = getBuilder()->getTopDataRange();
972 }
973 cint64 cardinality = JAVACC_TO_QSTRING(n->image).toLongLong();
974 return getBuilder()->getDataMinCardinality(x,y,cardinality);
975 }
976 }
977
978 /* 8.5.2 Maximum Cardinality */
979 CBuildExpressionPtr dataMaxCardinality():
980 {
981 Token* n;
982 CBuildExpressionPtr x;
983 CBuildExpressionPtr y = nullptr;
984 }{
985 <DATA_MAX_CARDINALITY> <OPEN_BRACKET>
986 n = <NON_NEGATIVE_INTEGER>
987 x = dataPropertyExpression()
988 ( y = dataRange() )?
989 <CLOSE_BRACKET> {
990 if (y == nullptr) {
991 y = getBuilder()->getTopDataRange();
992 }
993 cint64 cardinality = JAVACC_TO_QSTRING(n->image).toLongLong();
994 return getBuilder()->getDataMaxCardinality(x,y,cardinality);
995 }
996 }
997
998 /* 8.5.3 Exact Cardinality */
999 CBuildExpressionPtr dataExactCardinality():
1000 {
1001 Token* n;
1002 CBuildExpressionPtr x;
1003 CBuildExpressionPtr y = nullptr;
1004 }{
1005 <DATA_EXACT_CARDINALITY> <OPEN_BRACKET>
1006 n = <NON_NEGATIVE_INTEGER>
1007 x = dataPropertyExpression()
1008 ( y = dataRange() )?
1009 <CLOSE_BRACKET> {
1010 if (y == nullptr) {
1011 y = getBuilder()->getTopDataRange();
1012 }
1013 cint64 cardinality = JAVACC_TO_QSTRING(n->image).toLongLong();
1014 return getBuilder()->getDataExactCardinality(x,y,cardinality);
1015 }
1016 }
1017
1018
1019 /* 9 Axioms */
1020 CBuildExpressionPtr axiom():
1021 {
1022 CBuildExpressionPtr x = nullptr;
1023 }{
1024 (
1025 x = declaration()
1026 | x = classAxiom()
1027 | x = objectPropertyAxiom()
1028 | x = dataPropertyAxiom()
1029 | x = datatypeDefinition()
1030 | x = hasKey()
1031 | x = assertion()
1032 | x = annotationAxiom()
1033 ) { return x; }
1034 }
1035
1036 void axiomAnnotations():
1037 {}{
1038 ( annotation() )*
1039 }
1040
1041 /* 9.1 Class Expression Axioms */
1042 CBuildExpressionPtr classAxiom():
1043 {
1044 CBuildExpressionPtr x;
1045 }{ (
1046 x = subClassOf()
1047 | x = equivalentClasses()
1048 | x = disjointClasses()
1049 | x = disjointUnion()
1050 ) { return x; }
1051 }
1052
1053 /* 9.1.1 Subclass Axioms */
1054 CBuildExpressionPtr subClassOf():
1055 {
1056 CBuildExpressionPtr x, y;
1057 }{
1058 <SUB_CLASS_OF> <OPEN_BRACKET>
1059 axiomAnnotations()
1060 x = classExpression()
1061 y = classExpression()
1062 <CLOSE_BRACKET> {
1063 return getBuilder()->getSubClassOf(x,y);
1064 }
1065 }
1066
1067 /* 9.1.2 Equivalent Classes */
1068 CBuildExpressionPtr equivalentClasses():
1069 {
1070 CEXPRESSIONLIST<CBuildExpressionPtr> v;
1071 }{
1072 <EQUIVALENT_CLASSES> <OPEN_BRACKET>
1073 axiomAnnotations()
1074 v = classExpressionList()
1075 <CLOSE_BRACKET> {
1076 return getBuilder()->getEquivalentClasses(v);
1077 }
1078 }
1079
1080 /* 9.1.3 Disjoint Classes */
1081 CBuildExpressionPtr disjointClasses():
1082 {
1083 CEXPRESSIONLIST<CBuildExpressionPtr> v;
1084 }{
1085 <DISJOINT_CLASSES> <OPEN_BRACKET>
1086 axiomAnnotations()
1087 v = classExpressionList()
1088 <CLOSE_BRACKET> {
1089 return getBuilder()->getDisjointClasses(v);
1090 }
1091 }
1092
1093 /* 9.1.4 Disjoint Union of Class Expressions */
1094 CBuildExpressionPtr disjointUnion():
1095 {
1096 CBuildExpressionPtr x;
1097 CEXPRESSIONLIST<CBuildExpressionPtr> v;
1098 }{
1099 <DISJOINT_UNION> <OPEN_BRACKET>
1100 axiomAnnotations()
1101 x = owlClass()
1102 v = classExpressionList()
1103 <CLOSE_BRACKET> {
1104 v.prepend(x);
1105 return getBuilder()->getDisjointUnion(v);
1106 }
1107 }
1108
1109 CEXPRESSIONLIST<CBuildExpressionPtr> classExpressionList():
1110 {
1111 CBuildExpressionPtr x;
1112 CEXPRESSIONLIST<CBuildExpressionPtr> v;
1113 }{
1114 ( x = classExpression() { v.append(x); } )+
1115 { return v; }
1116 }
1117
1118 /* 9.2 Object Property Axioms */
1119 CBuildExpressionPtr objectPropertyAxiom():
1120 {
1121 CBuildExpressionPtr x;
1122 }{
1123 (
1124 x = subObjectPropertyOf()
1125 | x = equivalentObjectProperties()
1126 | x = disjointObjectProperties()
1127 | x = inverseObjectProperties()
1128 | x = objectPropertyDomain()
1129 | x = objectPropertyRange()
1130 | x = functionalObjectProperty()
1131 | x = inverseFunctionalObjectProperty()
1132 | x = reflexiveObjectProperty()
1133 | x = irreflexiveObjectProperty()
1134 | x = symmetricObjectProperty()
1135 | x = asymmetricObjectProperty()
1136 | x = transitiveObjectProperty()
1137 ) { return x; }
1138 }
1139
1140 /* 9.2.1 Object Subproperties */
1141 CBuildExpressionPtr subObjectPropertyOf():
1142 {
1143 CBuildExpressionPtr x = nullptr;
1144 CBuildExpressionPtr z;
1145 }{
1146 <SUB_OBJECT_PROPERTY_OF> <OPEN_BRACKET>
1147 axiomAnnotations()
1148 (
1149 x = objectPropertyExpression()
1150 | x = propertyExpressionChain()
1151 )
1152 z = objectPropertyExpression()
1153 <CLOSE_BRACKET> {
1154 return getBuilder()->getSubObjectPropertyOf(x,z);
1155 }
1156 }
1157
1158 CBuildExpressionPtr propertyExpressionChain():
1159 {
1160 CEXPRESSIONLIST<CBuildExpressionPtr> v;
1161 }{
1162 <OBJECT_PROPERTY_CHAIN> <OPEN_BRACKET>
1163 v = objectPropertyExpressionList()
1164 <CLOSE_BRACKET> {
1165 return getBuilder()->getObjectPropertyChain(v);
1166 }
1167 }
1168
1169 /* 9.2.2 Equivalent Object Properties */
1170 CBuildExpressionPtr equivalentObjectProperties():
1171 {
1172 CEXPRESSIONLIST<CBuildExpressionPtr> v;
1173 }{
1174 <EQUIVALENT_OBJECT_PROPERTIES> <OPEN_BRACKET>
1175 axiomAnnotations()
1176 v = objectPropertyExpressionList()
1177 <CLOSE_BRACKET> {
1178 return getBuilder()->getEquivalentObjectProperties(v);
1179 }
1180 }
1181
1182 /* 9.2.3 Disjoint Object Properties */
1183 CBuildExpressionPtr disjointObjectProperties():
1184 {
1185 CEXPRESSIONLIST<CBuildExpressionPtr> v;
1186 }{
1187 <DISJOINT_OBJECT_PROPERTIES> <OPEN_BRACKET>
1188 axiomAnnotations()
1189 v = objectPropertyExpressionList()
1190 <CLOSE_BRACKET> {
1191 return getBuilder()->getDisjointObjectProperties(v);
1192 }
1193 }
1194
1195 CEXPRESSIONLIST<CBuildExpressionPtr> objectPropertyExpressionList():
1196 {
1197 CBuildExpressionPtr x;
1198 CEXPRESSIONLIST<CBuildExpressionPtr> v;
1199 }{
1200 ( x = objectPropertyExpression() { v.append(x); } )+
1201 { return v; }
1202 }
1203
1204
1205 /* 9.2.4 Inverse Object Properties */
1206 CBuildExpressionPtr inverseObjectProperties():
1207 {
1208 CBuildExpressionPtr x, y;
1209 }{
1210 <INVERSE_OBJECT_PROPERTIES> <OPEN_BRACKET>
1211 axiomAnnotations()
1212 x = objectPropertyExpression()
1213 y = objectPropertyExpression()
1214 <CLOSE_BRACKET> {
1215 return getBuilder()->getInverseObjectProperties(x,y);
1216 }
1217 }
1218
1219 /* 9.2.5 Object Property Domain */
1220 CBuildExpressionPtr objectPropertyDomain():
1221 {
1222 CBuildExpressionPtr x, y;
1223 }{
1224 <OBJECT_PROPERTY_DOMAIN> <OPEN_BRACKET>
1225 axiomAnnotations()
1226 x = objectPropertyExpression()
1227 y = classExpression()
1228 <CLOSE_BRACKET> {
1229 return getBuilder()->getObjectPropertyDomainExpression(x,y);
1230 }
1231 }
1232
1233 /* 9.2.6 Object Property Range */
1234 CBuildExpressionPtr objectPropertyRange():
1235 {
1236 CBuildExpressionPtr x, y;
1237 }{
1238 <OBJECT_PROPERTY_RANGE> <OPEN_BRACKET>
1239 axiomAnnotations()
1240 x = objectPropertyExpression()
1241 y = classExpression()
1242 <CLOSE_BRACKET> {
1243 return getBuilder()->getObjectPropertyRangeExpression(x,y);
1244 }
1245 }
1246
1247 /* 9.2.7 Functional Object Properties */
1248 CBuildExpressionPtr functionalObjectProperty():
1249 {
1250 CBuildExpressionPtr x;
1251 }{
1252 <FUNCTIONAL_OBJECT_PROPERTY> <OPEN_BRACKET>
1253 axiomAnnotations()
1254 x = objectPropertyExpression()
1255 <CLOSE_BRACKET> {
1256 return getBuilder()->getFunctionalObjectProperty(x);
1257 }
1258 }
1259
1260 /* 9.2.8 Inverse-Functional Object Properties */
1261 CBuildExpressionPtr inverseFunctionalObjectProperty():
1262 {
1263 CBuildExpressionPtr x;
1264 }{
1265 <INVERSE_FUNCTIONAL_OBJECT_PROPERTY> <OPEN_BRACKET>
1266 axiomAnnotations()
1267 x = objectPropertyExpression()
1268 <CLOSE_BRACKET> {
1269 return getBuilder()->getInverseFunctionalObjectProperty(x);
1270 }
1271 }
1272
1273 /* 9.2.9 Reflexive Object Properties */
1274 CBuildExpressionPtr reflexiveObjectProperty():
1275 {
1276 CBuildExpressionPtr x;
1277 }{
1278 <REFLEXIVE_OBJECT_PROPERTY> <OPEN_BRACKET>
1279 axiomAnnotations()
1280 x = objectPropertyExpression()
1281 <CLOSE_BRACKET> {
1282 return getBuilder()->getReflexiveObjectProperty(x);
1283 }
1284 }
1285
1286 /* 9.2.10 Irreflexive Object Properties */
1287 CBuildExpressionPtr irreflexiveObjectProperty():
1288 {
1289 CBuildExpressionPtr x;
1290 }{
1291 <IRREFLEXIVE_OBJECT_PROPERTY> <OPEN_BRACKET>
1292 axiomAnnotations()
1293 x = objectPropertyExpression()
1294 <CLOSE_BRACKET> {
1295 return getBuilder()->getIrreflexiveObjectProperty(x);
1296 }
1297 }
1298
1299 /* 9.2.11 Symmetric Object Properties */
1300 CBuildExpressionPtr symmetricObjectProperty():
1301 {
1302 CBuildExpressionPtr x;
1303 }{
1304 <SYMMETRIC_OBJECT_PROPERTY> <OPEN_BRACKET>
1305 axiomAnnotations()
1306 x = objectPropertyExpression()
1307 <CLOSE_BRACKET> {
1308 return getBuilder()->getSymmetricObjectProperty(x);
1309 }
1310 }
1311
1312 /* 9.2.12 Asymmetric Object Properties */
1313 CBuildExpressionPtr asymmetricObjectProperty():
1314 {
1315 CBuildExpressionPtr x;
1316 }{
1317 <ASYMMETRIC_OBJECT_PROPERTY> <OPEN_BRACKET>
1318 axiomAnnotations()
1319 x = objectPropertyExpression()
1320 <CLOSE_BRACKET> {
1321 return getBuilder()->getAsymmetricObjectProperty(x);
1322 }
1323 }
1324
1325 /* 9.2.13 Transitive Object Properties */
1326 CBuildExpressionPtr transitiveObjectProperty():
1327 {
1328 CBuildExpressionPtr x;
1329 }{
1330 <TRANSITIVE_OBJECT_PROPERTY> <OPEN_BRACKET>
1331 axiomAnnotations()
1332 x = objectPropertyExpression()
1333 <CLOSE_BRACKET>{
1334 return getBuilder()->getTransetiveObjectProperty(x);
1335 }
1336 }
1337
1338 /* 9.3 Data Property Axioms */
1339 CBuildExpressionPtr dataPropertyAxiom():
1340 {
1341 CBuildExpressionPtr x;
1342 }{
1343 (
1344 x = subDataPropertyOf()
1345 | x = equivalentDataProperties()
1346 | x = disjointDataProperties()
1347 | x = dataPropertyDomain()
1348 | x = dataPropertyRange()
1349 | x = functionalDataProperty()
1350 ) { return x; }
1351 }
1352
1353 /* 9.3.1 Data Subproperties */
1354 CBuildExpressionPtr subDataPropertyOf():
1355 {
1356 CBuildExpressionPtr x,y;
1357 }{
1358 <SUB_DATA_PROPERTY_OF> <OPEN_BRACKET>
1359 axiomAnnotations()
1360 x = dataPropertyExpression()
1361 y = dataPropertyExpression()
1362 <CLOSE_BRACKET> {
1363 return getBuilder()->getSubDataPropertyOf(x,y);
1364 }
1365 }
1366
1367 /* 9.3.2 Equivalent Data Properties */
1368 CBuildExpressionPtr equivalentDataProperties():
1369 {
1370 CEXPRESSIONLIST<CBuildExpressionPtr> v;
1371 }{
1372 <EQUIVALENT_DATA_PROPERTIES> <OPEN_BRACKET>
1373 axiomAnnotations()
1374 v = dataPropertyExpressionList()
1375 <CLOSE_BRACKET> {
1376 return getBuilder()->getEquivalentDataProperties(v);
1377 }
1378 }
1379
1380 /* 9.3.3 Disjoint Data Properties */
1381 CBuildExpressionPtr disjointDataProperties():
1382 {
1383 CEXPRESSIONLIST<CBuildExpressionPtr> v;
1384 }{
1385 <DISJOINT_DATA_PROPERTIES> <OPEN_BRACKET>
1386 axiomAnnotations()
1387 v = dataPropertyExpressionList()
1388 <CLOSE_BRACKET> {
1389 return getBuilder()->getDisjointDataProperties(v);
1390 }
1391 }
1392
1393 CEXPRESSIONLIST<CBuildExpressionPtr> dataPropertyExpressionList():
1394 {
1395 CBuildExpressionPtr x;
1396 CEXPRESSIONLIST<CBuildExpressionPtr> v;
1397 }{
1398 ( x = dataPropertyExpression() { v.append(x); } )+
1399 { return v; }
1400 }
1401
1402
1403 /* 9.3.4 Data Property Domain */
1404 CBuildExpressionPtr dataPropertyDomain():
1405 {
1406 CBuildExpressionPtr x, y;
1407 }{
1408 <DATA_PROPERTY_DOMAIN> <OPEN_BRACKET>
1409 axiomAnnotations()
1410 x = dataPropertyExpression()
1411 y = classExpression()
1412 <CLOSE_BRACKET> {
1413 return getBuilder()->getDataPropertyDomainExpression(x,y);
1414 }
1415 }
1416
1417 /* 9.3.5 Data Property Range */
1418 CBuildExpressionPtr dataPropertyRange():
1419 {
1420 CBuildExpressionPtr x, y;
1421 }{
1422 <DATA_PROPERTY_RANGE> <OPEN_BRACKET>
1423 axiomAnnotations()
1424 x = dataPropertyExpression()
1425 y = dataRange()
1426 <CLOSE_BRACKET> {
1427 return getBuilder()->getDataPropertyRangeExpression(x,y);
1428 }
1429 }
1430
1431 /* 9.3.6 Functional Data Properties */
1432 CBuildExpressionPtr functionalDataProperty():
1433 {
1434 CBuildExpressionPtr x;
1435 }{
1436 <FUNCTIONAL_DATA_PROPERTY> <OPEN_BRACKET>
1437 axiomAnnotations()
1438 x = dataPropertyExpression()
1439 <CLOSE_BRACKET> {
1440 return getBuilder()->getFunctionalDataProperty(x);
1441 }
1442 }
1443
1444 /* 9.4 Datatype Definitions */
1445 CBuildExpressionPtr datatypeDefinition():
1446 {
1447 }{
1448 <DATATYPE_DEFINITION> <OPEN_BRACKET>
1449 axiomAnnotations()
1450 datatype()
1451 dataRange()
1452 <CLOSE_BRACKET> {
1453 return nullptr;
1454 }
1455 }
1456
1457 /* 9.5 Keys */
1458 CBuildExpressionPtr hasKey():
1459 {
1460 }{
1461 <HAS_KEY> <OPEN_BRACKET>
1462 axiomAnnotations()
1463 classExpression()
1464 <OPEN_BRACKET> ( objectPropertyExpression() )* <CLOSE_BRACKET>
1465 <OPEN_BRACKET> ( objectPropertyExpression() )* <CLOSE_BRACKET>
1466 <CLOSE_BRACKET> {
1467 return nullptr;
1468 }
1469 }
1470
1471 /* 9.6 Assertions */
1472 CBuildExpressionPtr assertion():
1473 {
1474 CBuildExpressionPtr x;
1475 }{
1476 (
1477 x = sameIndividual()
1478 | x = differentIndividuals()
1479 | x = classAssertion()
1480 | x = objectPropertyAssertion()
1481 | x = negativeObjectPropertyAssertion()
1482 | x = dataPropertyAssertion()
1483 | x = negativeDataPropertyAssertion()
1484 ) { return x; }
1485 }
1486
1487 /* 9.6.1 Individual Equality */
1488 CBuildExpressionPtr sameIndividual():
1489 {
1490 CEXPRESSIONLIST<CBuildExpressionPtr> v;
1491 }{
1492 <SAME_INDIVIDUAL> <OPEN_BRACKET>
1493 axiomAnnotations()
1494 v = individualList()
1495 <CLOSE_BRACKET> {
1496 return getBuilder()->getSameIndividual(v);
1497 }
1498 }
1499
1500 /* 9.6.2 Individual Inequality */
1501 CBuildExpressionPtr differentIndividuals():
1502 {
1503 CEXPRESSIONLIST<CBuildExpressionPtr> v;
1504 }{
1505 <DIFFERENT_INDIVIDUALS> <OPEN_BRACKET>
1506 axiomAnnotations()
1507 v = individualList()
1508 <CLOSE_BRACKET> {
1509 return getBuilder()->getDifferentIndividuals(v);
1510 }
1511 }
1512
1513 CEXPRESSIONLIST<CBuildExpressionPtr> individualList():
1514 {
1515 CBuildExpressionPtr x;
1516 CEXPRESSIONLIST<CBuildExpressionPtr> v;
1517 }{
1518 ( x = individual() { v.append(x); } )+
1519 { return v; }
1520 }
1521
1522 /* 9.6.3 Class Assertions */
1523 CBuildExpressionPtr classAssertion():
1524 {
1525 CBuildExpressionPtr x, y;
1526 }{
1527 <CLASS_ASSERTION> <OPEN_BRACKET>
1528 axiomAnnotations()
1529 x = classExpression()
1530 y = individual()
1531 <CLOSE_BRACKET> {
1532 return getBuilder()->getClassAssertion(x,y);
1533 }
1534 }
1535
1536 /* 9.6.4 Positive Object Property Assertions */
1537 CBuildExpressionPtr objectPropertyAssertion():
1538 {
1539 CBuildExpressionPtr x, y, z;
1540 }{
1541 <OBJECT_PROPERTY_ASSERTION> <OPEN_BRACKET>
1542 axiomAnnotations()
1543 x = objectPropertyExpression()
1544 y = individual()
1545 z = individual()
1546 <CLOSE_BRACKET> {
1547 return getBuilder()->getObjectPropertyAssertion(x,y,z);
1548 }
1549 }
1550
1551 /* 9.6.5 Negative Object Property Assertions */
1552 CBuildExpressionPtr negativeObjectPropertyAssertion():
1553 {
1554 CBuildExpressionPtr x, y, z;
1555 }{
1556 <NEGATIVE_OBJECT_PROPERTY_ASSERTION> <OPEN_BRACKET>
1557 axiomAnnotations()
1558 x = objectPropertyExpression()
1559 y = individual()
1560 z = individual()
1561 <CLOSE_BRACKET> {
1562 return getBuilder()->getNegativeObjectPropertyAssertion(x,y,z);
1563 }
1564 }
1565
1566 /* 9.6.6 Positive Data Property Assertions */
1567 CBuildExpressionPtr dataPropertyAssertion():
1568 {
1569 CBuildExpressionPtr x, y, z;
1570 }{
1571 <DATA_PROPERTY_ASSERTION> <OPEN_BRACKET>
1572 axiomAnnotations()
1573 x = dataPropertyExpression()
1574 y = individual()
1575 z = literal(false)
1576 <CLOSE_BRACKET> {
1577 return getBuilder()->getDataPropertyAssertion(x,y,z);
1578 }
1579 }
1580
1581 /* 9.6.7 Negative Data Property Assertions */
1582 CBuildExpressionPtr negativeDataPropertyAssertion():
1583 {
1584 CBuildExpressionPtr x, y, z;
1585 }{
1586 <NEGATIVE_DATA_PROPERTY_ASSERTION> <OPEN_BRACKET>
1587 axiomAnnotations()
1588 x = dataPropertyExpression()
1589 y = individual()
1590 z = literal(false)
1591 <CLOSE_BRACKET> {
1592 return getBuilder()->getNegativeDataPropertyAssertion(x,y,z);
1593 }
1594 }
1595
1596
1597 /* 10 Annotations */
1598
1599 /* 10.1 Annotations of Ontologies, Axioms, and other Annotations */
1600 CBuildExpressionPtr annotation():
1601 {
1602 }{
1603 <ANNOTATION> <OPEN_BRACKET>
1604 annotationAnnotations()
1605 annotationProperty()
1606 annotationValue()
1607 <CLOSE_BRACKET> {
1608 return nullptr;
1609 }
1610 }
1611
1612 void annotationAnnotations():
1613 {}{
1614 ( annotation() )*
1615 }
1616
1617 CBuildExpressionPtr annotationValue():
1618 {
1619 }{
1620 ( anonymousIndividual()
1621 | iri()
1622 | literal(true)
1623 ) {
1624 return nullptr;
1625 }
1626 }
1627
1628 /* 10.2 Annotation Axioms */
1629 CBuildExpressionPtr annotationAxiom():
1630 {
1631 }{
1632 ( annotationAssertion()
1633 | subAnnotationPropertyOf()
1634 | annotationPropertyDomain()
1635 | annotationPropertyRange()
1636 ) {
1637 return nullptr;
1638 }
1639 }
1640
1641 /* 10.2.1 Annotation Assertion */
1642 CBuildExpressionPtr annotationAssertion():
1643 {
1644 }{
1645 <ANNOTATION_ASSERTION> <OPEN_BRACKET>
1646 axiomAnnotations()
1647 annotationProperty()
1648 annotationSubject()
1649 annotationValue()
1650 <CLOSE_BRACKET> {
1651 return nullptr;
1652 }
1653 }
1654
1655 CBuildExpressionPtr annotationSubject():
1656 {
1657 }{
1658 ( iri()
1659 | anonymousIndividual()
1660 ) {
1661 return nullptr;
1662 }
1663 }
1664
1665 /* 10.2.2 Annotation Subproperties */
1666 CBuildExpressionPtr subAnnotationPropertyOf():
1667 {
1668 }{
1669 <SUB_ANNOTATION_PROPERTY_OF> <OPEN_BRACKET>
1670 axiomAnnotations()
1671 annotationProperty()
1672 annotationProperty()
1673 <CLOSE_BRACKET> {
1674 return nullptr;
1675 }
1676 }
1677
1678
1679 /* 10.2.3 Annotation Property Domain */
1680 CBuildExpressionPtr annotationPropertyDomain():
1681 {
1682 }{
1683 <ANNOTATION_PROPERTY_DOMAIN> <OPEN_BRACKET>
1684 axiomAnnotations()
1685 annotationProperty()
1686 iri()
1687 <CLOSE_BRACKET> {
1688 return nullptr;
1689 }
1690 }
1691
1692 /* 10.2.4 Annotation Property Range */
1693 CBuildExpressionPtr annotationPropertyRange():
1694 {
1695 }{
1696 <ANNOTATION_PROPERTY_RANGE> <OPEN_BRACKET>
1697 axiomAnnotations()
1698 annotationProperty()
1699 iri()
1700 <CLOSE_BRACKET> {
1701 return nullptr;
1702 }
1703 }