nl.tue.buildingsmart.express.parser.Express2SDAI.g Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of buildingsmartlibrary Show documentation
Show all versions of buildingsmartlibrary Show documentation
Java implementation for the BuildingSMART standards IFC2x3TC1 and IFC4
header {
package nl.tue.buildingsmart.express.parser;
import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Vector;
import java.util.Hashtable;
import java.util.Collection;
import java.util.Iterator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import net.sourceforge.osexpress.parser.*;
import nl.tue.buildingsmart.express.dictionary.*;
}
class
Express2DictWalker extends TreeParser;
options {
importVocab=ExpressParser;
genHashLines=true;
buildAST=true;
}
{
//Express2OwlMethods methods=new Express2OwlMethods();
private int pass=1;
SchemaDefinition schema = new SchemaDefinition();
//this is a very, very ugly shortcut to the unlimited bounds "?" token
static boolean unlimited_bound=false;
// stores the last INTEGER_LITERAL that was parsed. Is used in bounds
String nextInt;
private static final Logger LOGGER = LoggerFactory.getLogger(Express2DictWalker.class);
public SchemaDefinition getSchema(){
return schema;
}
public void setPass(int i)
{
this.pass=i;
}
public boolean isPass2(){
if (pass==2) return true;
else return false;
}
public int getPass(){return this.pass;}
public void echo (String s){
System.out.println(s);
}
}
actual_parameter_list
: #(ACTUAL_PARAMETER_LIST parameter ( parameter )* )
;
aggregate_initializer
: #(AGGREGATE_INITIALIZER ( element ( element )* )? )
;
aggregate_source
: #(AGGREGATE_SOURCE simple_expression)
;
aggregate_type returns [String TypeName="aggregate"]
: #(AGGREGATE_TYPE ( type_label )? parameter_type )
;
aggregation_types returns [String[] TypeName=new String[4]]
: #( AGGREGATION_TYPES (
TypeName=array_type
| TypeName=bag_type
| TypeName=list_type
| TypeName=set_type
))
;
algorithm_head
: #(ALGORITHM_HEAD ( declaration )* ( constant_decl )? ( local_decl )?)
;
alias_stmt
: #(ALIAS_STMT variable_id general_ref ( qualifier )* stmt ( stmt )* )
;
array_type returns [String[] TypeName= new String[4]]
{
String[] bounds= new String[2];
String type="";
}
: #(ARRAY_TYPE ( bounds=bound_spec )? ( "unique" )? type=base_type )
{
TypeName[0]=type;
TypeName[1]=bounds[0];
TypeName[2]=bounds[1];
TypeName[3]="ARRAY";
}
;
assignment_stmt
: #(ASSIGNMENT_STMT ( general_ref ( qualifier )* ) expression )
;
bag_type returns [String[] TypeName= new String[4]]
{
String[] bounds= new String[2];
String type="";
}
: #(BAG_TYPE ( bounds=bound_spec )? type=base_type )
{
TypeName[0]=type;
TypeName[1]=bounds[0];
TypeName[2]=bounds[1];
TypeName[3]="BAG";
}
;
base_type returns [String TypeName=""]
: #(BASE_TYPE (
TypeName=concrete_types
|TypeName=generalized_types
))
;
concrete_types returns [String TypeName =""]
{
String[] aggregate = new String[2];
}
: #(CONCRETE_TYPES (
aggregate=aggregation_types {System.out.println("aggregat");}
| TypeName=simple_types
| TypeName=named_types
))
;
binary_type returns [String TypeName="BINARY"]
: #(BINARY_TYPE ( width_spec )? )
;
boolean_type returns [String TypeName="BOOLEAN"]
: #(BOOLEAN_TYPE nothing)
;
bound_1 returns [String NumEx=""]
{
String se="";
}
: #(BOUND_1 se=numeric_expression)
{
/*
The little bugger "?" to denote no limit in a bound hides in this patth:
SIMPLE_EXPRESSION ( TERM ( FACTOR ( SIMPLE_FACTOR ( PRIMARY ( QUALIFIABLE_FACTOR ( CONSTANT_FACTOR ( BUILT_IN_CONSTANT ?
Here is a VERY LAZY QUICKHACK to get a shortcut to it:
*/
if (unlimited_bound)
{
NumEx="?";
unlimited_bound=false;
}
else NumEx=nextInt;
}
;
// bound_1 returns [String NumEx=""]
// : #(BOUND_1 ne:numeric_expression)
// {
//
//
//
//
// }
// ;
unlimited_upper_bound
: #(BOUND_2 simple_expression (term(factor)))
{
System.out.println("unlimited upper bound");
}
;
bound_2 returns [String NumEx=""]
: #(BOUND_2 ne:numeric_expression)
{
if (unlimited_bound)
{
NumEx="?";
unlimited_bound=false;
}
else NumEx=nextInt;
}
;
bound_spec returns [String[] bound =new String[2]]
{
String lower,upper="";
}
: #(BOUND_SPEC lower=bound_1 upper=bound_2 )
{
bound[0]=lower;
bound[1]=upper;
;
}
//{System.out.println("Bounds:"+lower+":"+upper);}
;
built_in_constant
: #(BUILT_IN_CONSTANT (
"const_e"
| "pi"
| "self"
| QUESTION {unlimited_bound=true;}
| STAR
))
;
case_action
: #(CASE_ACTION case_label ( case_label )* stmt)
;
case_label
: #(CASE_LABEL expression)
;
case_stmt
: #(CASE_STMT selector ( case_action )* ( stmt )? )
;
compound_stmt
: #(COMPOUND_STMT stmt ( stmt )* )
;
constant_body
: #(CONSTANT_BODY constant_id base_type expression )
;
constant_decl
: #(CONSTANT_DECL constant_body ( constant_body )* )
;
constant_factor
: #(CONSTANT_FACTOR (
built_in_constant
| constant_ref
))
;
constant_id
: #(CONSTANT_ID IDENT)
;
declaration
: #(DECLARATION (
entity_decl
| subtype_constraint_decl
| function_decl
| procedure_decl
| type_decl["test"]
))
;
domain_rule
: #(DOMAIN_RULE ( label )? logical_expression)
;
element
: #(ELEMENT expression ( repetition )?)
;
/*
simpleEntities
{
OWLNamedClass cl=null;
String name="";
}
: #(ENTITY_HEAD name=entity_id)
{
System.out.println(name);
if (owlModel.getOWLNamedClass(name)== null)
cl=owlModel.createOWLNamedClass(name);
}
;
*/
entity_head returns [String className=""]
{ //System.out.println("creating subclass for "+ cl.getName());
//OWLNamedClass cl=null;
String name="";
String[] sub={"",""};
}
: #(ENTITY_HEAD name=entity_id( "abstract" )?
{
// // methods.order=0;
// if (methods.owlModel.getOWLNamedClass(name)== null)
// {
// cl=methods.owlModel.createOWLNamedClass(name);
//
//
// }
// else cl=methods.owlModel.getOWLNamedClass(name);
// className=cl.getName();
// // System.out.println("name:"+name+", "+className);
EntityDefinition ent = schema.getEntityBN(name);
if (pass==1){
if (ent == null)
{
ent = new EntityDefinition(name);
schema.addEntity(ent);
}
}
className=name;
}
(sub=subsuper/*[cl]*/)? ){
//System.out.println("Subtype of "+name+" sub "+sub);
if (pass==2 && !sub[0].equals("")){
EntityDefinition parent = schema.getEntityBN(sub[0]);
ent.addSupertype(parent);
}
if (pass==2 && !sub[1].equals("true")){
ent.setInstantiable(true);
}
}
;
entity_decl
{
String className ="";
}
: #(ENTITY_DECL className=entity_head
{
}
entity_body[className])
;
entity_body [String forClass] returns [String atrribs=""]
: #(ENTITY_BODY (explicit_attr[forClass])* (derive_clause[forClass])? (inverse_clause[forClass])? (unique_clause)? (where_clause)?)
;
subsuper /*[OWLNamedClass cl]*/ returns [String[] sub]
{//System.out.println("working on "+cl.getName());
//sub={"",""};
sub=new String[]{"",""};
String subcls="";
String abst="";
}
: #(SUBSUPER ( abst=supertype_constraint )? ( subcls=subtype_declaration/*[cl]*/ )?)
{ sub[0]=subcls;
sub[1]=abst; }
;
supertype_constraint returns [String isAbstract=""]
: #(SUPERTYPE_CONSTRAINT (
isAbstract=abstract_supertype_declaration
| supertype_rule
))
;
abstract_supertype_declaration returns [String isAbstract="true"]
: #(ABSTRACT_SUPERTYPE_DECLARATION ( subtype_constraint )? )
;
/*subtype_declaration
: #(SUBTYPE_DECLARATION entity_ref ( entity_ref )*)
;*/
subtype_declaration /*[OWLNamedClass cl]*/ returns [String subent=""]
{
//String subent = "t";
String sub="";
}
: #(SUBTYPE_DECLARATION subent=get_ref /*entity_ref ( entity_ref )* */)
{
//System.out.println("subtype_declaration: "+subent);
// // if (cl.getName().indexOf("IfcApprovalActorRelationship")>-1)
// // System.out.println("debug");
// if(methods.owlModel.getOWLNamedClass(subent) == null)
// {
// // System.out.println(": creating root class "+subent);
// methods.owlModel.createOWLNamedClass(subent);
//
// }
// // System.out.println(": adding EXISTING superclass ..."+subent);}
// cl.addSuperclass(methods.owlModel.getOWLNamedClass(subent));
// cl.removeSuperclass(methods.owlModel.getOWLThingClass());
// //}
// //System.out.println(subent);
// sub = subent;
//System.out.println("subtype for "+ cl.getName() +" is "+ subent );
}
;
subtype_constraint_decl
: #(SUBTYPE_CONSTRAINT_DECL subtype_constraint_head subtype_constraint_body )
;
subtype_constraint_head
: #(SUBTYPE_CONSTRAINT_HEAD subtype_constraint_id entity_ref )
;
subtype_constraint_body
: #(SUBTYPE_CONSTRAINT_BODY ( abstract_supertype )? ( total_over )? ( supertype_expression )? )
;
subtype_constraint_id
: #(SUBTYPE_CONSTRAINT_ID i:IDENT)
{ //System.out.println(i.getText());
}
;
abstract_supertype
: #(ABSTRACT_SUPERTYPE nothing)
;
total_over
: #(TOTAL_OVER entity_ref ( entity_ref )* )
;
//definition of actual attributes. Not to be mistaken for TYPE definitions
explicit_attr [String forClass]
{
String PropName,TypeName="";
boolean isOptional = false;
String ConcreteType="";
String[] BoundedType=new String[4];
}
: #(EXPLICIT_ATTR PropName=attribute_decl (attribute_decl)* ("optional" {isOptional=true;})
//? #( BASE_TYPE(ConcreteType=concrete_types | /*TypeName=base_type */TypeName=generalized_types)))
? #( BASE_TYPE( #(CONCRETE_TYPES
(
ConcreteType=simple_types
| ConcreteType=named_types
| BoundedType=aggregation_types
)
)
|( TypeName=generalized_types))
)
)
{
if (pass==2){
EntityDefinition ent = schema.getEntityBN(forClass);
if ((BoundedType[0]!=null) && (ent!=null) )
{
/*ConcreteType=BoundedType[0];*/
AggregationType aggr =null;
BaseType bt = schema.getBaseTypeBN(BoundedType[0]);
if (bt==null) System.err.println("WARNING: could not find "+ BoundedType[0]+"(for +"+forClass+")");
if (BoundedType[3].equals("LIST")) aggr=new ListType (schema.getBaseTypeBN(BoundedType[0]));
else if (BoundedType[3].equals("BAG")) aggr=new BagType (schema.getBaseTypeBN(BoundedType[0]));
else if (BoundedType[3].equals("ARRAY")) aggr=new ArrayType (schema.getBaseTypeBN(BoundedType[0]));
else if (BoundedType[3].equals("SET")) aggr=new SetType (schema.getBaseTypeBN(BoundedType[0]));
String lbs = BoundedType[1];
String ubs = BoundedType[2];
if (lbs == "" || lbs == "?")lbs="-1";
if (ubs == "" || ubs == "?")ubs="-1";
IntegerBound lb = new IntegerBound (new Integer(lbs));
IntegerBound ub = new IntegerBound (new Integer(ubs));
if (aggr instanceof VariableSizeAggregationType){
((VariableSizeAggregationType)aggr).setUpper_bound(ub);
((VariableSizeAggregationType)aggr).setLower_bound(ub);
}
else if (aggr instanceof ArrayType){
((ArrayType)aggr).setLower_index(lb);
((ArrayType)aggr).setUpper_index(ub);
}
ExplicitAttribute attr= new ExplicitAttribute(PropName,ent);
attr.setOptional(isOptional);
attr.setDomain(aggr);
ent.addAttribute(attr);
//System.out.println(forClass +" has Prop " +PropName + " of " + aggr.getClass() + "["+lb.getBound_value()+":"+ub.getBound_value()+"]"+" of Type "+aggr.getElement_type());
}
//System.out.println(forClass +" has Prop " +PropName + " of Type "+ConcreteType);
else if ((ent!=null) ){
ExplicitAttribute attr= new ExplicitAttribute(PropName,ent);
attr.setDomain(schema.getBaseTypeBN(ConcreteType));
attr.setOptional(isOptional);
ent.addAttribute(attr);
//System.out.println(forClass +" has Prop " +PropName + " of Type "+ConcreteType);
}
}
if (ConcreteType.indexOf("SIMPLETYPE")==0)
{
if (pass==2){
EntityDefinition ent = schema.getEntityBN(forClass);
if ((ent!=null) ){
ExplicitAttribute attr= new ExplicitAttribute(PropName,ent);
attr.setDomain(schema.getBaseTypeBN(ConcreteType));
attr.setOptional(isOptional);
ent.addAttribute(attr);
//System.out.println(forClass +" has Prop " +PropName + " of Type "+ConcreteType);
}
}
// methods.createSimpleTypeInstance(forClass, PropName, ConcreteType.substring(new String("SIMPLETYPE").length()));
}
else if (ConcreteType.startsWith("TYPE"))
{
// methods.createDerivedListProperty(forClass, PropName, ConcreteType.substring(new String("TYPE").length()));
}
else if (ConcreteType.indexOf("UNDERLYING_TYPE")>-1)
{
//for a working version
// methods.createDatatypePropFromNamedType(forClass,
// PropName,
// ConcreteType.substring(new String("UNDERLYING_TYPE").length()));
}
else if (ConcreteType.indexOf("ENTITY_REF")>-1) {
String type=ConcreteType.substring(new String("ENTITY_REF").length());
// methods.createOrExtendObjectProperty(forClass, PropName,type );
}
if (BoundedType[0]!=null) {
// methods.addCardinalityConstraint(forClass,PropName,BoundedType[1],BoundedType[2]);
}
}
| #(EXPLICIT_ATTR PropName=attribute_decl (attribute_decl)* ("optional" {isOptional=true;})? TypeName=simple_types)
{
//System.out.println("SimpleType");
}
;
attribute_decl returns [String PropName=""]
: #(ATTRIBUTE_DECL (
PropName=attribute_id
| redeclared_attribute
))
{
}
;
redeclared_attribute returns [String PropName=""]
: #(REDECLARED_ATTRIBUTE qualified_attribute ( PropName=attribute_id )? )
;
attribute_id returns [String PropName=""]
: #(ATTRIBUTE_ID i:IDENT)
// {methods.entityElement.addContent(new Comment("Element" + methods.entityElement.getAttributeValue("name") + "." + i.getText()));
{PropName = i.getText();}
//OWLObjectProperty childrenProperty = owlModel.createOWLObjectProperty(entityElement.getAttributeValue("name") + "." +i.getText());
//childrenProperty.setRange(owlClass);
//childrenProperty.addUnionDomainClass(owlClass);
//}
;
qualified_attribute
: #(QUALIFIED_ATTRIBUTE group_qualifier attribute_qualifier)
;
derive_clause [String forClass]
: #(DERIVE_CLAUSE derived_attr[forClass] (derived_attr[forClass])* )
;
derived_attr [String forClass]
{
String attrib = "";
}
: #(DERIVED_ATTR ("SELF\\" IDENT ".")? attrib=attribute_decl base_type expression)
{
if (pass==4) {
EntityDefinition ent = schema.getEntityBN(forClass);
ent.addDerived(attrib);
// Attribute att = ent.getAttributeBNWithSuper(attrib);
// LOGGER.info(forClass + "." + attrib);
// if (att == null) {
// LOGGER.info("null");
// } else {
// LOGGER.info(att.toString());
// }
// att.setDerived(true);
}
}
;
inverse_clause [String forClass]
: #(INVERSE_CLAUSE inverse_attr[forClass] (inverse_attr[forClass])* )
;
inverse_attr [String forClass]
{
String attrib,entity,attrib_ref="";
String[] bounds=new String[2];
}
: #(INVERSE_ATTR attrib=attribute_decl ( ( "set" | "bag" ) ( bounds=bound_spec )? )? entity=entity_ref attrib_ref=attribute_ref)
{
//wait filling out the inverse attributes until the 3rd pass, when all other
//attributes have been filled in
if (pass==3)
{
EntityDefinition ent = schema.getEntityBN(entity);
EntityDefinition forEnt = schema.getEntityBN(forClass);
if (ent != null){
ExplicitAttribute attr = (ExplicitAttribute)ent.getAttributeBN(attrib_ref);
if (attr != null)
{
//System.out.println("INVERSE "+attrib+" of " + ent.getName()+" for " +attrib_ref);
InverseAttribute inv = new InverseAttribute(attrib,ent);
if (bounds[0]!=null && bounds[1]!=null){
if ((bounds[0].equals("")) || (bounds[0].equals("?"))) bounds[0]="-1";
if ((bounds[1].equals("")) || (bounds[1].equals("?"))) bounds[1]="-1";
Bound lb = new IntegerBound(new Integer(bounds[0]));
Bound ub = new IntegerBound(new Integer(bounds[1]));
inv.setMin_cardinality(lb);
inv.setMax_cardinality(ub);
}
inv.setDomain(ent);
inv.setInverted_attr(attr);
forEnt.addAttribute(inv);
}
}
}
// methods.createInverseObjectProperty (forClass,attrib,attrib_ref,entity);
// if (bounds[0]!=null)
// {
// methods.addCardinalityConstraint(forClass,attrib,bounds[0],bounds[1]);
// }
//
// System.out.println("Inverse " + attrib + " for " + entity);
}
;
unique_clause
: #(UNIQUE_CLAUSE unique_rule ( unique_rule )* )
;
unique_rule
: #(UNIQUE_RULE ( label )? referenced_attribute ( referenced_attribute)*)
;
referenced_attribute
: #(REFERENCED_ATTRIBUTE (
attribute_ref
| qualified_attribute
))
;
entity_constructor
: #(ENTITY_CONSTRUCTOR entity_ref ( expression ( expression )* )? )
;
entity_id returns [String name]
{
String entityName = null;
name = "";
}
: #(ENTITY_ID id:IDENT)
{
entityName = id.getText();
name=entityName;
}
;
enumeration_reference
: #(ENUMERATION_REFERENCE ( type_ref )? enumeration_ref)
;
escape_stmt
: #(ESCAPE_STMT nothing)
;
expression
: #(EXPRESSION simple_expression ( rel_op_extended simple_expression )?)
;
rel_op_extended
: #(REL_OP_EXTENDED (
rel_op
| "in"
| "like"
))
;
rel_op
: #(REL_OP (
LT
| GT
| LE
| GE
| LTGT
| ASSIGN
| COLLTGT
| COLEQCOL
))
;
factor
: #(FACTOR simple_factor ( simple_factor )?)
;
formal_parameter
: #(FORMAL_PARAMETER parameter_id ( parameter_id )* parameter_type)
;
attribute_qualifier
: #(ATTRIBUTE_QUALIFIER attribute_ref)
;
function_call
: #(FUNCTION_CALL ( function_ref | built_in_function ) ( actual_parameter_list )?)
;
built_in_function
: #(BUILT_IN_FUNCTION (
"abs"
| "acos"
| "asin"
| "atan"
| "blength"
| "cos"
| "exists"
| "exp"
| "format"
| "hibound"
| "hiindex"
| "length"
| "lobound"
| "loindex"
| "log"
| "log2"
| "log10"
| "nvl"
| "odd"
| "rolesof"
| "sin"
| "sizeof"
| "sqrt"
| "tan"
| "typeof"
| "usedin"
| "value"
| "value_in"
| "value_unique"
))
;
function_decl
: #(FUNCTION_DECL function_head ( algorithm_head)? stmt ( stmt )*)
;
function_head
: #(FUNCTION_HEAD function_id ( formal_parameter ( formal_parameter )* )? parameter_type )
;
function_id
: #(FUNCTION_ID IDENT)
;
generalized_types returns [String TypeName=""]
: #(GENERALIZED_TYPES (
aggregate_type
| TypeName=general_aggregation_types
| generic_type
| generic_entity_type
))
;
generic_entity_type
: #(GENERIC_ENTITY_TYPE nothing)
;
general_aggregation_types returns [String TypeName=""]
: #(GENERAL_AGGREGATION_TYPES (
general_array_type
| general_bag_type
| TypeName=general_list_type
| general_set_type
))
;
general_array_type
: #(GENERAL_ARRAY_TYPE ( bound_spec )? ( "optional" )? ( "unique" )? parameter_type )
{
// System.out.println("array");
}
;
general_bag_type
: #(GENERAL_BAG_TYPE ( bound_spec )? parameter_type )
;
general_list_type returns [String TypeName=""]
: #(GENERAL_LIST_TYPE ( bound_spec )? ( "unique" )? tn:parameter_type )
{
//System.out.println("list");
//TypeName += tn.getText();
}
;
general_ref
: #(GENERAL_REF (
parameter_ref
| variable_ref
))
;
general_set_type
: #(GENERAL_SET_TYPE ( bound_spec )? parameter_type )
;
generic_type
: #(GENERIC_TYPE ( type_label )? )
;
group_qualifier
: #(GROUP_QUALIFIER entity_ref )
;
if_stmt
: #(IF_STMT logical_expression stmt ( stmt )* ( else_clause )? )
;
/* added rule (and node) to break a nondeterminism (stmt) */
else_clause
: #(ELSE_CLAUSE stmt ( stmt )* )
;
increment
: #(INCREMENT numeric_expression)
;
increment_control
: #(INCREMENT_CONTROL variable_id bound_1 bound_2 ( increment )? )
;
index
: #(INDEX numeric_expression)
;
index_1
: #(INDEX_1 index)
;
index_2
: #(INDEX_2 index)
;
index_qualifier
: #(INDEX_QUALIFIER index_1 ( index_2 )? )
;
integer_type returns [String TypeName="INTEGER"]
: #(INTEGER_TYPE nothing)
;
interval
: #(INTERVAL interval_low interval_op interval_item interval_op interval_high )
;
interval_high
: #(INTERVAL_HIGH simple_expression)
;
interval_item
: #(INTERVAL_ITEM simple_expression)
;
interval_low
: #(INTERVAL_LOW simple_expression)
;
interval_op
: #(INTERVAL_OP (
LT
| LE
))
;
label
: #(LABEL IDENT)
;
list_type returns [String[] TypeName= new String[4]]
{
String[] bounds= new String[2];
String type="";
}
: #(LIST_TYPE ( bounds=bound_spec )? ( "unique" )? type=base_type )
{
//TypeName=" is a List of " + test + TypeName ;
//System.out.println ("L I S T" + test);
TypeName[0]=type;
TypeName[1]=bounds[0];
TypeName[2]=bounds[1];
TypeName[3]="LIST";
}
;
/* POD removed binary_literal */
literal
: #(LITERAL (
real_literal
| integer_literal
| logical_literal
| string_literal
))
;
integer_literal
: #(INTEGER_LITERAL i:INT)
{
nextInt=i.getText();
}
;
real_literal
: #(REAL_LITERAL FLOAT)
;
string_literal
: #(STRING_LITERAL STRING)
;
local_decl
: #(LOCAL_DECL local_variable ( local_variable )* )
;
local_variable
: #(LOCAL_VARIABLE variable_id ( variable_id )* parameter_type ( expression )? )
;
logical_expression
: #(LOGICAL_EXPRESSION expression)
;
logical_literal
: #(LOGICAL_LITERAL (
"false"
| "true"
| "unknown"
))
;
logical_type returns [String TypeName="LOGICAL"]
: #(LOGICAL_TYPE nothing)
;
named_types returns [String TypeName=""]
: #(NAMED_TYPES (
TypeName=entity_ref {TypeName = TypeName;}
| TypeName=type_ref {TypeName = TypeName; }
))
;
null_stmt
: #(NULL_STMT nothing)
;
number_type returns [String TypeName="NUMBER"]
: #(NUMBER_TYPE nothing)
;
numeric_expression returns [String se=""]
: #(NUMERIC_EXPRESSION s:simple_expression)
{
se=s.toStringList();
}
;
one_of
: #(ONE_OF supertype_expression ( supertype_expression )* )
;
parameter
: #(PARAMETER expression)
;
parameter_id
: #(PARAMETER_ID IDENT)
;
parameter_type returns [String TypeName =""]
: #(PARAMETER_TYPE (
TypeName=generalized_types
| TypeName=named_types
| TypeName=simple_types
))
;
population
: #(POPULATION entity_ref)
;
precision_spec
: #(PRECISION_SPEC numeric_expression)
;
primary
: #(PRIMARY (
literal
| qualifiable_factor ( qualifier )*
))
;
procedure_call_stmt
: #(PROCEDURE_CALL_STMT ( procedure_ref | built_in_procedure ) ( actual_parameter_list )?)
;
built_in_procedure
: #(BUILT_IN_PROCEDURE (
"insert"
| "remove"
))
;
procedure_decl
: #(PROCEDURE_DECL procedure_head ( algorithm_head )? ( stmt )*)
;
procedure_head
: #(PROCEDURE_HEAD procedure_id ( ( "var" )? formal_parameter ( ( "var" )? formal_parameter )* )? )
;
procedure_id
: #(PROCEDURE_ID IDENT)
;
qualifiable_factor
: #(QUALIFIABLE_FACTOR (
attribute_ref
| constant_factor
| function_call
| population
| general_ref
))
;
qualifier
: #(QUALIFIER (
attribute_qualifier
| group_qualifier
| index_qualifier
))
;
query_expression
: #(QUERY_EXPRESSION variable_id aggregate_source logical_expression )
;
real_type returns [String TypeName="REAL"]
: #(REAL_TYPE ( precision_spec )? )
;
reference_clause
: #(REFERENCE_CLAUSE schema_ref
( resource_or_rename ( resource_or_rename )* )?)
;
rename_id
: #(RENAME_ID (
constant_id
| entity_id
| function_id
| procedure_id
| type_id
))
;
repeat_control
: #(REPEAT_CONTROL ( increment_control )? ( while_control )? ( until_control )?)
;
repeat_stmt
: #(REPEAT_STMT repeat_control stmt ( stmt )* )
;
repetition
: #(REPETITION numeric_expression)
;
resource_or_rename
: #(RESOURCE_OR_RENAME resource_ref ( rename_id )?)
;
resource_ref
: #(RESOURCE_REF (
constant_ref
| entity_ref
| function_ref
| procedure_ref
| type_ref
))
;
return_stmt
: #(RETURN_STMT ( expression )? )
;
rule_decl
: #(RULE_DECL rule_head ( algorithm_head )? ( stmt )* where_clause)
;
rule_head
: #(RULE_HEAD rule_id entity_ref ( entity_ref )* )
;
rule_id
: #(RULE_ID IDENT)
;
schema_id returns [String schemaName]
{
schemaName = null;
}
: #(SCHEMA_ID id:IDENT)
{
schemaName = id.getText();
}
;
schema_body
: #(SCHEMA_BODY ( interface_specification )* ( constant_decl )? ( declaration | rule_decl )*)
;
schema_decl //returns [Element schemaElement]
{
// schemaElement = null;
// Element contents = new Element("complexType", methods.xsd);;
// String schemaName = null;
// methods.schemaContents = methods.makeChoiceElement("0", "unbounded");
}
: #(SCHEMA_DECL ( schema_version_id )? /*schemaName=*/schema_id
{
/* schemaElement =
(new Element("element", methods.xsd).addContent(contents));
schemaElement.setAttribute
(new Attribute("name", "schema-instance"));
contents.addContent(methods.schemaContents);
contents.addContent
(new Element
("attributeGroup", methods.xsd).setAttribute
(new Attribute("ref", "schema-instance.atts")));
contents.addContent
(new Element
("attribute", methods.xsd).setAttribute
(new Attribute
("name", "express_schema_name")).setAttribute
(new Attribute
("type", methods.xsd.getPrefix()+":NMTOKEN")).setAttribute
(new Attribute
("fixed", methods.capitalizeFirstLetter(schemaName))));
*/ }
schema_body)
;
schema_version_id
: #(SCHEMA_VERSION_ID string_literal)
;
interface_specification
: #(INTERFACE_SPECIFICATION (
reference_clause
| use_clause
))
;
use_clause
: #(USE_CLAUSE schema_ref ( named_type_or_rename ( named_type_or_rename )* )? )
;
named_type_or_rename
: #(NAMED_TYPE_OR_RENAME named_types ( entity_id | type_id )?)
;
selector
: #(SELECTOR expression)
;
/*
set_type
: #(SET_TYPE ( bound_spec )? base_type )
;
*/
set_type returns [String[] TypeName= new String[4]]
{
String[] bounds= new String[2];
String type="";
}
: #(SET_TYPE ( bounds=bound_spec )? ( "unique" )? type=base_type )
{
//TypeName=" is a List of " + test + TypeName ;
//System.out.println ("L I S T" + test);
TypeName[0]=type;
TypeName[1]=bounds[0];
TypeName[2]=bounds[1];
TypeName[3]="SET";
}
;
simple_expression
: #(SIMPLE_EXPRESSION term ( add_like_op term )* )
;
add_like_op
: #(ADD_LIKE_OP (
PLUS
| MINUS
| "or"
| "xor"
))
;
simple_factor
: #(SIMPLE_FACTOR (
aggregate_initializer
| interval
| query_expression
| entity_constructor
| enumeration_reference
| ( unary_op )? ( expression | primary )
))
;
simple_types returns [String TypeName="simpleType"]
{
SimpleType st;
}
: #(SIMPLE_TYPES (
TypeName=binary_type
| TypeName=boolean_type
| TypeName=integer_type
| TypeName=logical_type
| TypeName=number_type
| TypeName=real_type
| TypeName=string_type
)
)
//{System.out.println("SimpleTYPE: "+ TypeName);}
;
//declares
simple_types_decl_bt returns [SimpleType st = null]
{
String TypeName="";
}
: #(SIMPLE_TYPES (
TypeName=binary_type {st = new BinaryType (); }
| TypeName=boolean_type {st = new BooleanType (); }
| TypeName=integer_type {st = new IntegerType ();}
| TypeName=logical_type {st = new LogicalType ();}
| TypeName=number_type {st = new NumberType ();}
| TypeName=real_type {st = new RealType (); }
| TypeName=string_type {st = new StringType ();}
//{if (schema.getBaseType(st)==null) schema.addType(st);}
))
;
skip_stmt
: #(SKIP_STMT nothing)
;
stmt
: #(STMT (
alias_stmt
| assignment_stmt
| case_stmt
| compound_stmt
| escape_stmt
| if_stmt
| null_stmt
| procedure_call_stmt
| repeat_stmt
| return_stmt
| skip_stmt
))
;
string_type returns [String TypeName="STRING"]
: #(STRING_TYPE ( width_spec )? )
;
subtype_constraint
: #(SUBTYPE_CONSTRAINT supertype_expression)
;
supertype_expression
: #(SUPERTYPE_EXPRESSION supertype_factor ( supertype_factor )*)
;
supertype_factor
: #(SUPERTYPE_FACTOR supertype_term ( supertype_term )*)
;
supertype_rule
: #(SUPERTYPE_RULE subtype_constraint )
;
supertype_term
: #(SUPERTYPE_TERM (
entity_ref
| one_of
| supertype_expression
))
;
syntax
{
}
: #(SYNTAX ( language_version_id )? schema_decl
( schema_decl )*)
;
syntax_pass2
{
}
: #(SYNTAX ( language_version_id )? schema_decl
( schema_decl )*)
;
language_version_id
: #(LANGUAGE_VERSION_ID nothing)
;
term
: #(TERM factor ( multiplication_like_op factor )*)
;
multiplication_like_op
: #(MULTIPLICATION_LIKE_OP (
STAR
| DIVSIGN
| "div"
| "mod"
| "and"
| DOUBLEBAR
))
;
type_decl [String IDName]
{String UTN, TypeID="";UnderlyingType ut=null;}
: #(TYPE_DECL TypeID=type_id ut=underlying_type_decl[TypeID] ( where_clause )? )
{
if (!(ut instanceof SelectType) && !(ut instanceof EnumerationType)){
DefinedType dt;
if (pass==1){
dt = new DefinedType(TypeID);
if (schema.getTypeBN(TypeID)==null)schema.addType(dt);
}
else if (pass==2){
schema.getTypeBN(TypeID).setDomain(ut);
}
}
// methods.createOrExtendDatatypeProperty("",TypeID,UnderlyingTypeName);
// if (UnderlyingTypeName.startsWith("SIMPLETYPE")) {
//
// UnderlyingTypeName=UnderlyingTypeName.substring(new String("SIMPLETYPE").length());
// methods.createDatatypePropertyListInstance("",
// TypeID,
// UnderlyingTypeName);
// }
// else if (UnderlyingTypeName.startsWith("UNDERLYING_TYPE")) {
//
// UnderlyingTypeName=UnderlyingTypeName.substring(new String("UNDERLYING_TYPE").length());
// {
// methods.createDerivedType("",
// TypeID,
// UnderlyingTypeName);
// }
// }
// else{
// //methods.createOrExtendDatatypeProperty("",TypeID,UnderlyingTypeName);
// }
}
;
underlying_type_decl [String TypeName] returns [UnderlyingType ut =null]
{
String UTN="";
}
: #(UNDERLYING_TYPE (
constructed_types [TypeName]
{
// System.out.println ("ENUMERATION"+TypeName);
}
| aggregation_types
| ut=simple_types_decl_bt {
}
| UTN=type_ref {
if (isPass2()){
//TODO add Type Reference here
ut = schema.getTypeBN(UTN);
System.err.println(TypeName+"PASS 2 get TYPEREF:"+UTN);
}
else {System.err.println("PASS one:"+TypeName);}
//UnderlyingTypeName="UNDERLYING_TYPE"+UnderlyingTypeName;
//System.out.println("debug"+UnderlyingTypeName);
}
))
;
underlying_type [String TypeName] returns [String UnderlyingTypeName =""]
{
String UTN="";
}
: #(UNDERLYING_TYPE (
constructed_types [TypeName]
{
// System.out.println ("ENUMERATION"+TypeName);
}
| aggregation_types
| UnderlyingTypeName=simple_types {
}
| UnderlyingTypeName=type_ref {
if (isPass2()){
//TODO add Type Reference here
}
//UnderlyingTypeName="UNDERLYING_TYPE"+UnderlyingTypeName;
//System.out.println("debug"+UnderlyingTypeName);
}
))
{
if(UnderlyingTypeName.indexOf("IfcPositiveLength")>-1)
{
System.out.println("test");
}
}
;
constructed_types [String TypeName]
{
List ItemList = new ArrayList();
}
: #(CONSTRUCTED_TYPES (
ItemList=enumeration_type
{
EnumerationType et;
if (pass==1){
et = new EnumerationType(TypeName);
schema.addType(et);
}
else if (pass==2){
et = (EnumerationType)schema.getTypeBN(TypeName);
Iterator li = ItemList.iterator();
while (li.hasNext()){
Object o =li.next();
et.addElement(o.toString());
}
}
}
| ItemList=select_type
{
SelectType st;
// in the first pass, create the type for further use
if (pass==1){
st = new SelectType(TypeName);
schema.addType(st);
}
// in the second one, get it from the schema and fill in the
// actual selections
if (isPass2()){
st = (SelectType)schema.getTypeBN(TypeName);
Iterator li = ItemList.iterator();
while (li.hasNext()){
Object o =li.next();
//SELECT types can either be ENTITYs or TYPEs, so
//check which one it it s and add it
NamedType nt = schema.getTypeBN(o.toString());
if (nt == null)
nt = schema.getEntityBN(o.toString());
if (nt!=null)
st.addSelection(nt);
}
}
}
))
;
enumeration_type returns [List ItemList = new ArrayList()]
{
//String[] Items;
}
: #(ENUMERATION_TYPE ( "extensible" )? ( ( ItemList=enumeration_items | enumeration_extension ) )? )
;
enumeration_items returns [List items = new ArrayList();]
{
String id0,id;
}
: #(ENUMERATION_ITEMS id0=enumeration_id {items.add(id0);} ( id=enumeration_id {items.add(id);})* )
;
enumeration_extension
: #(ENUMERATION_EXTENSION type_ref ( enumeration_items )? )
;
enumeration_id returns [String identifier=""]
: #(ENUMERATION_ID id:IDENT{identifier=id.getText();})
;
select_type returns [List items = new ArrayList();]
//{ System.out.println("SELECT_TYPE");}
: #(SELECT_TYPE ( "extensible" )? ( "generic_entity" )? ( ( items=select_list | select_extension ) )? )
;
select_list returns [List items=new ArrayList();]
{
String id0,id;
}
: #(SELECT_LIST id0=named_types {items.add(id0);}( id=named_types {items.add(id);} )* )
;
select_extension
: #(SELECT_EXTENSION type_ref ( select_list )? )
;
type_id returns [String identifyer=""]
: #(TYPE_ID id:IDENT)
{identifyer=id.getText();}
;
type_label
: #(TYPE_LABEL IDENT)
;
type_label_id
: #(TYPE_LABEL_ID IDENT)
;
unary_op
: #(UNARY_OP (
PLUS
| MINUS
| "not"
))
;
until_control
: #(UNTIL_CONTROL logical_expression)
;
variable_id
: #(VARIABLE_ID IDENT)
;
where_clause
: #(WHERE_CLAUSE domain_rule ( domain_rule )* )
;
while_control
: #(WHILE_CONTROL logical_expression )
;
width
: #(WIDTH numeric_expression)
;
width_spec
: #(WIDTH_SPEC width ( "fixed" )?)
;
entity_ref returns [String TypeName=""]
: #(ENTITY_REF i:IDENT)
//{entityElement.addContent(new Comment("ENTITY REF: " + entityElement.getAttributeValue("name") + "." + i.getText()));}
{
TypeName=i.getText();
}
;
get_ref returns [String subent="test"]
: #(ENTITY_REF i:IDENT)
{subent=i.getText();}
;
type_ref returns [String TypeName=""]
: #(TYPE_REF i:IDENT)
{
TypeName=i.getText();
}
;
enumeration_ref
: #(ENUMERATION_REF i:IDENT)
// {entityElement.addContent(new Comment("ENUMERATION REF: " + entityElement.getAttributeValue("name") + "." + i.getText()));}
//{System.out.println("ENUMERATION------"+i.getText());}
;
attribute_ref returns [String attrib_ref = ""]
: #(ATTRIBUTE_REF id:IDENT {attrib_ref=id.getText();})
// {entityElement.addContent(new Comment("ATTRIBUTE REF: " + entityElement.getAttributeValue("name") + "." + i.getText()));}
;
constant_ref
: #(CONSTANT_REF IDENT)
;
function_ref
: #(FUNCTION_REF IDENT)
;
parameter_ref
: #(PARAMETER_REF IDENT)
;
variable_ref
: #(VARIABLE_REF IDENT)
;
schema_ref
: #(SCHEMA_REF IDENT)
;
type_label_ref
: #(TYPE_LABEL_REF IDENT)
;
procedure_ref
: #(PROCEDURE_REF IDENT)
;
/* added pseudo-rule because you can't have nodes without arguments */
nothing
: ("")?
;