bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/environment/NamespaceImpl.java

   1 package org.simantics.scl.compiler.environment;
   2
   3 import java.util.ArrayList;
   4 import java.util.List;
   5 import java.util.function.Consumer;
   6
   7 import org.simantics.scl.compiler.constants.Constant;
   8 import org.simantics.scl.compiler.elaboration.modules.SCLValue;
   9 import org.simantics.scl.compiler.elaboration.modules.TypeClass;
  10 import org.simantics.scl.compiler.elaboration.modules.TypeDescriptor;
  11 import org.simantics.scl.compiler.elaboration.relations.SCLEntityType;
  12 import org.simantics.scl.compiler.elaboration.relations.SCLRelation;
  13 import org.simantics.scl.compiler.elaboration.rules.MappingRelation;
  14 import org.simantics.scl.compiler.elaboration.rules.TransformationRule;
  15 import org.simantics.scl.compiler.environment.filter.NamespaceFilter;
  16 import org.simantics.scl.compiler.environment.filter.NamespaceFilters;
  17 import org.simantics.scl.compiler.internal.codegen.effects.EffectConstructor;
  18 import org.simantics.scl.compiler.module.Module;
  19 import org.simantics.scl.compiler.types.TCon;
  20
  21 import gnu.trove.map.hash.THashMap;
  22 import gnu.trove.procedure.TObjectProcedure;
  23
  24 public class NamespaceImpl implements Namespace {
  25
  26     private final THashMap<String, Namespace> namespaceMap;
  27     private final ModuleImport[] moduleImports;
  28
  29     public static class ModuleImport {
  30         public final Module module;
  31         public NamespaceFilter filter;
  32
  33         public ModuleImport(Module module, NamespaceFilter filter) {
  34             this.module = module;
  35             this.filter = filter;
  36         }
  37     }
  38
  39     public NamespaceImpl(THashMap<String, Namespace> namespaceMap,
  40             ModuleImport[] moduleImports) {
  41         this.namespaceMap = namespaceMap;
  42         this.moduleImports = moduleImports;
  43     }
  44
  45     @Override
  46     public Namespace getNamespace(String name) {
  47         return namespaceMap.get(name);
  48     }
  49
  50     @Override
  51     public SCLValue getValue(String name) throws AmbiguousNameException {
  52         SCLValue result = null, temp;
  53         Module resultModule = null;
  54         ArrayList<String> conflictingModules = null;
  55         for(ModuleImport moduleImport : moduleImports) {
  56             Module module = moduleImport.module;
  57             temp = module.getValue(name);
  58             if(temp != null
  59                     && !temp.isPrivate()
  60                     && moduleImport.filter.isValueIncluded(name)) {
  61                 if(result != null) {
  62                     if(conflictingModules == null) {
  63                         conflictingModules = new ArrayList<String>(2);
  64                         conflictingModules.add(resultModule.getName());
  65                     }
  66                     conflictingModules.add(module.getName());
  67                 }
  68                 else {
  69                     result = temp;
  70                     resultModule = module;
  71                 }
  72             }
  73         }
  74         if(conflictingModules != null)
  75             throw new AmbiguousNameException(conflictingModules, name);
  76         return result;
  77     }
  78
  79     @Override
  80     public SCLRelation getRelation(String name) throws AmbiguousNameException {
  81         SCLRelation result = null, temp;
  82         Module resultModule = null;
  83         ArrayList<String> conflictingModules = null;
  84         for(ModuleImport moduleImport : moduleImports) {
  85             Module module = moduleImport.module;
  86             temp = module.getRelation(name);
  87             if(temp != null) {
  88                 if(result != null) {
  89                     if(conflictingModules == null) {
  90                         conflictingModules = new ArrayList<String>(2);
  91                         conflictingModules.add(resultModule.getName());
  92                     }
  93                     conflictingModules.add(module.getName());
  94                 }
  95                 else {
  96                     result = temp;
  97                     resultModule = module;
  98                 }
  99             }
 100         }
 101         if(conflictingModules != null)
 102             throw new AmbiguousNameException(conflictingModules, name);
 103         return result;
 104     }
 105
 106     @Override
 107     public SCLEntityType getEntityType(String name)
 108             throws AmbiguousNameException {
 109         SCLEntityType result = null, temp;
 110         Module resultModule = null;
 111         ArrayList<String> conflictingModules = null;
 112         for(ModuleImport moduleImport : moduleImports) {
 113             Module module = moduleImport.module;
 114             temp = module.getEntityType(name);
 115             if(temp != null) {
 116                 if(result != null) {
 117                     if(conflictingModules == null) {
 118                         conflictingModules = new ArrayList<String>(2);
 119                         conflictingModules.add(resultModule.getName());
 120                     }
 121                     conflictingModules.add(module.getName());
 122                 }
 123                 else {
 124                     result = temp;
 125                     resultModule = module;
 126                 }
 127             }
 128         }
 129         if(conflictingModules != null)
 130             throw new AmbiguousNameException(conflictingModules, name);
 131         return result;
 132     }
 133
 134     @Override
 135     public TypeDescriptor getTypeDescriptor(String name)
 136             throws AmbiguousNameException {
 137         TypeDescriptor result = null, temp;
 138         Module resultModule = null;
 139         ArrayList<String> conflictingModules = null;
 140         for(ModuleImport moduleImport : moduleImports) {
 141             Module module = moduleImport.module;
 142             temp = module.getTypeDescriptor(name);
 143             if(temp != null) {
 144                 if(result != null) {
 145                     if(conflictingModules == null) {
 146                         conflictingModules = new ArrayList<String>(2);
 147                         conflictingModules.add(resultModule.getName());
 148                     }
 149                     conflictingModules.add(module.getName());
 150                 }
 151                 else {
 152                     result = temp;
 153                     resultModule = module;
 154                 }
 155             }
 156         }
 157         if(conflictingModules != null)
 158             throw new AmbiguousNameException(conflictingModules, name);
 159         return result;
 160     }
 161
 162     @Override
 163     public EffectConstructor getEffectConstructor(String name)
 164             throws AmbiguousNameException {
 165         EffectConstructor result = null, temp;
 166         Module resultModule = null;
 167         ArrayList<String> conflictingModules = null;
 168         for(ModuleImport moduleImport : moduleImports) {
 169             Module module = moduleImport.module;
 170             temp = module.getEffectConstructor(name);
 171             if(temp != null) {
 172                 if(result != null) {
 173                     if(conflictingModules == null) {
 174                         conflictingModules = new ArrayList<String>(2);
 175                         conflictingModules.add(resultModule.getName());
 176                     }
 177                     conflictingModules.add(module.getName());
 178                 }
 179                 else {
 180                     result = temp;
 181                     resultModule = module;
 182                 }
 183             }
 184         }
 185         if(conflictingModules != null)
 186             throw new AmbiguousNameException(conflictingModules, name);
 187         return result;
 188     }
 189
 190     @Override
 191     public TypeClass getTypeClass(String name) throws AmbiguousNameException {
 192         TypeClass result = null, temp;
 193         Module resultModule = null;
 194         ArrayList<String> conflictingModules = null;
 195         for(ModuleImport moduleImport : moduleImports) {
 196             Module module = moduleImport.module;
 197             temp = module.getTypeClass(name);
 198             if(temp != null) {
 199                 if(result != null) {
 200                     if(conflictingModules == null) {
 201                         conflictingModules = new ArrayList<String>(2);
 202                         conflictingModules.add(resultModule.getName());
 203                     }
 204                     conflictingModules.add(module.getName());
 205                 }
 206                 else {
 207                     result = temp;
 208                     resultModule = module;
 209                 }
 210             }
 211         }
 212         if(conflictingModules != null)
 213             throw new AmbiguousNameException(conflictingModules, name);
 214         return result;
 215     }
 216
 217     @Override
 218     public MappingRelation getMappingRelation(String name) throws AmbiguousNameException {
 219         MappingRelation result = null, temp;
 220         Module resultModule = null;
 221         ArrayList<String> conflictingModules = null;
 222         for(ModuleImport moduleImport : moduleImports) {
 223             Module module = moduleImport.module;
 224             temp = module.getMappingRelation(name);
 225             if(temp != null) {
 226                 if(result != null) {
 227                     if(conflictingModules == null) {
 228                         conflictingModules = new ArrayList<String>(2);
 229                         conflictingModules.add(resultModule.getName());
 230                     }
 231                     conflictingModules.add(module.getName());
 232                 }
 233                 else {
 234                     result = temp;
 235                     resultModule = module;
 236                 }
 237             }
 238         }
 239         if(conflictingModules != null)
 240             throw new AmbiguousNameException(conflictingModules, name);
 241         return result;
 242     }
 243
 244     @Override
 245     public TransformationRule getRule(String name) throws AmbiguousNameException {
 246         TransformationRule result = null, temp;
 247         Module resultModule = null;
 248         ArrayList<String> conflictingModules = null;
 249         for(ModuleImport moduleImport : moduleImports) {
 250             Module module = moduleImport.module;
 251             temp = module.getRule(name);
 252             if(temp != null) {
 253                 if(result != null) {
 254                     if(conflictingModules == null) {
 255                         conflictingModules = new ArrayList<String>(2);
 256                         conflictingModules.add(resultModule.getName());
 257                     }
 258                     conflictingModules.add(module.getName());
 259                 }
 260                 else {
 261                     result = temp;
 262                     resultModule = module;
 263                 }
 264             }
 265         }
 266         if(conflictingModules != null)
 267             throw new AmbiguousNameException(conflictingModules, name);
 268         return result;
 269     }
 270
 271     @Override
 272     public void findValuesForPrefix(String prefix, NamespaceFilter filter, TObjectProcedure<SCLValue> proc) {
 273         for(ModuleImport moduleImport : moduleImports)
 274             moduleImport.module.findValuesForPrefix(prefix,
 275                     NamespaceFilters.intersection(filter, moduleImport.filter),
 276                     proc);
 277     }
 278
 279     @Override
 280     public void findTypesForPrefix(String prefix, NamespaceFilter filter, Consumer<TCon> consumer) {
 281         for(ModuleImport moduleImport : moduleImports)
 282             moduleImport.module.findTypesForPrefix(prefix,
 283                     NamespaceFilters.intersection(filter, moduleImport.filter),
 284                     consumer);
 285     }
 286
 287 }