X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=bundles%2Forg.simantics.databoard%2Fsrc%2Forg%2Fsimantics%2Fdataboard%2Fparser%2FDataParser.jj;h=763699bae79d3cfb98bbae57fd948827da2e0ca4;hb=3f5adda763f6281e9988277d067c1f71615e3da2;hp=d49980f713b35129fb45c0381eef96d92861308c;hpb=969bd23cab98a79ca9101af33334000879fb60c5;p=simantics%2Fplatform.git

diff --git a/bundles/org.simantics.databoard/src/org/simantics/databoard/parser/DataParser.jj b/bundles/org.simantics.databoard/src/org/simantics/databoard/parser/DataParser.jj
index d49980f71..763699bae 100644
--- a/bundles/org.simantics.databoard/src/org/simantics/databoard/parser/DataParser.jj
+++ b/bundles/org.simantics.databoard/src/org/simantics/databoard/parser/DataParser.jj
@@ -1,351 +1,351 @@
-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); }
+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