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