bundles/org.simantics.graph.compiler/src/org/simantics/graph/compiler/internal/translation/GraphTranslator.java

   1 package org.simantics.graph.compiler.internal.translation;\r
   2 \r
   3 import gnu.trove.map.hash.TObjectIntHashMap;\r
   4 import gnu.trove.set.hash.TIntHashSet;\r
   5 \r
   6 import java.util.ArrayList;\r
   7 import java.util.Collection;\r
   8 \r
   9 import org.antlr.runtime.tree.Tree;\r
  10 import org.simantics.graph.compiler.SourceInfo.DefinitionPosition;\r
  11 import org.simantics.graph.compiler.internal.parsing.GraphParser;\r
  12 import org.simantics.graph.compiler.internal.store.LocationStore;\r
  13 import org.simantics.graph.compiler.internal.store.PreValueStore;\r
  14 import org.simantics.graph.compiler.internal.templates.TemplateDefinition;\r
  15 import org.simantics.graph.compiler.internal.templates.TemplateDefinitionStore;\r
  16 import org.simantics.graph.compiler.internal.templates.TemplateInstanceStore;\r
  17 import org.simantics.graph.compiler.internal.values.TreeValue;\r
  18 import org.simantics.graph.query.Paths;\r
  19 import org.simantics.graph.query.UriUtils;\r
  20 import org.simantics.graph.store.GraphStore;\r
  21 import org.simantics.ltk.ISource;\r
  22 import org.simantics.ltk.Problem;\r
  23 import org.simantics.ltk.antlr.ANTLRUtils;\r
  24 \r
  25 public class GraphTranslator extends GraphStore {\r
  26 \r
  27         ISource source;\r
  28         Collection<Problem> problems;\r
  29         \r
  30         TObjectIntHashMap<String> variables = new TObjectIntHashMap<String>();\r
  31         ArrayList<DefinitionPosition> definitionPositions = new ArrayList<DefinitionPosition>();\r
  32         TIntHashSet definedResources = new TIntHashSet();\r
  33         \r
  34         LocationStore locations;\r
  35         TemplateInstanceStore templateInstances;\r
  36         TemplateDefinitionStore templateDefinitions;\r
  37         PreValueStore preValues;\r
  38         \r
  39         Paths paths;\r
  40         int layer0;\r
  41         \r
  42         public GraphTranslator(Paths paths, Collection<Problem> problems, GraphStore store) {\r
  43                 super(store);           \r
  44                 this.problems = problems;\r
  45                 this.paths = paths;\r
  46                 \r
  47                 locations = getStore(LocationStore.class);\r
  48                 if(locations == null) {\r
  49                         locations = new LocationStore();\r
  50                         addStore(LocationStore.class, locations);\r
  51                 }\r
  52                 \r
  53                 templateInstances = getStore(TemplateInstanceStore.class);\r
  54                 if(templateInstances == null) {\r
  55                         templateInstances = new TemplateInstanceStore();\r
  56                         addStore(TemplateInstanceStore.class, templateInstances);\r
  57                 }\r
  58                 \r
  59                 templateDefinitions = getStore(TemplateDefinitionStore.class);\r
  60                 if(templateDefinitions == null) {\r
  61                         templateDefinitions = new TemplateDefinitionStore();\r
  62                         addStore(TemplateDefinitionStore.class, templateDefinitions);\r
  63                 }\r
  64                 \r
  65                 preValues = getStore(PreValueStore.class);\r
  66                 if(preValues == null) {\r
  67                         preValues = new PreValueStore();\r
  68                         addStore(PreValueStore.class, preValues);\r
  69                 }\r
  70                         \r
  71                 layer0 = identities.createPathToId(paths.Layer0);               \r
  72         }\r
  73         \r
  74         public void setSource(ISource source) {\r
  75                 this.source = source;\r
  76         }\r
  77         \r
  78         public void translateGraph(Tree tree) {         \r
  79                 int count = tree.getChildCount();\r
  80                 for(int i=0;i<count;++i)\r
  81                         translateResourceDefinition(tree.getChild(i));\r
  82         }\r
  83 \r
  84         protected void locate(int resource, Tree tree) {\r
  85                 locations.add(resource, ANTLRUtils.location(source, tree));\r
  86         }\r
  87         \r
  88         public int translateResourceDefinition(Tree tree) {\r
  89                 Tree subjectTree = tree.getChild(0);\r
  90                 int subject = translateResource(subjectTree);\r
  91                 \r
  92                 int count = tree.getChildCount();\r
  93                 for(int i=1;i<count;++i) {\r
  94                         Tree child = tree.getChild(i);\r
  95                         switch(child.getType()) {\r
  96                         case GraphParser.PROPERTY:\r
  97                                 translateProperty(subject, subjectTree, child);\r
  98                                 break;\r
  99                         case GraphParser.TEMPLATE_INSTANCE:\r
 100                                 translateTemplateInstance(subject, child);\r
 101                                 break;\r
 102                         case GraphParser.TEMPLATE_DEFINITION:\r
 103                                 translateTemplateDefinition(subject, child);\r
 104                                 break;\r
 105                         }\r
 106                 }\r
 107                 return subject;\r
 108         }\r
 109 \r
 110         private void translateProperty(int subject, Tree subjectTree, Tree tree) {\r
 111                 int predicate = translateResource(tree.getChild(0));\r
 112                 if(predicate == instanceOfId || predicate == inheritsId || predicate == subrelationOfId)\r
 113                         if(definedResources.add(subject)) {                             \r
 114                         definitionPositions.add(new DefinitionPosition(subject,\r
 115                                         ANTLRUtils.getStartLine(subjectTree) + source.startLine(),\r
 116                                         ANTLRUtils.getStartIndex(subjectTree) + source.startPos(),\r
 117                                         ANTLRUtils.getStopIndex(subjectTree) + source.startPos()\r
 118                         ));\r
 119                         }\r
 120                 int count = tree.getChildCount();\r
 121                 for(int i=1;i<count;++i) {\r
 122                         int object = translateResourceDefinition(tree.getChild(i));\r
 123                         statements.add(subject, predicate, object);\r
 124                 }\r
 125         }       \r
 126          \r
 127         private void translateTemplateInstance(int subject, Tree tree) {\r
 128                 int parameterCount = tree.getChildCount();\r
 129                 int[] templateInstance = new int[parameterCount+1];\r
 130                 templateInstance[0] = translateResource(tree.getChild(0));\r
 131                 templateInstance[1] = subject;\r
 132                 for(int i=1;i<parameterCount;++i) {\r
 133                         Tree child = tree.getChild(i);\r
 134                         if(child.getType() == GraphParser.RESOURCE)\r
 135                                 templateInstance[i+1] = translateResourceDefinition(child);\r
 136                         else\r
 137                                 templateInstance[i+1] = translateResource(child);\r
 138                 }\r
 139                 templateInstances.add(templateInstance);\r
 140         }       \r
 141         \r
 142         private void translateTemplateDefinition(int subject, Tree tree) {\r
 143                 ArrayList<String> parameters = new ArrayList<String>(); \r
 144 \r
 145                 int i=0;\r
 146                 while(i < tree.getChildCount() && \r
 147                                 tree.getChild(i).getType() == GraphParser.VARIABLE) {\r
 148                         parameters.add(tree.getChild(i).getChild(0).getText());\r
 149                         ++i;\r
 150                 }\r
 151 \r
 152                 GraphStore store = new GraphStore();\r
 153                 ChildGraphTranslator translator = new ChildGraphTranslator(this, store);\r
 154                 translator.setSource(source);\r
 155                 while(i < tree.getChildCount()) {\r
 156                         translator.translateResourceDefinition(tree.getChild(i));\r
 157                         ++i;\r
 158                 }       \r
 159                 \r
 160                 templateDefinitions.add(subject, \r
 161                                 new TemplateDefinition(parameters.toArray(new String[parameters.size()]), \r
 162                                                 translator.correspondences.toArray(), \r
 163                                                 store));\r
 164         }\r
 165 \r
 166         public static void printTree(Tree tree) {\r
 167                 printTree(0, tree);\r
 168         }\r
 169         \r
 170         int equalsId = 0;\r
 171         int inheritsId = 0;\r
 172         int subrelationOfId = 0;\r
 173         int instanceOfId = 0;\r
 174         int hasDomainId = 0;\r
 175         int hasRangeId = 0;\r
 176         int domainOfId = 0;\r
 177         int requiresValueTypeId = 0;\r
 178         int DatatypeId = 0;\r
 179         \r
 180         private int translateResource(Tree tree) {\r
 181                 switch(tree.getType()) {\r
 182                 case GraphParser.EMBEDDED_VALUE: {\r
 183                         int id = identities.newResource();\r
 184                         preValues.setValue(id, new TreeValue(source, tree.getChild(0)));\r
 185                         locate(id, tree.getChild(0));\r
 186                         return id;\r
 187                 }\r
 188                 case GraphParser.EMBEDDED_TYPE: {\r
 189                         int DataType = identities.newResource();\r
 190                         values.setValue(DataType, new DataTypeTranslator(source, problems).translate(tree.getChild(0)));\r
 191                         if(instanceOfId == 0)\r
 192                                 instanceOfId = identities.getChild(layer0, "InstanceOf");\r
 193                         if(DatatypeId == 0)\r
 194                                 DatatypeId = identities.getChild(layer0, "DataType");\r
 195                         statements.add(DataType, instanceOfId, DatatypeId);\r
 196                         locate(DataType, tree.getChild(0));\r
 197                         return DataType;\r
 198                 }\r
 199                 case GraphParser.BLANK: {\r
 200                         int id = identities.newResource();\r
 201                         locate(id, tree);\r
 202                         return id;\r
 203                 }\r
 204                 case GraphParser.ID:\r
 205                         return getVariable(tree, tree.getText());\r
 206                 case GraphParser.VARIABLE: {\r
 207                         int id = identities.getRoot(tree.getChild(0).getText());\r
 208                         locate(id, tree);\r
 209                         return id;\r
 210                 }\r
 211                 case GraphParser.URI: {\r
 212                         String uri = tree.getText();\r
 213                         uri = uri.substring(1, uri.length()-1);\r
 214                         int id = identities.createPathToId(UriUtils.uriToPath(uri));\r
 215                         locate(id, tree);\r
 216                         return id;\r
 217                 }\r
 218                 case GraphParser.REF: {\r
 219                         int parent = translateResource(tree.getChild(0));\r
 220                         Tree nameNode = tree.getChild(1);\r
 221                         String name = nameNode.getText();\r
 222                         if(nameNode.getType() == GraphParser.STRING) {\r
 223                                 name = name.substring(1, name.length()-1);\r
 224                         }\r
 225                         int id = identities.getChild(parent, name);\r
 226                         locate(id, tree);\r
 227                         return id;\r
 228                 }\r
 229                 case GraphParser.EQUALS:\r
 230                         if(equalsId == 0)\r
 231                                 equalsId = identities.getChild(layer0, "Equals");\r
 232                         return equalsId;\r
 233                 case GraphParser.INHERITS:\r
 234                         if(inheritsId == 0)\r
 235                                 inheritsId = identities.getChild(layer0, "Inherits");\r
 236                         return inheritsId;\r
 237                 case GraphParser.SUBRELATION_OF:\r
 238                         if(subrelationOfId == 0)\r
 239                                 subrelationOfId = identities.getChild(layer0, "SubrelationOf");\r
 240                         return subrelationOfId;\r
 241                 case GraphParser.INSTANCE_OF:\r
 242                         if(instanceOfId == 0)\r
 243                                 instanceOfId = identities.getChild(layer0, "InstanceOf");\r
 244                         return instanceOfId;            \r
 245                 case GraphParser.HAS_DOMAIN:\r
 246             if(hasDomainId == 0)\r
 247                 hasDomainId = identities.getChild(layer0, "HasDomain");\r
 248             return hasDomainId;                 \r
 249                 case GraphParser.HAS_RANGE:\r
 250             if(hasRangeId == 0)\r
 251                 hasRangeId = identities.getChild(layer0, "HasRange");\r
 252             return hasRangeId;\r
 253                 case GraphParser.DOMAIN_OF:\r
 254             if(domainOfId == 0)\r
 255                 domainOfId = identities.getChild(layer0, "DomainOf");\r
 256             return domainOfId;     \r
 257         case GraphParser.REQUIRES_VALUE_TYPE:\r
 258             if(requiresValueTypeId == 0)\r
 259                 requiresValueTypeId = identities.getChild(layer0, "RequiresValueType");\r
 260             return requiresValueTypeId;            \r
 261                 default: \r
 262                         // TODO\r
 263                         System.out.println("-- " + GraphParser.tokenNames[tree.getType()]);\r
 264                         printTree(tree);\r
 265                         return 0;\r
 266                 }               \r
 267         }\r
 268 \r
 269         public int getVariable(Tree place, String text) {\r
 270                 if(variables.containsKey(text))\r
 271                         return variables.get(text);\r
 272                 else {\r
 273                         int id = identities.newResource();\r
 274                         variables.put(text, id);\r
 275                         locate(id, place);\r
 276                         return id;\r
 277                 }\r
 278         }\r
 279         \r
 280         public TObjectIntHashMap<String> getVariables() {\r
 281                 return variables;\r
 282         }\r
 283         \r
 284         public ArrayList<DefinitionPosition> getDefinitionPositions() {\r
 285                 return definitionPositions;\r
 286         }\r
 287 \r
 288         public static void printTree(int indent, Tree tree) {\r
 289                 for(int i=0;i<indent;++i)\r
 290                         System.out.print("  ");\r
 291                 System.out.println(tree.getText());\r
 292                 for(int i=0;i<tree.getChildCount();++i)\r
 293                         printTree(indent+1, tree.getChild(i));\r
 294         }       \r
 295 }\r