bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/module/ConcreteModule.java

   1 package org.simantics.scl.compiler.module;
   2
   3 import java.util.ArrayList;
   4 import java.util.Collection;
   5 import java.util.Collections;
   6 import java.util.List;
   7 import java.util.Map;
   8 import java.util.function.Consumer;
   9
  10 import org.simantics.scl.compiler.common.names.Name;
  11 import org.simantics.scl.compiler.constants.Constant;
  12 import org.simantics.scl.compiler.elaboration.chr.CHRRuleset;
  13 import org.simantics.scl.compiler.elaboration.modules.Documentation;
  14 import org.simantics.scl.compiler.elaboration.modules.SCLValue;
  15 import org.simantics.scl.compiler.elaboration.modules.TypeClass;
  16 import org.simantics.scl.compiler.elaboration.modules.TypeClassInstance;
  17 import org.simantics.scl.compiler.elaboration.modules.TypeDescriptor;
  18 import org.simantics.scl.compiler.elaboration.relations.SCLEntityType;
  19 import org.simantics.scl.compiler.elaboration.relations.SCLRelation;
  20 import org.simantics.scl.compiler.elaboration.rules.MappingRelation;
  21 import org.simantics.scl.compiler.elaboration.rules.TransformationRule;
  22 import org.simantics.scl.compiler.environment.filter.NamespaceFilter;
  23 import org.simantics.scl.compiler.errors.CompilationError;
  24 import org.simantics.scl.compiler.internal.codegen.effects.EffectConstructor;
  25 import org.simantics.scl.compiler.module.debug.ModuleDebugInfo;
  26 import org.simantics.scl.compiler.top.ModuleInitializer;
  27 import org.simantics.scl.compiler.types.TCon;
  28 import org.simantics.scl.runtime.profiling.BranchPoint;
  29
  30 import gnu.trove.map.hash.THashMap;
  31 import gnu.trove.procedure.TObjectObjectProcedure;
  32 import gnu.trove.procedure.TObjectProcedure;
  33
  34 public class ConcreteModule implements Module {
  35     String moduleName;
  36     String defaultLocalName;
  37     String deprecation;
  38     THashMap<String, TypeDescriptor> typeDescriptors = new THashMap<String, TypeDescriptor>();
  39     THashMap<String, EffectConstructor> effectConstructors = new THashMap<String, EffectConstructor>();
  40     THashMap<String, TypeClass> typeClasses = new THashMap<String, TypeClass>();
  41     THashMap<TCon, ArrayList<TypeClassInstance>> typeClassInstances = new THashMap<TCon, ArrayList<TypeClassInstance>>();
  42     THashMap<String, SCLValue> values = new THashMap<String, SCLValue>();
  43     THashMap<String, List<Constant>> fieldAccessors = new THashMap<String, List<Constant>>();
  44     THashMap<String, SCLRelation> relations = new THashMap<String, SCLRelation>(2);
  45     THashMap<String, SCLEntityType> entityTypes = new THashMap<String, SCLEntityType>(2);
  46     THashMap<String, TransformationRule> rules = new THashMap<String, TransformationRule>(2);
  47     THashMap<String, MappingRelation> mappingRelations = new THashMap<String, MappingRelation>(2);
  48     THashMap<String, CHRRuleset> rulesets = new THashMap<String, CHRRuleset>(2);
  49     ArrayList<ImportDeclaration> dependencies = new ArrayList<ImportDeclaration>();
  50     THashMap<String, BranchPoint[]> branchPoints;
  51     CompilationError[] warnings = CompilationError.EMPTY_ARRAY;
  52
  53     Map<String, byte[]> classes = Collections.emptyMap();
  54     ClassLoader parentClassLoader;
  55     ModuleInitializer moduleInitializer;
  56
  57     protected Documentation documentation;
  58
  59     public ModuleDebugInfo moduleDebugInfo;
  60
  61     public ConcreteModule(String moduleName) {
  62         this.moduleName = moduleName;
  63     }
  64
  65     @Override
  66     public String getDefaultLocalName() {
  67         return defaultLocalName;
  68     }
  69
  70     public void setDefaultLocalName(String defaultLocalName) {
  71                 this.defaultLocalName = defaultLocalName;
  72         }
  73
  74     public boolean addTypeDescriptor(String name, TypeDescriptor typeConstructor) {
  75         return typeDescriptors.put(name, typeConstructor) != null;
  76     }
  77
  78     public boolean addEffectConstructor(String name, EffectConstructor effectConstructor) {
  79         return effectConstructors.put(name, effectConstructor) != null;
  80     }
  81
  82     public boolean addTypeClass(String name, TypeClass typeClass) {
  83         return typeClasses.put(name, typeClass) != null;
  84     }
  85
  86     public void addTypeClassInstance(TCon typeClass, TypeClassInstance typeClassInstance) {
  87         ArrayList<TypeClassInstance> instances = typeClassInstances.get(typeClass);
  88         if(instances == null) {
  89             instances = new ArrayList<TypeClassInstance>();
  90             typeClassInstances.put(typeClass, instances);
  91         }
  92         instances.add(typeClassInstance);
  93     }
  94
  95     public boolean addRule(TransformationRule rule) {
  96         return rules.put(rule.name.name, rule) != null;
  97     }
  98
  99     public boolean addMappingRelation(MappingRelation relation) {
 100         return mappingRelations.put(relation.name.name, relation) != null;
 101     }
 102
 103     public Collection<TCon> getTypeClassesWithInstances() {
 104         return typeClassInstances.keySet();
 105     }
 106
 107     public boolean addValue(SCLValue value) {
 108         return values.put(value.getName().name, value) != null;
 109     }
 110
 111     public SCLValue addValue(String name, Constant constant) {
 112         SCLValue value = new SCLValue(Name.create(moduleName, name), constant);
 113         addValue(value);
 114         return value;
 115     }
 116
 117     @Override
 118     public List<Constant> getFieldAccessors(String name) {
 119         return fieldAccessors.get(name);
 120     }
 121
 122     public void addRelation(String name, SCLRelation relation) {
 123         relations.put(name, relation);
 124     }
 125
 126     public void addEntityType(String name, SCLEntityType entityType) {
 127         entityTypes.put(name, entityType);
 128     }
 129
 130     public void addDependency(ImportDeclaration module) {
 131         if(!dependencies.contains(module))
 132             dependencies.add(module);
 133     }
 134
 135     public Collection<SCLValue> getValues() {
 136         return values.values();
 137     }
 138
 139     public Collection<TransformationRule> getRules() {
 140         return rules.values();
 141     }
 142
 143     public Collection<MappingRelation> getMappingRelations() {
 144         return mappingRelations.values();
 145     }
 146
 147     @Override
 148     public String getName() {
 149         return moduleName;
 150     }
 151
 152     @Override
 153     public SCLValue getValue(String name) {
 154         return values.get(name);
 155     }
 156
 157     @Override
 158     public SCLRelation getRelation(String name) {
 159         return relations.get(name);
 160     }
 161
 162     @Override
 163     public MappingRelation getMappingRelation(String name) {
 164         return mappingRelations.get(name);
 165     }
 166
 167     @Override
 168     public TransformationRule getRule(String name) {
 169         return rules.get(name);
 170     }
 171
 172     @Override
 173     public SCLEntityType getEntityType(String name) {
 174         return entityTypes.get(name);
 175     }
 176
 177     public TypeClass getTypeClass(String name) {
 178         return typeClasses.get(name);
 179     }
 180
 181     @Override
 182     public Collection<TypeClassInstance> getInstances(TCon typeClass) {
 183         Collection<TypeClassInstance> result = typeClassInstances.get(typeClass);
 184         if(result == null)
 185             return Collections.emptyList();
 186         else
 187             return result;
 188     }
 189
 190     @Override
 191     public TypeDescriptor getTypeDescriptor(String name) {
 192         return typeDescriptors.get(name);
 193     }
 194
 195     @Override
 196     public EffectConstructor getEffectConstructor(String name) {
 197         return effectConstructors.get(name);
 198     }
 199
 200     @Override
 201     public CHRRuleset getRuleset(String name) {
 202         return rulesets.get(name);
 203     }
 204
 205     public Collection<TypeClass> getTypeClasses() {
 206         return typeClasses.values();
 207     }
 208
 209     public THashMap<TCon, ArrayList<TypeClassInstance>> getTypeInstances() {
 210         return typeClassInstances;
 211     }
 212
 213     @Override
 214     public List<ImportDeclaration> getDependencies() {
 215         return dependencies;
 216     }
 217
 218     public void setDocumentation(Documentation documentation) {
 219         this.documentation = documentation;
 220     }
 221
 222     public Documentation getDocumentation() {
 223         return documentation;
 224     }
 225
 226     public void setClasses(Map<String, byte[]> classes) {
 227         this.classes = classes;
 228     }
 229
 230     @Override
 231     public byte[] getClass(String name) {
 232         return classes.get(name);
 233     }
 234
 235     public void setModuleInitializer(ModuleInitializer moduleInitializer) {
 236         this.moduleInitializer = moduleInitializer;
 237     }
 238
 239     @Override
 240     public ModuleInitializer getModuleInitializer() {
 241         return moduleInitializer;
 242     }
 243
 244     @Override
 245     public String toString() {
 246         return moduleName;
 247     }
 248
 249     @Override
 250     public void findValuesForPrefix(final String prefix, final NamespaceFilter filter,
 251             final TObjectProcedure<SCLValue> proc) {
 252         this.values.forEachEntry(new TObjectObjectProcedure<String,SCLValue>() {
 253             @Override
 254             public boolean execute(String name, SCLValue value) {
 255                 if(value.isPrivateOrDerived())
 256                     return true;
 257                 String lowerPrefix = prefix.toLowerCase();
 258                 String lowerName = name.toLowerCase();
 259                 if(lowerName.startsWith(lowerPrefix) && filter.isValueIncluded(name))
 260                     proc.execute(value);
 261                 return true;
 262             }
 263         });
 264     }
 265
 266     @Override
 267     public void findValuesForPrefix(String prefix, NamespaceFilter filter, Consumer<SCLValue> consumer) {
 268         values.values().forEach((Consumer<SCLValue>) (value) -> {
 269             String lowerPrefix = prefix.toLowerCase();
 270             String lowerName = value.getName().name.toLowerCase();
 271             if(lowerName.startsWith(lowerPrefix) && filter.isValueIncluded(value.getName().name))
 272                 consumer.accept(value);
 273         });
 274     }
 275
 276     @Override
 277     public List<String> getValueNames() {
 278         return new ArrayList<String>(values.keySet());
 279     }
 280
 281     public Collection<SCLRelation> getRelations() {
 282         return relations.values();
 283     }
 284
 285     @Override
 286     public void findTypesForPrefix(String prefix, NamespaceFilter filter, Consumer<TCon> consumer) {
 287         typeDescriptors.values().forEach(type -> {
 288             TCon tcon = type.name;
 289             if (tcon.name.toLowerCase().startsWith(prefix.toLowerCase()) && filter.isValueIncluded(tcon.name))
 290                 consumer.accept(tcon);
 291         });
 292     }
 293
 294     public void setBranchPoints(THashMap<String, BranchPoint[]> branchPoints) {
 295         this.branchPoints = branchPoints;
 296     }
 297
 298     @Override
 299     public THashMap<String, BranchPoint[]> getBranchPoints() {
 300         return branchPoints;
 301     }
 302
 303     @Override
 304     public void dispose() {
 305     }
 306
 307     public void setWarnings(CompilationError[] warnings) {
 308         this.warnings = warnings;
 309     }
 310
 311     public CompilationError[] getWarnings() {
 312         return warnings;
 313     }
 314
 315     @Override
 316     public ClassLoader getParentClassLoader() {
 317         return parentClassLoader;
 318     }
 319
 320     public void setParentClassLoader(ClassLoader parentClassLoader) {
 321         if(parentClassLoader == null)
 322             throw new NullPointerException();
 323         this.parentClassLoader = parentClassLoader;
 324     }
 325
 326     public void addFieldAccessor(String name, Constant accessor) {
 327         List<Constant> list = fieldAccessors.get(name);
 328         if(list == null) {
 329             list = new ArrayList<Constant>(2);
 330             fieldAccessors.put(name, list);
 331         }
 332         list.add(accessor);
 333     }
 334
 335     public void addRuleset(String name, CHRRuleset ruleset) {
 336         rulesets.put(name, ruleset);
 337     }
 338
 339     @Override
 340     public String getDeprecation() {
 341         return deprecation;
 342     }
 343
 344     public void setDeprecation(String deprecation) {
 345         this.deprecation = deprecation;
 346     }
 347
 348     @Override
 349     public ModuleDebugInfo getModuleDebugInfo() {
 350         return moduleDebugInfo;
 351     }
 352 }