-options {\r
- JDK_VERSION = "1.6";\r
- STATIC = false;\r
- IGNORE_CASE = false;\r
-}\r
-\r
-PARSER_BEGIN(DataParser)\r
-package org.simantics.databoard.parser;\r
-\r
-import org.simantics.databoard.parser.ast.type.*;\r
-import org.simantics.databoard.parser.ast.value.*;\r
-import java.util.ArrayList;\r
-import java.util.List;\r
-import java.util.Collections;\r
-\r
-/**\r
- * Parser for data type definitions.\r
- * @author Hannu Niemist�\r
- */\r
-public class DataParser { \r
-}\r
-PARSER_END(DataParser)\r
-\r
-/*** Lexer *********************************************************/\r
-\r
-SKIP:\r
-{ <WHITESPACE: " " | "\n" | "\r" | "\t" > \r
-| <COMMENT1: "/*" (~["*"] | "*" ~["/"])* "*/" > \r
-| <COMMENT2: "//" (~["\n"])* >\r
-}\r
-\r
-TOKEN:\r
-{ ";" | "(" | ")" | "?" | "[" | "]"\r
-| "{" | "}" | "|" | "&" | ":" \r
-| "," | ".." | "." | "=" | "<" | ">"\r
-| "type" | "true" | "false" | "null" | "map" | "referable"\r
-| <STRING: "\"" (~["\"", "\\", "\n"] | "\\" ~["\n"])* "\"">\r
- { matchedToken.image = StringEscapeUtils.unescape(\r
- matchedToken.image.substring(1,matchedToken.image.length()-1)); }\r
-| <LONG_STRING: "\"\"\"" (~["\""] | "\"" ~["\""] | "\"\"" ~["\""])* "\"\"\"">\r
- { matchedToken.image = matchedToken.image.substring(3,matchedToken.image.length()-3); }\r
-| <#POSITIVE_INTEGER: (["0"-"9"])+ >\r
-| <INTEGER: ("-"|"+")? <POSITIVE_INTEGER> >\r
-| <FLOAT: \r
- ("-")? \r
- ( <POSITIVE_INTEGER> "." <POSITIVE_INTEGER> (["e","E"] <INTEGER>)?\r
- | "." <POSITIVE_INTEGER> (["e","E"] <INTEGER>)?\r
- | <POSITIVE_INTEGER> ["e","E"] <INTEGER>\r
- | "NaN"\r
- | "Infinity"\r
- ) >\r
-| <IDENT: ["a"-"z","A"-"Z","_"] (["a"-"z","A"-"Z","_","0"-"9"])* >\r
-| <URI: "<" (~["<",">"])* ">"> \r
- { matchedToken.image = matchedToken.image.substring(1,matchedToken.image.length()-1); }\r
-}\r
-\r
-/*** Type parser ***************************************************/\r
-\r
-List<AstTypeDefinition> typeDefinitions() : {\r
- AstTypeDefinition def;\r
- List<AstTypeDefinition> result = new ArrayList<AstTypeDefinition>();\r
-} {\r
- ( def=typeDefinition() { result.add(def); } )* <EOF>\r
- { return result; }\r
-}\r
-\r
-AstTypeDefinition typeDefinition() : {\r
- Token name;\r
- AstType type;\r
-} {\r
- "type" name=<IDENT> "=" type=type() \r
- { return new AstTypeDefinition(name.image, type); } \r
-}\r
-\r
-AstType type() : { \r
- AstType type;\r
-} {\r
- type=simpleType()\r
- { return type; }\r
- | type=unionType()\r
- { return type; }\r
-}\r
-\r
-AstType unionType() : {\r
- List<AstComponent> components = new ArrayList<AstComponent>(4);\r
-} {\r
- ( "|" unionComponent(components) )+\r
- { return new AstUnionType(components); }\r
-}\r
-\r
-private void unionComponent(List<AstComponent> components) : {\r
- Token tag;\r
- AstType type;\r
-} {\r
- tag=<IDENT>\r
- ( \r
- type=simpleType() { components.add(new AstComponent(tag.image, type)); }\r
- | { components.add(new AstComponent(tag.image, AstRecordType.EMPTY_RECORD)); }\r
- ) \r
-}\r
-\r
-AstType simpleType() : { \r
- AstType type;\r
-} {\r
- type=basicType()\r
- ( "[" type=arraySuffix(type) )*\r
- { return type; }\r
-}\r
-\r
-private AstType arraySuffix(AstType componentType) : {\r
- Token t1, t2;\r
- Integer v1;\r
-} {\r
- "]" { \r
- return new AstArrayType(componentType, null, null); \r
- }\r
- | ".." t1=<INTEGER> "]" {\r
- v1 = Integer.parseInt(t1.image); \r
- return new AstArrayType(componentType, null, v1); \r
- }\r
- | t1=<INTEGER> { v1 = Integer.parseInt(t1.image); } \r
- (\r
- "]" { return new AstArrayType(componentType, v1, v1); } \r
- | ".." \r
- (\r
- "]" { return new AstArrayType(componentType, v1, null); }\r
- | t2=<INTEGER> "]" {\r
- return new AstArrayType(componentType, v1, Integer.parseInt(t2.image)); \r
- }\r
- ) \r
- ) \r
-}\r
-\r
-AstType basicType() : { \r
- AstType type;\r
- boolean referable = false;\r
-} { \r
- "(" type = tupleType() ")" { return type; }\r
- | ("referable" {referable=true;})? \r
- "{" type = recordType(referable) "}" { return type; }\r
- | type = typeReference() { return type; }\r
-}\r
-\r
-AstType typeReference() : {\r
- Token name;\r
- List<AstType> parameters = Collections.emptyList();\r
- List<AstAttribute> attributes = Collections.emptyList();\r
-} {\r
- name=<IDENT> \r
- ("("\r
- { parameters = new ArrayList<AstType>(2);\r
- attributes = new ArrayList<AstAttribute>(2); \r
- } \r
- parameter(parameters, attributes)\r
- ("," parameter(parameters, attributes))*\r
- ")")?\r
- { \r
- return new AstTypeReference(name.image, parameters, attributes); \r
- }\r
-}\r
-\r
-private void parameter(List<AstType> parameters, List<AstAttribute> attributes) : {\r
- Token key;\r
- String value;\r
- AstType type;\r
-} {\r
- LOOKAHEAD(<IDENT> "=")\r
- key=<IDENT> "=" value=attributeValue() { attributes.add(new AstAttribute(key.image, value)); } \r
- | type=type() { parameters.add(type); }\r
-}\r
-\r
-String numericValue() : {}\r
-{ (<INTEGER> | <FLOAT>)\r
- { return token.image; }\r
-| "-" (<INTEGER> | <FLOAT>)\r
- { return "-" + token.image; }\r
-}\r
-\r
-String range() : {\r
- Token open, close;\r
- String first = "", second = "";\r
-} {\r
- ( "[" | "(" ) { open = token; }\r
- ( first = numericValue() )?\r
- ".."\r
- ( second = numericValue() )?\r
- ( "]" | ")" ) { close = token; }\r
- { return open.image + first + ".." + second + close.image; } \r
-}\r
-\r
-String attributeValue() : {\r
- String str;\r
-} {\r
- ( <STRING> \r
- | "true"\r
- | "false" \r
- ) { return token.image; }\r
-| str=numericValue() { return str; }\r
-| str=range() { return str; }\r
-}\r
-\r
-AstType tupleType() : { \r
- AstType type;\r
- ArrayList<AstType> types; \r
-} { \r
- type = type() \r
- { types = new ArrayList<AstType>(3); types.add(type); }\r
- ( "," type = type() { types.add(type); } )* \r
- { \r
- if(types.size()==1)\r
- return types.get(0);\r
- else\r
- return new AstTupleType(types);\r
- }\r
- | { return new AstTupleType(Collections.<AstType>emptyList()); } \r
-}\r
-\r
-AstType recordType(boolean referable) : {\r
- AstComponent component;\r
- ArrayList<AstComponent> components; \r
-} { \r
- component = component() \r
- { components = new ArrayList<AstComponent>(3); components.add(component); }\r
- ( "," component = component() { components.add(component); } )*\r
- { return new AstRecordType(referable, components); }\r
- | { return new AstRecordType(referable, Collections.<AstComponent>emptyList()); }\r
-}\r
-\r
-AstComponent component() : {\r
- Token field;\r
- AstType type;\r
-} {\r
- (field=<IDENT> | field="type" | field="referable") ":" type=type() \r
- { return new AstComponent(field.image, type); }\r
-}\r
- \r
-/*** Value parser **************************************************/\r
-\r
-List<AstValueDefinition> valueDefinitions() : {\r
- AstValueDefinition def;\r
- List<AstValueDefinition> result = new ArrayList<AstValueDefinition>();\r
-} {\r
- ( def=valueDefinition() { result.add(def); } )* <EOF>\r
- { return result; }\r
-}\r
-\r
-AstValueDefinition valueDefinition() : {\r
- Token name;\r
- AstValue value;\r
- AstType type;\r
-} {\r
- name=<IDENT> ":" type=type() "=" value=value() \r
- { return new AstValueDefinition(name.image, type, value); }\r
-}\r
-\r
-AstValue value() : {\r
- AstValue value;\r
- AstType type;\r
-} {\r
- value = basicValue()\r
- ( ":" type = type()\r
- { value = new AstVariant(value, type); } \r
- )*\r
- { return value; }\r
-}\r
-\r
-AstValue basicValue() : {\r
- Token tag;\r
- AstValue temp;\r
-} {\r
- "null" { return AstNull.NULL; }\r
- | <STRING> { return new AstString(token.image); }\r
- | <LONG_STRING> { return new AstString(token.image); }\r
- | <INTEGER> { return new AstInteger(token.image); }\r
- | <FLOAT> { return new AstFloat(token.image); }\r
- | "true" { return AstBoolean.TRUE; }\r
- | "false" { return AstBoolean.FALSE; }\r
- | "map" "{" temp=map() "}" { return temp; }\r
- | "[" temp=array() "]" { return temp; }\r
- | "{" temp=record() "}" { return temp; }\r
- | "(" temp=tuple() ")" { return temp; }\r
- | tag=<IDENT> \r
- ( temp=basicValue() { return new AstTaggedValue(tag.image, temp); }\r
- | { return new AstReference(tag.image); } \r
- ) \r
-}\r
-\r
-AstArray array() : {\r
- ArrayList<AstValue> components;\r
- AstValue value;\r
-} {\r
- { components = new ArrayList<AstValue>(); }\r
- value=value() { components.add(value); }\r
- ("," value=value() { components.add(value); })*\r
- { return new AstArray(components); }\r
- | { return AstArray.EMPTY; } \r
-}\r
-\r
-AstValue tuple() : {\r
- ArrayList<AstValue> components;\r
- AstValue value;\r
-} {\r
- { components = new ArrayList<AstValue>(); }\r
- value=value() { components.add(value); }\r
- ("," value=value() { components.add(value); })*\r
- { \r
- if(components.size() == 1)\r
- return components.get(0);\r
- else\r
- return new AstTuple(components); \r
- }\r
- | { return AstTuple.EMPTY; } \r
-}\r
-\r
-AstRecord record() : {\r
- ArrayList<AstComponentAssignment> components;\r
- AstComponentAssignment assignment;\r
-} {\r
- { components = new ArrayList<AstComponentAssignment>(); }\r
- assignment=assignment() { components.add(assignment); }\r
- ("," assignment=assignment() { components.add(assignment); })*\r
- { return new AstRecord(components); }\r
- | { return AstRecord.EMPTY; } \r
-}\r
-\r
-AstMap map() : {\r
- ArrayList<AstMapAssignment> components;\r
- AstMapAssignment assignment;\r
-} {\r
- { components = new ArrayList<AstMapAssignment>(); }\r
- assignment=mapAssignment() { components.add(assignment); }\r
- ("," assignment=mapAssignment() { components.add(assignment); })*\r
- { return new AstMap(components); }\r
- | { return AstMap.EMPTY; } \r
-}\r
-\r
-AstComponentAssignment assignment() : {\r
- Token name;\r
- AstValue value;\r
-} {\r
- name=<IDENT> "=" value=value() \r
- { return new AstComponentAssignment(name.image, value); }\r
-}\r
-\r
-AstMapAssignment mapAssignment() : {\r
- AstValue key;\r
- AstValue value;\r
-} {\r
- key=value() "=" value=value() \r
- { return new AstMapAssignment(key, value); }\r
+options {
+ JDK_VERSION = "1.6";
+ STATIC = false;
+ IGNORE_CASE = false;
+}
+
+PARSER_BEGIN(DataParser)
+package org.simantics.databoard.parser;
+
+import org.simantics.databoard.parser.ast.type.*;
+import org.simantics.databoard.parser.ast.value.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Collections;
+
+/**
+ * Parser for data type definitions.
+ * @author Hannu Niemist�
+ */
+public class DataParser {
+}
+PARSER_END(DataParser)
+
+/*** Lexer *********************************************************/
+
+SKIP:
+{ <WHITESPACE: " " | "\n" | "\r" | "\t" >
+| <COMMENT1: "/*" (~["*"] | "*" ~["/"])* "*/" >
+| <COMMENT2: "//" (~["\n"])* >
+}
+
+TOKEN:
+{ ";" | "(" | ")" | "?" | "[" | "]"
+| "{" | "}" | "|" | "&" | ":"
+| "," | ".." | "." | "=" | "<" | ">"
+| "type" | "true" | "false" | "null" | "map" | "referable"
+| <STRING: "\"" (~["\"", "\\", "\n"] | "\\" ~["\n"])* "\"">
+ { matchedToken.image = StringEscapeUtils.unescape(
+ matchedToken.image.substring(1,matchedToken.image.length()-1)); }
+| <LONG_STRING: "\"\"\"" (~["\""] | "\"" ~["\""] | "\"\"" ~["\""])* "\"\"\"">
+ { matchedToken.image = matchedToken.image.substring(3,matchedToken.image.length()-3); }
+| <#POSITIVE_INTEGER: (["0"-"9"])+ >
+| <INTEGER: ("-"|"+")? <POSITIVE_INTEGER> >
+| <FLOAT:
+ ("-")?
+ ( <POSITIVE_INTEGER> "." <POSITIVE_INTEGER> (["e","E"] <INTEGER>)?
+ | "." <POSITIVE_INTEGER> (["e","E"] <INTEGER>)?
+ | <POSITIVE_INTEGER> ["e","E"] <INTEGER>
+ | "NaN"
+ | "Infinity"
+ ) >
+| <IDENT: ["a"-"z","A"-"Z","_"] (["a"-"z","A"-"Z","_","0"-"9"])* >
+| <URI: "<" (~["<",">"])* ">">
+ { matchedToken.image = matchedToken.image.substring(1,matchedToken.image.length()-1); }
+}
+
+/*** Type parser ***************************************************/
+
+List<AstTypeDefinition> typeDefinitions() : {
+ AstTypeDefinition def;
+ List<AstTypeDefinition> result = new ArrayList<AstTypeDefinition>();
+} {
+ ( def=typeDefinition() { result.add(def); } )* <EOF>
+ { return result; }
+}
+
+AstTypeDefinition typeDefinition() : {
+ Token name;
+ AstType type;
+} {
+ "type" name=<IDENT> "=" type=type()
+ { return new AstTypeDefinition(name.image, type); }
+}
+
+AstType type() : {
+ AstType type;
+} {
+ type=simpleType()
+ { return type; }
+ | type=unionType()
+ { return type; }
+}
+
+AstType unionType() : {
+ List<AstComponent> components = new ArrayList<AstComponent>(4);
+} {
+ ( "|" unionComponent(components) )+
+ { return new AstUnionType(components); }
+}
+
+private void unionComponent(List<AstComponent> components) : {
+ Token tag;
+ AstType type;
+} {
+ tag=<IDENT>
+ (
+ type=simpleType() { components.add(new AstComponent(tag.image, type)); }
+ | { components.add(new AstComponent(tag.image, AstRecordType.EMPTY_RECORD)); }
+ )
+}
+
+AstType simpleType() : {
+ AstType type;
+} {
+ type=basicType()
+ ( "[" type=arraySuffix(type) )*
+ { return type; }
+}
+
+private AstType arraySuffix(AstType componentType) : {
+ Token t1, t2;
+ Integer v1;
+} {
+ "]" {
+ return new AstArrayType(componentType, null, null);
+ }
+ | ".." t1=<INTEGER> "]" {
+ v1 = Integer.parseInt(t1.image);
+ return new AstArrayType(componentType, null, v1);
+ }
+ | t1=<INTEGER> { v1 = Integer.parseInt(t1.image); }
+ (
+ "]" { return new AstArrayType(componentType, v1, v1); }
+ | ".."
+ (
+ "]" { return new AstArrayType(componentType, v1, null); }
+ | t2=<INTEGER> "]" {
+ return new AstArrayType(componentType, v1, Integer.parseInt(t2.image));
+ }
+ )
+ )
+}
+
+AstType basicType() : {
+ AstType type;
+ boolean referable = false;
+} {
+ "(" type = tupleType() ")" { return type; }
+ | ("referable" {referable=true;})?
+ "{" type = recordType(referable) "}" { return type; }
+ | type = typeReference() { return type; }
+}
+
+AstType typeReference() : {
+ Token name;
+ List<AstType> parameters = Collections.emptyList();
+ List<AstAttribute> attributes = Collections.emptyList();
+} {
+ name=<IDENT>
+ ("("
+ { parameters = new ArrayList<AstType>(2);
+ attributes = new ArrayList<AstAttribute>(2);
+ }
+ parameter(parameters, attributes)
+ ("," parameter(parameters, attributes))*
+ ")")?
+ {
+ return new AstTypeReference(name.image, parameters, attributes);
+ }
+}
+
+private void parameter(List<AstType> parameters, List<AstAttribute> attributes) : {
+ Token key;
+ String value;
+ AstType type;
+} {
+ LOOKAHEAD(<IDENT> "=")
+ key=<IDENT> "=" value=attributeValue() { attributes.add(new AstAttribute(key.image, value)); }
+ | type=type() { parameters.add(type); }
+}
+
+String numericValue() : {}
+{ (<INTEGER> | <FLOAT>)
+ { return token.image; }
+| "-" (<INTEGER> | <FLOAT>)
+ { return "-" + token.image; }
+}
+
+String range() : {
+ Token open, close;
+ String first = "", second = "";
+} {
+ ( "[" | "(" ) { open = token; }
+ ( first = numericValue() )?
+ ".."
+ ( second = numericValue() )?
+ ( "]" | ")" ) { close = token; }
+ { return open.image + first + ".." + second + close.image; }
+}
+
+String attributeValue() : {
+ String str;
+} {
+ ( <STRING>
+ | "true"
+ | "false"
+ ) { return token.image; }
+| str=numericValue() { return str; }
+| str=range() { return str; }
+}
+
+AstType tupleType() : {
+ AstType type;
+ ArrayList<AstType> types;
+} {
+ type = type()
+ { types = new ArrayList<AstType>(3); types.add(type); }
+ ( "," type = type() { types.add(type); } )*
+ {
+ if(types.size()==1)
+ return types.get(0);
+ else
+ return new AstTupleType(types);
+ }
+ | { return new AstTupleType(Collections.<AstType>emptyList()); }
+}
+
+AstType recordType(boolean referable) : {
+ AstComponent component;
+ ArrayList<AstComponent> components;
+} {
+ component = component()
+ { components = new ArrayList<AstComponent>(3); components.add(component); }
+ ( "," component = component() { components.add(component); } )*
+ { return new AstRecordType(referable, components); }
+ | { return new AstRecordType(referable, Collections.<AstComponent>emptyList()); }
+}
+
+AstComponent component() : {
+ Token field;
+ AstType type;
+} {
+ (field=<IDENT> | field="type" | field="referable") ":" type=type()
+ { return new AstComponent(field.image, type); }
+}
+
+/*** Value parser **************************************************/
+
+List<AstValueDefinition> valueDefinitions() : {
+ AstValueDefinition def;
+ List<AstValueDefinition> result = new ArrayList<AstValueDefinition>();
+} {
+ ( def=valueDefinition() { result.add(def); } )* <EOF>
+ { return result; }
+}
+
+AstValueDefinition valueDefinition() : {
+ Token name;
+ AstValue value;
+ AstType type;
+} {
+ name=<IDENT> ":" type=type() "=" value=value()
+ { return new AstValueDefinition(name.image, type, value); }
+}
+
+AstValue value() : {
+ AstValue value;
+ AstType type;
+} {
+ value = basicValue()
+ ( ":" type = type()
+ { value = new AstVariant(value, type); }
+ )*
+ { return value; }
+}
+
+AstValue basicValue() : {
+ Token tag;
+ AstValue temp;
+} {
+ "null" { return AstNull.NULL; }
+ | <STRING> { return new AstString(token.image); }
+ | <LONG_STRING> { return new AstString(token.image); }
+ | <INTEGER> { return new AstInteger(token.image); }
+ | <FLOAT> { return new AstFloat(token.image); }
+ | "true" { return AstBoolean.TRUE; }
+ | "false" { return AstBoolean.FALSE; }
+ | "map" "{" temp=map() "}" { return temp; }
+ | "[" temp=array() "]" { return temp; }
+ | "{" temp=record() "}" { return temp; }
+ | "(" temp=tuple() ")" { return temp; }
+ | tag=<IDENT>
+ ( temp=basicValue() { return new AstTaggedValue(tag.image, temp); }
+ | { return new AstReference(tag.image); }
+ )
+}
+
+AstArray array() : {
+ ArrayList<AstValue> components;
+ AstValue value;
+} {
+ { components = new ArrayList<AstValue>(); }
+ value=value() { components.add(value); }
+ ("," value=value() { components.add(value); })*
+ { return new AstArray(components); }
+ | { return AstArray.EMPTY; }
+}
+
+AstValue tuple() : {
+ ArrayList<AstValue> components;
+ AstValue value;
+} {
+ { components = new ArrayList<AstValue>(); }
+ value=value() { components.add(value); }
+ ("," value=value() { components.add(value); })*
+ {
+ if(components.size() == 1)
+ return components.get(0);
+ else
+ return new AstTuple(components);
+ }
+ | { return AstTuple.EMPTY; }
+}
+
+AstRecord record() : {
+ ArrayList<AstComponentAssignment> components;
+ AstComponentAssignment assignment;
+} {
+ { components = new ArrayList<AstComponentAssignment>(); }
+ assignment=assignment() { components.add(assignment); }
+ ("," assignment=assignment() { components.add(assignment); })*
+ { return new AstRecord(components); }
+ | { return AstRecord.EMPTY; }
+}
+
+AstMap map() : {
+ ArrayList<AstMapAssignment> components;
+ AstMapAssignment assignment;
+} {
+ { components = new ArrayList<AstMapAssignment>(); }
+ assignment=mapAssignment() { components.add(assignment); }
+ ("," assignment=mapAssignment() { components.add(assignment); })*
+ { return new AstMap(components); }
+ | { return AstMap.EMPTY; }
+}
+
+AstComponentAssignment assignment() : {
+ Token name;
+ AstValue value;
+} {
+ name=<IDENT> "=" value=value()
+ { return new AstComponentAssignment(name.image, value); }
+}
+
+AstMapAssignment mapAssignment() : {
+ AstValue key;
+ AstValue value;
+} {
+ key=value() "=" value=value()
+ { return new AstMapAssignment(key, value); }
}
\ No newline at end of file
Code Review / simantics / platform.git / blobdiff