C++ ArrayType::hasFixedLength方法代码示例

int32_t
sp::ComputeSizeOfType(ReportingContext &cc, Type *aType, size_t level)
{
  if (aType->isUnresolvedTypedef()) {
    cc.report(rmsg::recursive_type);
    return 0;
  }
  if (!aType->isArray()) {
    cc.report(rmsg::sizeof_needs_array);
    return 0;
  }

  ArrayType *type = aType->toArray();
  for (size_t i = 1; i <= level; i++) {
    if (!type->contained()->isArray()) {
      cc.report(rmsg::sizeof_invalid_rank);
      return 0;
    }
    type = type->contained()->toArray();
  }

  if (!type->hasFixedLength()) {
    cc.report(rmsg::sizeof_indeterminate);
    return 0;
  }

  return type->fixedLength();
}

// Since const is transitive, we require it to be threaded through type
// equivalence tests.
bool
sp::AreTypesEquivalent(Type *a, Type *b, Qualifiers context)
{
  Qualifiers qa = (a->qualifiers() | context);
  Qualifiers qb = (b->qualifiers() | context);
  if (qa != qb)
    return false;

  a = a->canonical();
  b = b->canonical();
  if (a == b)
    return true;

  switch (a->canonicalKind()) {
    case Type::Kind::Primitive:
      // Either |b| is not primitive, or they should not have the same
      // primitive type since each type is a singleton.
      assert(!b->isPrimitive() || a->primitive() != b->primitive());
      return false;
    case Type::Kind::Function:
    {
      if (!b->isFunction())
        return false;

      // const is not transitive through function signatures.
      return AreFunctionTypesEqual(a->toFunction(), b->toFunction());
    }
    case Type::Kind::Array:
    {
      if (!b->isArray())
        return false;

      ArrayType *aa = a->toArray();
      ArrayType *ba = b->toArray();
      while (true) {
        // Both arrays must be either dynamic or have the same fixed size.
        if (aa->hasFixedLength() != ba->hasFixedLength())
          return false;
        if (aa->hasFixedLength() && aa->fixedLength() != ba->fixedLength())
          return false;

        // Both contained types must be the same type.
        Type *innerA = aa->contained();
        Type *innerB = ba->contained();
        if (innerA->isArray() != innerB->isArray())
          return false;
        if (!innerA->isArray()) {
          // const is transitive through arrays.
          if (!AreTypesEquivalent(innerA, innerB, context))
            return false;

          // If neither contained type is an array, we're done.
          break;
        }

        // Re-check qualifiers.
        Qualifiers qa = (innerA->qualifiers() | context);
        Qualifiers qb = (innerB->qualifiers() | context);
        if (qa != qb)
          return false;
      }
      return true;
    }
    // These types have unique instances.
    case Type::Kind::Void:
    case Type::Kind::Unchecked:
    case Type::Kind::MetaFunction:
    // These types are named and must have the same identity.
    case Type::Kind::Struct:
    case Type::Kind::Typeset:
    case Type::Kind::Enum:
      // Handled by a == b check earlier.
      return false;
    default:
      // Should not get Unresolvable, Typedef, or Qualifier here.
      assert(false);
      return false;
  }
}