@Override
  public IValue evaluateValue(
      final CompilationTimeStamp timestamp,
      final Expected_Value_type expectedValue,
      final IReferenceChain referenceChain) {
    if (lastTimeChecked != null && !lastTimeChecked.isLess(timestamp)) {
      return lastValue;
    }

    isErroneous = false;
    lastTimeChecked = timestamp;
    lastValue = this;

    if (value == null) {
      return lastValue;
    }

    checkExpressionOperands(timestamp, expectedValue, referenceChain);

    if (getIsErroneous(timestamp) || isUnfoldable(timestamp, referenceChain)) {
      return lastValue;
    }

    IValue last = value.getValueRefdLast(timestamp, referenceChain);
    if (last.getIsErroneous(timestamp)) {
      return lastValue;
    }

    switch (last.getValuetype()) {
      case CHARSTRING_VALUE:
        {
          String string = ((Charstring_Value) last).getValue();
          string = string.trim();

          double number;
          if ("-INF".equals(string)) {
            number = Float.NEGATIVE_INFINITY;
          } else if ("INF".equals(string)) {
            number = Float.POSITIVE_INFINITY;
          } else {
            try {
              number = Double.parseDouble(string);
            } catch (NumberFormatException e) {
              number = 0;
            }
          }
          lastValue = new Real_Value(number);
          break;
        }
      default:
        return this;
    }

    lastValue.copyGeneralProperties(this);
    return lastValue;
  }
 protected void check(IValue expression, Problems problems) {
   if (expression instanceof Expression_Value) {
     ExpressionVisitor visitor = new ExpressionVisitor();
     expression.accept(visitor);
     if (visitor.getCount() > reportTooComplexExpressionSize) {
       String msg =
           MessageFormat.format(COMPLEXITY, visitor.getCount(), reportTooComplexExpressionSize);
       problems.report(expression.getLocation(), msg);
     }
   }
 }
 @Override
 public void setMyScope(final Scope scope) {
   super.setMyScope(scope);
   if (value != null) {
     value.setMyScope(scope);
   }
 }
  public ComponentRunnningExpression(final IValue value) {
    this.value = value;

    if (value != null) {
      value.setFullNameParent(this);
    }
  }
 @Override
 protected boolean memberAccept(ASTVisitor v) {
   if (value != null && !value.accept(v)) {
     return false;
   }
   return true;
 }
  /**
   * Checks the parameters of the expression and if they are valid in their position in the
   * expression or not.
   *
   * @param timestamp the timestamp of the actual semantic check cycle.
   * @param expectedValue the kind of value expected.
   * @param referenceChain a reference chain to detect cyclic references.
   */
  private void checkExpressionOperands(
      final CompilationTimeStamp timestamp,
      final Expected_Value_type expectedValue,
      final IReferenceChain referenceChain) {
    IValue tempValue = value.setLoweridToReference(timestamp);
    Component_Type.checkExpressionOperandComponentRefernce(timestamp, tempValue, OPERATIONNAME);

    checkExpressionDynamicPart(expectedValue, OPERATIONNAME, false, true, false);
  }
  @Override
  public void findReferences(
      final ReferenceFinder referenceFinder, final List<Hit> foundIdentifiers) {
    if (value == null) {
      return;
    }

    value.findReferences(referenceFinder, foundIdentifiers);
  }
  @Override
  public IValue evaluateValue(
      final CompilationTimeStamp timestamp,
      final Expected_Value_type expectedValue,
      final IReferenceChain referenceChain) {
    if (lastTimeChecked != null && !lastTimeChecked.isLess(timestamp)) {
      return lastValue;
    }

    isErroneous = false;
    lastTimeChecked = timestamp;
    lastValue = this;

    if (value1 == null || value2 == null) {
      return lastValue;
    }

    checkExpressionOperands(timestamp, expectedValue, referenceChain);

    if (getIsErroneous(timestamp)) {
      return lastValue;
    }

    if (isUnfoldable(timestamp, referenceChain)) {
      return lastValue;
    }

    IValue last1 = value1.getValueRefdLast(timestamp, referenceChain);
    IValue last2 = value2.getValueRefdLast(timestamp, referenceChain);
    if (last1.getIsErroneous(timestamp) || last2.getIsErroneous(timestamp)) {
      setIsErroneous(true);
      return lastValue;
    }

    Integer_Value i1 = (Integer_Value) last1;
    long i2 = ((Integer_Value) last2).getValue();
    lastValue = new Octetstring_Value(Int2HexExpression.int2hex(i1, (int) i2 * 2));

    lastValue.copyGeneralProperties(this);
    return lastValue;
  }
  @Override
  public void updateSyntax(final TTCN3ReparseUpdater reparser, final boolean isDamaged)
      throws ReParseException {
    if (isDamaged) {
      throw new ReParseException();
    }

    if (value instanceof IIncrementallyUpdateable) {
      ((IIncrementallyUpdateable) value).updateSyntax(reparser, false);
      reparser.updateLocation(value.getLocation());
    } else if (value != null) {
      throw new ReParseException();
    }
  }
  /**
   * Checks the parameters of the expression and if they are valid in their position in the
   * expression or not.
   *
   * @param timestamp the timestamp of the actual semantic check cycle.
   * @param expectedValue the kind of value expected.
   * @param referenceChain a reference chain to detect cyclic references.
   */
  private void checkExpressionOperands(
      final CompilationTimeStamp timestamp,
      final Expected_Value_type expectedValue,
      final IReferenceChain referenceChain) {
    if (value == null) {
      return;
    }

    value.setLoweridToReference(timestamp);
    Type_type tempType = value.getExpressionReturntype(timestamp, expectedValue);

    switch (tempType) {
      case TYPE_CHARSTRING:
        IValue last = value.getValueRefdLast(timestamp, expectedValue, referenceChain);
        if (!last.isUnfoldable(timestamp)) {
          String string = ((Charstring_Value) last).getValue();
          string = string.trim();
          if (!"-INF".equals(string) && !"INF".equals(string)) {
            try {
              Double.parseDouble(string);
            } catch (NumberFormatException e) {
              value.getLocation().reportSemanticError(OPERANDERROR2);
            }
          }
        }
        return;
      case TYPE_UNDEFINED:
        setIsErroneous(true);
        return;
      default:
        if (!isErroneous) {
          location.reportSemanticError(OPERANDERROR1);
          setIsErroneous(true);
        }
        return;
    }
  }
  /**
   * Checks the parameters of the expression and if they are valid in their position in the
   * expression or not.
   *
   * @param timestamp the timestamp of the actual semantic check cycle.
   * @param expectedValue the kind of value expected.
   * @param referenceChain a reference chain to detect cyclic references.
   */
  private void checkExpressionOperands(
      final CompilationTimeStamp timestamp,
      final Expected_Value_type expectedValue,
      final IReferenceChain referenceChain) {
    if (value1 == null || value2 == null) {
      return;
    }

    IValue last1 = null;
    IValue last2 = null;
    Integer_Value i1 = new Integer_Value(0);

    value1.setLoweridToReference(timestamp);
    Type_type tempType1 = value1.getExpressionReturntype(timestamp, expectedValue);

    switch (tempType1) {
      case TYPE_INTEGER:
        last1 = value1.getValueRefdLast(timestamp, expectedValue, referenceChain);
        if (!last1.isUnfoldable(timestamp)
            && Value.Value_type.INTEGER_VALUE.equals(last1.getValuetype())) {
          i1 = (Integer_Value) last1;
          if (i1.signum() < 0) {
            value1.getLocation().reportSemanticError(OPERANDERROR2);
            setIsErroneous(true);
          }
        }
        break;
      case TYPE_UNDEFINED:
        setIsErroneous(true);
        break;
      default:
        if (!isErroneous) {
          location.reportSemanticError(OPERANDERROR1);
          setIsErroneous(true);
        }
        break;
    }

    value2.setLoweridToReference(timestamp);
    Type_type tempType2 = value2.getExpressionReturntype(timestamp, expectedValue);

    switch (tempType2) {
      case TYPE_INTEGER:
        last2 = value2.getValueRefdLast(timestamp, expectedValue, referenceChain);
        if (!last2.isUnfoldable(timestamp)
            && Value.Value_type.INTEGER_VALUE.equals(last2.getValuetype())) {
          if (!((Integer_Value) last2).isNative()) {
            value2.getLocation().reportSemanticError(MessageFormat.format(OPERANDERROR6, last2));
            setIsErroneous(true);
          } else {
            long i2 = ((Integer_Value) last2).getValue();
            if (i2 < 0) {
              value2.getLocation().reportSemanticError(OPERANDERROR4);
              setIsErroneous(true);
            } else if (last1 != null
                && !last1.isUnfoldable(timestamp)
                && Value.Value_type.INTEGER_VALUE.equals(last1.getValuetype())) {
              if ((i1.shiftRight((int) i2 * 8)).signum() > 0) {
                location.reportSemanticError(MessageFormat.format(OPERANDERROR5, i1, i2));
                setIsErroneous(true);
              }
            }
          }
        }
        break;
      case TYPE_UNDEFINED:
        setIsErroneous(true);
        break;
      default:
        if (!isErroneous) {
          location.reportSemanticError(OPERANDERROR3);
          setIsErroneous(true);
        }
        break;
    }
  }
 public void check(final CompilationTimeStamp timestamp, final Scope scope) {
   templateInst.setMyScope(scope);
   if (isOmit()) {
     // special case, no type needed
     if (indicator == Indicator_Type.Before_Indicator
         || indicator == Indicator_Type.After_Indicator) {
       if (!hasAllKeyword) {
         final String message =
             MessageFormat.format(
                 "Keyword `all'' is expected after `omit'' when omitting all fields {0} the specified field",
                 indicator.getDisplayName());
         templateInst.getLocation().reportSemanticError(message);
       }
     } else {
       if (hasAllKeyword) {
         templateInst
             .getLocation()
             .reportSemanticError("Unexpected `all' keyword after `omit' when omitting one field");
       }
     }
     type = null;
     return;
   }
   if (hasAllKeyword) {
     templateInst
         .getLocation()
         .reportSemanticError("Unexpected `all' keyword after the in-line template");
   }
   // determine the type of the tmpl_inst
   type = templateInst.getExpressionGovernor(timestamp, Expected_Value_type.EXPECTED_TEMPLATE);
   if (type == null) {
     templateInst.getTemplateBody().setLoweridToReference(timestamp);
     type = templateInst.getExpressionGovernor(timestamp, Expected_Value_type.EXPECTED_TEMPLATE);
   }
   if (type == null) {
     templateInst
         .getLocation()
         .reportSemanticError("Cannot determine the type of the in-line template");
     return;
   }
   type.check(timestamp);
   IType typeLast = type.getTypeRefdLast(timestamp);
   if (typeLast == null || typeLast.getIsErroneous(timestamp)) {
     type = null;
     return;
   }
   if (isRaw) {
     switch (typeLast.getTypetypeTtcn3()) {
       case TYPE_BITSTRING:
       case TYPE_OCTETSTRING:
       case TYPE_CHARSTRING:
       case TYPE_UCHARSTRING:
         break;
       default:
         templateInst
             .getLocation()
             .reportSemanticError(
                 MessageFormat.format(
                     "An in-line template of type `{0}'' cannot be used as a `raw'' erroneous value",
                     typeLast.getTypename()));
     }
   }
   if (templateInst.getDerivedReference() != null) {
     templateInst
         .getLocation()
         .reportSemanticError(
             "Reference to a constant value was expected instead of an in-line modified template");
     type = null;
     return;
   }
   ITTCN3Template templ = templateInst.getTemplateBody();
   if (templ.isValue(timestamp)) {
     value = templ.getValue();
     value.setMyGovernor(type);
     type.checkThisValueRef(timestamp, value);
     type.checkThisValue(
         timestamp,
         value,
         new ValueCheckingOptions(
             Expected_Value_type.EXPECTED_CONSTANT, false, false, true, false, false));
   } else {
     templateInst
         .getLocation()
         .reportSemanticError("A specific value without matching symbols was expected");
     type = null;
     return;
   }
 }
  @Override
  public IType getFieldType(
      final CompilationTimeStamp timestamp,
      final Reference reference,
      final int actualSubReference,
      final Expected_Value_type expectedIndex,
      final IReferenceChain refChain,
      final boolean interruptIfOptional) {
    List<ISubReference> subreferences = reference.getSubreferences();
    if (subreferences.size() <= actualSubReference) {
      return this;
    }

    Expected_Value_type internalExpectation =
        expectedIndex == Expected_Value_type.EXPECTED_TEMPLATE
            ? Expected_Value_type.EXPECTED_DYNAMIC_VALUE
            : expectedIndex;

    ISubReference subreference = subreferences.get(actualSubReference);
    switch (subreference.getReferenceType()) {
      case arraySubReference:
        Value indexValue = ((ArraySubReference) subreference).getValue();
        if (indexValue != null) {
          indexValue.setLoweridToReference(timestamp);
          Type_type tempType = indexValue.getExpressionReturntype(timestamp, expectedIndex);

          switch (tempType) {
            case TYPE_INTEGER:
              IValue last = indexValue.getValueRefdLast(timestamp, expectedIndex, refChain);
              if (Value_type.INTEGER_VALUE.equals(last.getValuetype())) {
                Integer_Value lastInteger = (Integer_Value) last;
                if (lastInteger.isNative()) {
                  long temp = lastInteger.getValue();
                  if (temp < 0) {
                    indexValue
                        .getLocation()
                        .reportSemanticError(MessageFormat.format(NONNEGATIVINDEXEXPECTED, last));
                    indexValue.setIsErroneous(true);
                  }
                } else {
                  indexValue
                      .getLocation()
                      .reportSemanticError(
                          MessageFormat.format(TOOBIGINDEX, indexValue, getTypename()));
                  indexValue.setIsErroneous(true);
                }
              }
              break;
            case TYPE_UNDEFINED:
              indexValue.setIsErroneous(true);
              break;
            default:
              indexValue.getLocation().reportSemanticError(INTEGERINDEXEXPECTED);
              indexValue.setIsErroneous(true);
              break;
          }
        }

        if (getOfType() != null) {
          return getOfType()
              .getFieldType(
                  timestamp,
                  reference,
                  actualSubReference + 1,
                  internalExpectation,
                  refChain,
                  interruptIfOptional);
        }

        return null;
      case fieldSubReference:
        subreference
            .getLocation()
            .reportSemanticError(
                MessageFormat.format(
                    FieldSubReference.INVALIDSUBREFERENCE,
                    ((FieldSubReference) subreference).getId().getDisplayName(),
                    getTypename()));
        return null;
      case parameterisedSubReference:
        subreference
            .getLocation()
            .reportSemanticError(
                MessageFormat.format(
                    FieldSubReference.INVALIDSUBREFERENCE,
                    ((ParameterisedSubReference) subreference).getId().getDisplayName(),
                    getTypename()));
        return null;
      default:
        subreference.getLocation().reportSemanticError(ISubReference.INVALIDSUBREFERENCE);
        return null;
    }
  }
  @Override
  public void checkThisTemplate(
      final CompilationTimeStamp timestamp,
      final ITTCN3Template template,
      final boolean isModified,
      final boolean implicitOmit) {
    registerUsage(template);
    template.setMyGovernor(this);

    switch (template.getTemplatetype()) {
      case OMIT_VALUE:
        if (template.getLengthRestriction() != null) {
          template.getLocation().reportSemanticWarning(REDUNDANTLENGTHRESTRICTION);
        }
        break;
      case PERMUTATION_MATCH:
        {
          PermutationMatch_Template permutationTemplate = (PermutationMatch_Template) template;
          int nofComponents = permutationTemplate.getNofTemplates();
          for (int i = 0; i < nofComponents; i++) {
            ITTCN3Template templateComponent =
                permutationTemplate.getTemplateByIndex(
                    i); // FIXME: type is ok? It should be ITemplateListItem!
            templateComponent.setMyGovernor(getOfType());
            templateComponent =
                getOfType()
                    .checkThisTemplateRef(
                        timestamp,
                        templateComponent); // It does not do anything for AllElementsFrom, it is ok
            templateComponent.checkThisTemplateGeneric(
                timestamp,
                getOfType(),
                false,
                false,
                true,
                true,
                implicitOmit); // it is a special for AllElementsFrom, it is the usual for
                               // TemplateBody
          }
          break;
        }
      case SUPERSET_MATCH:
        {
          SupersetMatch_Template supersetTemplate = (SupersetMatch_Template) template;
          int nofComponents = supersetTemplate.getNofTemplates();
          for (int i = 0; i < nofComponents; i++) {
            ITTCN3Template templateComponent =
                supersetTemplate.getTemplateByIndex(
                    i); // FIXME: type is ok? It should be ITemplateListItem!
            templateComponent.setMyGovernor(getOfType());
            templateComponent =
                getOfType()
                    .checkThisTemplateRef(
                        timestamp,
                        templateComponent); // It does not do anything for AllElementsFrom, it is ok
            templateComponent.checkThisTemplateGeneric(
                timestamp,
                getOfType(),
                false,
                false,
                true,
                true,
                implicitOmit); // it is a special for AllElementsFrom, it is the usual for
                               // TemplateBody
          }
          break;
        }
      case SUBSET_MATCH:
        {
          SubsetMatch_Template subsetTemplate = (SubsetMatch_Template) template;
          int nofComponents = subsetTemplate.getNofTemplates();
          for (int i = 0; i < nofComponents; i++) {
            ITTCN3Template templateComponent =
                subsetTemplate.getTemplateByIndex(
                    i); // FIXME: type is ok? It should be ITemplateListItem!
            templateComponent.setMyGovernor(getOfType());
            templateComponent =
                getOfType()
                    .checkThisTemplateRef(
                        timestamp,
                        templateComponent); // It does not do anything for AllElementsFrom, it is ok
            templateComponent.checkThisTemplateGeneric(
                timestamp,
                getOfType(),
                false,
                false,
                true,
                true,
                implicitOmit); // it is a special for AllElementsFrom, it is the usual for
                               // TemplateBody
          }
          break;
        }
      case TEMPLATE_LIST:
        {
          Completeness_type completeness =
              template.getCompletenessConditionSeof(timestamp, isModified);
          Template_List base = null;
          int nofBaseComps = 0;
          if (Completeness_type.PARTIAL.equals(completeness)) {
            ITTCN3Template tempBase = template.getBaseTemplate();
            if (tempBase != null) {
              tempBase = tempBase.getTemplateReferencedLast(timestamp);
            }

            if (tempBase == null) {
              setIsErroneous(true);
              return;
            }

            base = ((Template_List) tempBase);
            nofBaseComps = base.getNofTemplates();
          }

          Template_List templateList = (Template_List) template;
          int nofComponents = templateList.getNofTemplates();
          for (int i = 0; i < nofComponents; i++) {
            ITTCN3Template component = templateList.getTemplateByIndex(i);
            component.setMyGovernor(getOfType());
            if (base != null && nofBaseComps > i) {
              component.setBaseTemplate(base.getTemplateByIndex(i));
            } else {
              component.setBaseTemplate(null);
            }

            component = getOfType().checkThisTemplateRef(timestamp, component);

            switch (component.getTemplatetype()) {
              case PERMUTATION_MATCH:
              case SUPERSET_MATCH:
              case SUBSET_MATCH:
                // FIXME: for Complement??? case COMPLEMENTED_LIST: ???
                // the elements of permutation has to be checked by u.seof.ofType
                // the templates within the permutation always have to be complete
                component.checkThisTemplateGeneric(
                    timestamp, this, false, false, true, true, implicitOmit);
                break;
              case TEMPLATE_NOTUSED:
                if (Completeness_type.MUST_COMPLETE.equals(completeness)) {
                  component.getLocation().reportSemanticError(NOTUSEDNOTALLOWED1);
                } else if (Completeness_type.PARTIAL.equals(completeness) && i >= nofBaseComps) {
                  component.getLocation().reportSemanticError(NOTUSEDNOTALLOWED2);
                }
                break;
              default:
                boolean embeddedModified =
                    (completeness == Completeness_type.MAY_INCOMPLETE)
                        || (completeness == Completeness_type.PARTIAL && i < nofBaseComps);
                component.checkThisTemplateGeneric(
                    timestamp, getOfType(), embeddedModified, false, true, true, implicitOmit);
                break;
            }
          }
          break;
        }
      case INDEXED_TEMPLATE_LIST:
        {
          Map<Long, Integer> indexMap = new HashMap<Long, Integer>();
          Indexed_Template_List indexedTemplateList = (Indexed_Template_List) template;
          for (int i = 0, size = indexedTemplateList.getNofTemplates(); i < size; i++) {
            IndexedTemplate indexedTemplate = indexedTemplateList.getIndexedTemplateByIndex(i);
            Value indexValue = indexedTemplate.getIndex().getValue();
            ITTCN3Template templateComponent = indexedTemplate.getTemplate();

            IReferenceChain chain =
                ReferenceChain.getInstance(IReferenceChain.CIRCULARREFERENCE, true);
            IValue lastValue = indexValue.getValueRefdLast(timestamp, chain);
            chain.release();
            if (Value_type.INTEGER_VALUE.equals(lastValue.getValuetype())) {
              long index = ((Integer_Value) lastValue).getValue();
              if (index > Integer.MAX_VALUE) {
                indexValue
                    .getLocation()
                    .reportSemanticError(
                        MessageFormat.format(
                            TOOBIGINDEXTEMPLATE, Integer.MAX_VALUE, getTypename(), index));
                indexValue.setIsErroneous(true);
              } else if (index < 0) {
                indexValue
                    .getLocation()
                    .reportSemanticError(
                        MessageFormat.format(
                            NONNEGATIVEINDEXEXPECTEDTEMPLATE, getTypename(), index));
                indexValue.setIsErroneous(true);
              } else {
                if (indexMap.containsKey(index)) {
                  indexValue
                      .getLocation()
                      .reportSemanticError(
                          MessageFormat.format(DUPLICATEINDEX, index, i + 1, indexMap.get(index)));
                  indexValue.setIsErroneous(true);
                } else {
                  indexMap.put(index, i);
                }
              }
            } else {
              indexValue.getLocation().reportSemanticError(INTEGERINDEXEXPECTED);
              indexValue.setIsErroneous(true);
            }

            templateComponent.setMyGovernor(getOfType());
            templateComponent = getOfType().checkThisTemplateRef(timestamp, templateComponent);
            templateComponent.checkThisTemplateGeneric(
                timestamp, getOfType(), true, false, true, true, implicitOmit);
          }
          break;
        }
      default:
        template
            .getLocation()
            .reportSemanticError(
                MessageFormat.format(
                    TEMPLATENOTALLOWED, template.getTemplateTypeName(), getTypename()));
        break;
    }
  }
  /**
   * Checks the SequenceOf_value kind value against this type.
   *
   * <p>Please note, that this function can only be called once we know for sure that the value is
   * of set-of type.
   *
   * @param timestamp the timestamp of the actual semantic check cycle.
   * @param value the value to be checked
   * @param expectedValue the kind of value expected here.
   * @param incompleteAllowed wheather incomplete value is allowed or not.
   * @param implicit_omit true if the implicit omit optional attribute was set for the value, false
   *     otherwise
   */
  public void checkThisValueSequenceOf(
      final CompilationTimeStamp timestamp,
      final SequenceOf_Value value,
      final Expected_Value_type expectedValue,
      final boolean incompleteAllowed,
      final boolean implicit_omit,
      final boolean strElem) {
    if (value.isIndexed()) {
      boolean checkHoles = Expected_Value_type.EXPECTED_CONSTANT.equals(expectedValue);
      BigInteger maxIndex = BigInteger.valueOf(-1);
      Map<BigInteger, Integer> indexMap =
          new HashMap<BigInteger, Integer>(value.getNofComponents());
      for (int i = 0, size = value.getNofComponents(); i < size; i++) {
        IValue component = value.getValueByIndex(i);
        IValue index = value.getIndexByIndex(i);
        IReferenceChain referenceChain =
            ReferenceChain.getInstance(IReferenceChain.CIRCULARREFERENCE, true);
        IValue indexLast = index.getValueRefdLast(timestamp, referenceChain);
        referenceChain.release();

        if (indexLast.getIsErroneous(timestamp)
            || !Value_type.INTEGER_VALUE.equals(indexLast.getValuetype())) {
          checkHoles = false;
        } else {
          BigInteger tempIndex = ((Integer_Value) indexLast).getValueValue();
          if (tempIndex.compareTo(BigInteger.valueOf(Integer.MAX_VALUE)) == 1) {
            index
                .getLocation()
                .reportSemanticError(
                    MessageFormat.format(
                        "A integer value less than `{0}'' was expected for indexing type `{1}'' instead of `{2}''",
                        Integer.MAX_VALUE, getTypename(), tempIndex));
            checkHoles = false;
          } else if (tempIndex.compareTo(BigInteger.ZERO) == -1) {
            index
                .getLocation()
                .reportSemanticError(
                    MessageFormat.format(
                        "A non-negative integer value was expected for indexing type `{0}'' instead of `{1}''",
                        getTypename(), tempIndex));
            checkHoles = false;
          } else if (indexMap.containsKey(tempIndex)) {
            index
                .getLocation()
                .reportSemanticError(
                    MessageFormat.format(
                        "Duplicate index value `{0}'' for components {1} and {2}",
                        tempIndex, indexMap.get(tempIndex), i + 1));
            checkHoles = false;
          } else {
            indexMap.put(tempIndex, Integer.valueOf(i + 1));
            if (maxIndex.compareTo(tempIndex) == -1) {
              maxIndex = tempIndex;
            }
          }
        }

        component.setMyGovernor(getOfType());
        IValue tempValue2 = getOfType().checkThisValueRef(timestamp, component);
        getOfType()
            .checkThisValue(
                timestamp,
                tempValue2,
                new ValueCheckingOptions(
                    expectedValue, incompleteAllowed, false, true, implicit_omit, strElem));
      }
      if (checkHoles) {
        if (maxIndex.compareTo(BigInteger.valueOf(indexMap.size() - 1)) != 0) {
          value
              .getLocation()
              .reportSemanticError("It's not allowed to create hole(s) in constant values");
        }
      }
    } else {
      for (int i = 0, size = value.getNofComponents(); i < size; i++) {
        IValue component = value.getValueByIndex(i);
        component.setMyGovernor(getOfType());
        if (Value_type.NOTUSED_VALUE.equals(component.getValuetype())) {
          if (!incompleteAllowed) {
            component.getLocation().reportSemanticError(INCOMPLETEPRESENTERROR);
          }
        } else {
          IValue tempValue2 = getOfType().checkThisValueRef(timestamp, component);
          getOfType()
              .checkThisValue(
                  timestamp,
                  tempValue2,
                  new ValueCheckingOptions(
                      expectedValue, incompleteAllowed, false, true, implicit_omit, strElem));
        }
      }
    }
  }
  @Override
  public void checkThisValue(
      final CompilationTimeStamp timestamp,
      final IValue value,
      final ValueCheckingOptions valueCheckingOptions) {
    if (getIsErroneous(timestamp)) {
      return;
    }

    super.checkThisValue(timestamp, value, valueCheckingOptions);

    IValue last = value.getValueRefdLast(timestamp, valueCheckingOptions.expected_value, null);
    if (last == null || last.getIsErroneous(timestamp)) {
      return;
    }

    // already handled ones
    switch (value.getValuetype()) {
      case OMIT_VALUE:
      case REFERENCED_VALUE:
        return;
      case UNDEFINED_LOWERIDENTIFIER_VALUE:
        if (Value_type.REFERENCED_VALUE.equals(last.getValuetype())) {
          return;
        }
        break;
      default:
        break;
    }

    if (Value_type.UNDEFINED_BLOCK.equals(last.getValuetype())) {
      last = last.setValuetype(timestamp, Value_type.SEQUENCEOF_VALUE);
    }
    if (last.getIsErroneous(timestamp)) {
      return;
    }

    switch (last.getValuetype()) {
      case SEQUENCEOF_VALUE:
        {
          checkThisValueSequenceOf(
              timestamp,
              (SequenceOf_Value) last,
              valueCheckingOptions.expected_value,
              valueCheckingOptions.incomplete_allowed,
              valueCheckingOptions.implicit_omit,
              valueCheckingOptions.str_elem);
          break;
        }
      case SETOF_VALUE:
        {
          checkThisValueSetOf(
              timestamp,
              (SetOf_Value) last,
              valueCheckingOptions.expected_value,
              valueCheckingOptions.incomplete_allowed,
              valueCheckingOptions.implicit_omit,
              valueCheckingOptions.str_elem);
          break;
        }
      case EXPRESSION_VALUE:
      case MACRO_VALUE:
        // already checked
        break;
      default:
        if (value.isAsn()) {
          value.getLocation().reportSemanticError(SEQOFVALUEEXPECTED);
        } else {
          value.getLocation().reportSemanticError(RECORDOFVALUEEXPECTED);
        }

        value.setIsErroneous(true);
    }

    if (valueCheckingOptions.sub_check) {
      // there is no parent type to check
      if (subType != null) {
        subType.checkThisValue(timestamp, last);
      }
    }
  }
 @Override
 public String createStringRepresentation() {
   StringBuilder builder = new StringBuilder();
   builder.append(value.createStringRepresentation()).append(".running");
   return builder.toString();
 }
  @Override
  public void checkThisValue(
      final CompilationTimeStamp timestamp,
      final IValue value,
      final ValueCheckingOptions valueCheckingOptions) {
    super.checkThisValue(timestamp, value, valueCheckingOptions);

    IValue last = value.getValueRefdLast(timestamp, valueCheckingOptions.expected_value, null);
    if (null == last || last.getIsErroneous(timestamp)) {
      return;
    }

    // already handled ones
    switch (value.getValuetype()) {
      case OMIT_VALUE:
      case REFERENCED_VALUE:
        return;
      case UNDEFINED_LOWERIDENTIFIER_VALUE:
        if (Value_type.REFERENCED_VALUE.equals(last.getValuetype())) {
          return;
        }
        break;
      default:
        break;
    }

    switch (last.getValuetype()) {
      case UNDEFINED_BLOCK:
        last = last.setValuetype(timestamp, Value_type.CHARSYMBOLS_VALUE);
        if (last.getIsErroneous(timestamp)) {
          return;
        }

        last.setValuetype(timestamp, Value_type.UNIVERSALCHARSTRING_VALUE);
        break;
      case CHARSYMBOLS_VALUE:
      case CHARSTRING_VALUE:
        last.setValuetype(timestamp, Value_type.UNIVERSALCHARSTRING_VALUE);
        break;
      case ISO2022STRING_VALUE:
        location.reportSemanticError(UniversalCharstring_Value.ISOCONVERTION);
        setIsErroneous(true);
        break;
      case UNIVERSALCHARSTRING_VALUE:
        break;
      case EXPRESSION_VALUE:
      case MACRO_VALUE:
        // already checked
        break;
      default:
        value.getLocation().reportSemanticError(BMPSTRINGVALUEEXPECTED);
        value.setIsErroneous(true);
    }
  }