gerrit.simantics Code Review - simantics/platform.git/blob

   1 package org.simantics.scl.compiler.compilation;
   2
   3 import java.util.Arrays;
   4 import java.util.function.Consumer;
   5
   6 import org.simantics.scl.compiler.elaboration.chr.CHRRuleset;
   7 import org.simantics.scl.compiler.elaboration.modules.SCLValue;
   8 import org.simantics.scl.compiler.elaboration.modules.TypeClass;
   9 import org.simantics.scl.compiler.elaboration.modules.TypeDescriptor;
  10 import org.simantics.scl.compiler.elaboration.relations.SCLEntityType;
  11 import org.simantics.scl.compiler.elaboration.relations.SCLRelation;
  12 import org.simantics.scl.compiler.elaboration.rules.MappingRelation;
  13 import org.simantics.scl.compiler.elaboration.rules.TransformationRule;
  14 import org.simantics.scl.compiler.environment.AmbiguousNameException;
  15 import org.simantics.scl.compiler.environment.Namespace;
  16 import org.simantics.scl.compiler.environment.filter.AcceptAllNamespaceFilter;
  17 import org.simantics.scl.compiler.environment.filter.NamespaceFilter;
  18 import org.simantics.scl.compiler.internal.codegen.effects.EffectConstructor;
  19 import org.simantics.scl.compiler.module.Module;
  20 import org.simantics.scl.compiler.top.SCLCompilerConfiguration;
  21 import org.simantics.scl.compiler.types.TCon;
  22
  23 import gnu.trove.procedure.TObjectProcedure;
  24
  25 public class NamespaceOfModule implements Namespace {
  26     private final Namespace base;
  27     private final Module module;
  28
  29     public NamespaceOfModule(Namespace base, Module module) {
  30         this.base = base;
  31         this.module = module;
  32     }
  33
  34     @Override
  35     public Namespace getNamespace(String name) {
  36         return base.getNamespace(name);
  37     }
  38
  39     @Override
  40     public SCLValue getValue(String name) throws AmbiguousNameException {
  41         SCLValue value = module.getValue(name);
  42         if(SCLCompilerConfiguration.ALLOW_OVERLOADING) {
  43             SCLValue value2;
  44             try {
  45                 value2 = base.getValue(name);
  46             } catch(AmbiguousNameException e) {
  47                 if(value != null) {
  48                     String[] conflictingModules = Arrays.copyOf(e.conflictingModules, e.conflictingModules.length+1);
  49                     conflictingModules[e.conflictingModules.length] = module.getName();
  50                     throw new AmbiguousNameException(Arrays.asList(conflictingModules), e.name);
  51                 }
  52                 else
  53                     throw e;
  54             }
  55             if(value == null)
  56                 return value2;
  57             if(value2 == null)
  58                 return value;
  59             throw new AmbiguousNameException(Arrays.asList(value.getName().module, value2.getName().module), value.getName().name);
  60         }
  61         else {
  62             if(value != null)
  63                 return value;
  64             return base.getValue(name);
  65         }
  66     }
  67
  68     @Override
  69     public SCLRelation getRelation(String name) throws AmbiguousNameException {
  70         SCLRelation relation = module.getRelation(name);
  71         if(relation != null)
  72             return relation;
  73         return base.getRelation(name);
  74     }
  75
  76     @Override
  77     public CHRRuleset getRuleset(String name) throws AmbiguousNameException {
  78         CHRRuleset ruleset = module.getRuleset(name);
  79         if(ruleset != null)
  80             return ruleset;
  81         return base.getRuleset(name);
  82     }
  83
  84     @Override
  85     public SCLEntityType getEntityType(String name)
  86             throws AmbiguousNameException {
  87         SCLEntityType entityType = module.getEntityType(name);
  88         if(entityType != null)
  89             return entityType;
  90         return base.getEntityType(name);
  91     }
  92
  93     @Override
  94     public TypeDescriptor getTypeDescriptor(String name)
  95             throws AmbiguousNameException {
  96         TypeDescriptor typeDescriptor = module.getTypeDescriptor(name);
  97         if(typeDescriptor != null)
  98             return typeDescriptor;
  99         return base.getTypeDescriptor(name);
 100     }
 101
 102     @Override
 103     public EffectConstructor getEffectConstructor(String name)
 104             throws AmbiguousNameException {
 105         EffectConstructor effectConstructor = module.getEffectConstructor(name);
 106         if(effectConstructor != null)
 107             return effectConstructor;
 108         return base.getEffectConstructor(name);
 109     }
 110
 111     @Override
 112     public TypeClass getTypeClass(String name) throws AmbiguousNameException {
 113         TypeClass typeClass = module.getTypeClass(name);
 114         if(typeClass != null)
 115             return typeClass;
 116         return base.getTypeClass(name);
 117     }
 118
 119     @Override
 120     public MappingRelation getMappingRelation(String name)
 121             throws AmbiguousNameException {
 122         MappingRelation mappingRelation = module.getMappingRelation(name);
 123         if(mappingRelation != null)
 124             return mappingRelation;
 125         return base.getMappingRelation(name);
 126     }
 127
 128     @Override
 129     public TransformationRule getRule(String name) throws AmbiguousNameException {
 130         TransformationRule rule = module.getRule(name);
 131         if(rule != null)
 132             return rule;
 133         return base.getRule(name);
 134     }
 135
 136     @Override
 137     public void findValuesForPrefix(String prefix, NamespaceFilter filter, TObjectProcedure<SCLValue> proc) {
 138         base.findValuesForPrefix(prefix, filter, proc);
 139         module.findValuesForPrefix(prefix, AcceptAllNamespaceFilter.INSTANCE, proc);
 140     }
 141
 142     @Override
 143     public void findTypesForPrefix(String prefix, NamespaceFilter filter, Consumer<TCon> consumer) {
 144         base.findTypesForPrefix(prefix, filter, consumer);
 145         module.findTypesForPrefix(prefix, AcceptAllNamespaceFilter.INSTANCE, consumer);
 146     }
 147
 148 }