bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/elaboration/modules/SCLValue.java

   1 package org.simantics.scl.compiler.elaboration.modules;
   2
   3 import java.util.ArrayList;
   4 import java.util.List;
   5
   6 import org.simantics.scl.compiler.common.names.Name;
   7 import org.simantics.scl.compiler.common.precedence.Precedence;
   8 import org.simantics.scl.compiler.constants.Constant;
   9 import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;
  10 import org.simantics.scl.compiler.elaboration.expressions.Expression;
  11 import org.simantics.scl.compiler.elaboration.macros.MacroRule;
  12 import org.simantics.scl.compiler.errors.Locations;
  13 import org.simantics.scl.compiler.internal.codegen.references.IVal;
  14 import org.simantics.scl.compiler.internal.codegen.utils.TransientClassBuilder;
  15 import org.simantics.scl.compiler.types.Type;
  16 import org.simantics.scl.compiler.types.util.Typed;
  17
  18 /**
  19  * Information about SCL values that is needed in parsing
  20  * and elaboration phases.
  21  * @author Hannu Niemist&ouml;
  22  */
  23 public final class SCLValue implements Typed {
  24     private static final int SIMPLIFIED = 1;
  25     private static final int INLINE_IN_SIMPLIFICATION = 2;
  26     private static final int FLAG_MASK = 0xffff;
  27
  28     private Name name;
  29     private Type type;
  30     private Precedence precedence = Precedence.DEFAULT;
  31     private IVal value;
  32     private Expression expression;
  33     private MacroRule macroRule;
  34     private int flags = 0;
  35     private ArrayList<SCLValueProperty> properties = new ArrayList<SCLValueProperty>(2);
  36     public String documentation;
  37     public long definitionLocation = Locations.NO_LOCATION;
  38     public String[] parameterNames;
  39
  40     public SCLValue(Name name) {
  41         this.name = name;
  42     }
  43
  44     public SCLValue(Name name, Constant value) {
  45         this(name);
  46         setValue(value);
  47     }
  48
  49     public Name getName() {
  50         return name;
  51     }
  52
  53     public Type getType() {
  54         return type;
  55     }
  56
  57     public void setType(Type type) {
  58         this.type = type;
  59     }
  60
  61     public void addProperty(SCLValueProperty property) {
  62         properties.add(property);
  63     }
  64
  65     public List<SCLValueProperty> getProperties() {
  66         return properties;
  67     }
  68
  69     public Precedence getPrecedence() {
  70         return precedence;
  71     }
  72
  73     public void setPrecedence(Precedence precedence) {
  74         this.precedence = precedence;
  75     }
  76
  77     public IVal getValue() {
  78         return value;
  79     }
  80
  81     public void setValue(IVal value) {
  82         this.value = value;
  83         if(type == null)
  84             type = value.getType();
  85     }
  86
  87     public Expression getExpression() {
  88         return expression;
  89     }
  90
  91     public Expression getSimplifiedExpression(SimplificationContext context) {
  92         if(expression != null && (flags & SIMPLIFIED) == 0) {
  93             //System.out.println("Simplify: " + name);
  94             //System.out.println("BEFORE: " + expression);
  95             expression = expression.simplify(context);
  96             //System.out.println("AFTER: " + expression);
  97             flags |= SIMPLIFIED;
  98         }
  99         return expression;
 100     }
 101
 102     public void setExpression(Expression expression) {
 103         this.expression = expression;
 104     }
 105
 106     public MacroRule getMacroRule() {
 107         return macroRule;
 108     }
 109
 110     public void setMacroRule(MacroRule macroRule) {
 111         this.macroRule = macroRule;
 112     }
 113
 114     @Override
 115     public String toString() {
 116         return name.toString();
 117     }
 118
 119     private void setFlag(int flagMask, boolean value) {
 120         if(value)
 121             flags |= flagMask;
 122         else
 123             flags &= FLAG_MASK - flagMask;
 124     }
 125
 126     public void setSimplified(boolean value) {
 127         setFlag(SIMPLIFIED, value);
 128     }
 129
 130     public void setInlineInSimplification(boolean value) {
 131         setFlag(INLINE_IN_SIMPLIFICATION, value);
 132     }
 133
 134     public boolean getInlineInSimplification() {
 135         return (flags & INLINE_IN_SIMPLIFICATION) != 0;
 136     }
 137
 138     public Object realizeValue(TransientClassBuilder classLoader) {
 139         return getValue().realizeValue(classLoader);
 140     }
 141
 142         public boolean isPrivate() {
 143                 for(SCLValueProperty property : properties)
 144                         if(property == PrivateProperty.INSTANCE)
 145                                 return true;
 146                 return false;
 147         }
 148
 149         public String isDeprecated() {
 150             for(SCLValueProperty property : properties)
 151             if(property instanceof DeprecatedProperty)
 152                 return ((DeprecatedProperty)property).description;
 153         return null;
 154         }
 155
 156         public void setDocumentation(String documentation) {
 157                 this.documentation = documentation;
 158         }
 159
 160         public String getDocumentation() {
 161                 return documentation;
 162         }
 163
 164     public boolean isPrivateOrDerived() {
 165         for(SCLValueProperty property : properties)
 166             if(property == PrivateProperty.INSTANCE || property == DerivedProperty.INSTANCE)
 167                 return true;
 168         return false;
 169     }
 170 }