{

__MCAssertIsTypeInfo(self);

return __MCTypeInfoGetExtendedTypeCode(self) == kMCTypeInfoTypeIsAlias;

{

__MCAssertIsTypeInfo(self);

return __MCTypeInfoGetExtendedTypeCode(self) == kMCTypeInfoTypeIsNamed;

{

__MCAssertIsTypeInfo(self);

return __MCTypeInfoGetExtendedTypeCode(self) == kMCTypeInfoTypeIsOptional;

{

__MCAssertIsTypeInfo(self);

return __MCTypeInfoGetExtendedTypeCode(self) == kMCValueTypeCodeHandler;

{

__MCAssertIsTypeInfo(self);

return __MCTypeInfoGetExtendedTypeCode(self) == kMCValueTypeCodeRecord;

{

__MCAssertIsTypeInfo(self);

return __MCTypeInfoGetExtendedTypeCode(self) == kMCValueTypeCodeError;

{

__MCAssertIsTypeInfo(self);

return __MCTypeInfoGetExtendedTypeCode(self) == kMCTypeInfoTypeIsForeign;

{

__MCAssertIsTypeInfo(self);

return __MCTypeInfoGetExtendedTypeCode(self) == kMCValueTypeCodeCustom;

{

__MCAssertIsTypeInfo(self);

switch(__MCTypeInfoGetExtendedTypeCode(self))

{

case kMCValueTypeCodeNull:

return kMCNull;

case kMCValueTypeCodeBoolean:

return kMCFalse;

case kMCValueTypeCodeNumber:

return kMCZero;

case kMCValueTypeCodeName:

return kMCEmptyName;

case kMCValueTypeCodeString:

return kMCEmptyString;

case kMCValueTypeCodeData:

return kMCEmptyData;

case kMCValueTypeCodeArray:

return kMCEmptyArray;

case kMCValueTypeCodeList:

return kMCEmptyList;

case kMCValueTypeCodeSet:

return kMCEmptySet;

case kMCValueTypeCodeProperList:

return kMCEmptyProperList;

case kMCValueTypeCodeCustom:

return nil;

case kMCValueTypeCodeRecord:

return nil;

case kMCValueTypeCodeHandler:

return nil;

case kMCValueTypeCodeTypeInfo:

return nil;

case kMCValueTypeCodeError:

return nil;

case kMCValueTypeCodeForeignValue:

return nil;

case kMCTypeInfoTypeIsOptional:

return kMCNull;

case kMCTypeInfoTypeIsAlias:

return MCTypeInfoGetDefault(self -> alias . typeinfo);

case kMCTypeInfoTypeIsNamed:

return MCTypeInfoGetDefault(self -> named . typeinfo);

default:

return nil;

}

{

__MCAssertIsTypeInfo(self);

intenum_t t_ext_typecode;

t_ext_typecode = __MCTypeInfoGetExtendedTypeCode(self);

if (t_ext_typecode == kMCTypeInfoTypeIsAlias)

return MCTypeInfoResolve(self -> alias . typeinfo, r_resolution);

if (t_ext_typecode == kMCTypeInfoTypeIsNamed)

{

// Attempt to resolve the binding, this will throw an error if it fails.

MCTypeInfoRef t_next_type = nullptr;

if (!MCNamedTypeInfoResolve(self, t_next_type))

return false;

// We've successfully resolved the type, so return this one as the resolution.

r_resolution . named_type = self;

r_resolution . type = t_next_type;

r_resolution . is_optional = false;

return true;

}

if (t_ext_typecode == kMCTypeInfoTypeIsOptional)

{

if (!MCTypeInfoResolve(self -> optional . basetype, r_resolution))

return false;

r_resolution . is_optional = true;

return true;

}

// Resolving any other form of type, returns the (un-named) naked typeinfo.

r_resolution . is_optional = false;

r_resolution . named_type = nil;

r_resolution . type = self;

return true;

{

// We require that source is concrete for all but handler types (as handlers

// have unnamed typeinfos which we need to compare with potentially named

// handler type typeinfos).

MCAssert(MCTypeInfoIsNamed(source) || MCTypeInfoIsHandler(source) || MCTypeInfoIsOptional(source));

// If the two types are the same, they conform.

if (source == target)

{

return true;

}

// Resolve the source type.

MCResolvedTypeInfo t_resolved_source;

if (!MCTypeInfoResolve(source, t_resolved_source))

{

MCAssert(false);

return false;

}

// We require that target is resolvable.

MCResolvedTypeInfo t_resolved_target;

if (!MCTypeInfoResolve(target, t_resolved_target))

{

MCAssert(false);

return false;

}

return MCResolvedTypeInfoConforms(t_resolved_source, t_resolved_target);

{

// If source and target are the same, we are done - as they are named types.

if (source . named_type != nil &&

source . named_type == target . named_type)

return true;

// If source is undefined, then target must be optional.

if (source . named_type == kMCNullTypeInfo)

return target . is_optional;

// If the target is any, then all is well.

if (target . named_type == kMCAnyTypeInfo)

return true;

// If source is of foreign type then target must be the source's bridge type

// the source type, or one of the source's supertypes.

if (MCTypeInfoIsForeign(source . type))

{

// If both sides are foreign, do they have a bridge type in common?

if (MCTypeInfoIsForeign(target.type))

{

if (source.type->foreign.descriptor.bridgetype != kMCNullTypeInfo &&

source.type->foreign.descriptor.bridgetype == target.type->foreign.descriptor.bridgetype)

return true;

}

// Check to see if the target is the source's bridge type.

if (source . type -> foreign . descriptor . bridgetype != kMCNullTypeInfo &&

target . named_type == source . type -> foreign . descriptor . bridgetype)

return true;

// Now check to see if the target is one of the source's supertypes.

for(MCTypeInfoRef t_supertype = source . type; t_supertype != kMCNullTypeInfo; t_supertype = __MCTypeInfoResolve(t_supertype) -> foreign . descriptor . basetype)

if (target . named_type == t_supertype)

return true;

return false;

}

// If the target is of foreign type, then the source must be the target's

// bridge type.

if (MCTypeInfoIsForeign(target . type))

{

if (target . type -> foreign . descriptor . bridgetype != kMCNullTypeInfo &&

target . type -> foreign . descriptor . bridgetype == source . named_type)

return true;

return false;

}

// If the source is of record type, then the target must be the same type.

if (MCTypeInfoIsRecord(source . type))

{

return false;

}

// If the source is of custom type, then the target must be the same type or

// one of the source's super types.

if (MCTypeInfoIsCustom(source . type))

{

// Now check to see if the target is one of the source's supertypes.

for(MCTypeInfoRef t_supertype = source . type; t_supertype != kMCNullTypeInfo; t_supertype = __MCTypeInfoResolve(t_supertype) -> custom . base)

if (target . named_type == t_supertype)

return true;

return false;

}

// If the source is a handler type then we must check conformance with the

// dst handler type.

if (MCTypeInfoIsHandler(source . type))

{

// If the other type is not a handler, then we are done.

if (!MCTypeInfoIsHandler(target . type))

return false;

// The number of parameters must conform.

if (MCHandlerTypeInfoGetParameterCount(source . type) != MCHandlerTypeInfoGetParameterCount(target . type))

return false;

// The source return type must conform to the target (i.e. the return value

// of the concrete handler, must be assignable to the return value of the

// abstract handler).

if (!MCTypeInfoConforms(MCHandlerTypeInfoGetReturnType(source . type), MCHandlerTypeInfoGetReturnType(target . type)))

return false;

// The modes of each parameter must match, and conformance must correspond to the

// mode.

for(uindex_t i = 0; i < MCHandlerTypeInfoGetParameterCount(source . type); i++)

{

if (MCHandlerTypeInfoGetParameterMode(source . type, i) != MCHandlerTypeInfoGetParameterMode(target . type, i))

return false;

// Out parameters - source must conform to target.

if (MCHandlerTypeInfoGetParameterMode(source . type, i) != kMCHandlerTypeFieldModeOut)

{

if (!MCTypeInfoConforms(MCHandlerTypeInfoGetParameterType(source . type, i), MCHandlerTypeInfoGetParameterType(target . type, i)))

return false;

}

// In parameters - target must conform to source.

if (MCHandlerTypeInfoGetParameterMode(source . type, i) != kMCHandlerTypeFieldModeIn)

{

if (!MCTypeInfoConforms(MCHandlerTypeInfoGetParameterType(target . type, i), MCHandlerTypeInfoGetParameterType(source . type, i)))

return false;

}

}

return true;

}

return false;

{

__MCTypeInfo *self;

if (!__MCValueCreate(kMCValueTypeCodeTypeInfo, self))

return false;

self -> flags |= p_code & 0xff;

if (MCValueInterAndRelease(self, r_typeinfo))

return true;

MCValueRelease(self);

return false;

{

__MCAssertIsName(p_name);

__MCAssertIsTypeInfo(p_target);

__MCTypeInfo *self;

if (!__MCValueCreate(kMCValueTypeCodeTypeInfo, self))

return false;

self -> flags |= kMCTypeInfoTypeIsAlias & 0xff;

self -> alias . name = MCValueRetain(p_name);

self -> alias . typeinfo = MCValueRetain(p_target);

if (MCValueInterAndRelease(self, r_typeinfo))

return true;

MCValueRelease(self);

return false;

{

MCAssert(MCTypeInfoIsAlias(self));

return self -> alias . name;

{

MCAssert(MCTypeInfoIsAlias(self));

return self -> alias . typeinfo;

{

__MCAssertIsName(p_name);

__MCTypeInfo *self;

if (!__MCValueCreate(kMCValueTypeCodeTypeInfo, self))

return false;

self -> flags |= kMCTypeInfoTypeIsNamed & 0xff;

self -> named . name = MCValueRetain(p_name);

// Note that we don't do anything with the 'typeinfo' field of the named typeinfo.

// This is because it does not form part of the uniqueness of the typeinfo, thus

// when we inter we get an existing named typeinfo with the same name.

if (MCValueInterAndRelease(self, r_typeinfo))

return true;

MCValueRelease(self);

return false;

{

MCAssert(MCTypeInfoIsNamed(self));

return self -> named . name;

{

MCAssert(MCTypeInfoIsNamed(self));

return self -> named . typeinfo != nil;

{

MCAssert(MCTypeInfoIsNamed(self));

return self -> named . typeinfo;

{

MCAssert(MCTypeInfoIsNamed(self));

__MCAssertIsTypeInfo(p_target);

if (self -> named . typeinfo != nil)

return MCErrorThrowGenericWithMessage(MCSTR("Can't bind typeinfo %{name}: already bound to %{self}"),

"name", p_target->named.name,

"self", self->named.name,

nullptr);

self -> named . typeinfo = MCValueRetain(p_target);

return true;

{

MCAssert(MCTypeInfoIsNamed(self));

if (self -> named . typeinfo == nil)

return MCErrorThrowGeneric(MCSTR("Can't unbind typeinfo: not bound"));

MCValueRelease(self -> named . typeinfo);

self -> named . typeinfo = nil;

return true;

{

MCAssert(MCTypeInfoIsNamed(self));

if (self -> named . typeinfo == nil)

return MCErrorThrowGeneric(MCSTR("Can't resolve typeinfo: not bound"));

r_bound_type = self -> named . typeinfo;

return true;

{

__MCAssertIsTypeInfo(p_base);

if (__MCTypeInfoGetExtendedTypeCode(p_base) == kMCTypeInfoTypeIsOptional)

{

r_new_type = MCValueRetain(p_base);

return true;

}

__MCTypeInfo *self;

if (!__MCValueCreate(kMCValueTypeCodeTypeInfo, self))

return false;

self -> flags |= kMCTypeInfoTypeIsOptional;

self -> optional . basetype = MCValueRetain(p_base);

if (MCValueInterAndRelease(self, r_new_type))

return true;

MCValueRelease(self);

return false;

{

MCAssert(MCTypeInfoIsOptional(p_base));

return p_base -> optional . basetype;

{

// If the typeinfo has a layout size of size 1, then it is just a value.

if (self -> foreign . descriptor . layout_size == 1)

self -> foreign . ffi_layout_type = __map_primitive_type(self -> foreign . descriptor . layout[0]);

else

{

ffi_type *t_type;

if (!MCMemoryNew(t_type))

return false;

if (!MCMemoryNewArray(self -> foreign . descriptor . layout_size + 1, t_type -> elements))

{

MCMemoryDelete(t_type);

return false;

}

t_type -> alignment = 0;

t_type -> type = FFI_TYPE_STRUCT;

for(uindex_t i = 0; i < self -> foreign . descriptor . layout_size; i++)

t_type -> elements[i] = __map_primitive_type(self -> foreign . descriptor . layout[i]);

t_type -> elements[self -> foreign . descriptor . layout_size] = NULL;

self -> foreign . ffi_layout_type = t_type;

}

return true;

{

MCAssert(nil != p_descriptor);

__MCTypeInfo *self;

if (!__MCValueCreate(kMCValueTypeCodeTypeInfo, self))

return false;

if (!MCMemoryNewArray(p_descriptor -> layout_size, self -> foreign . descriptor . layout, self -> foreign . descriptor . layout_size))

{

MCValueRelease (self);

return false;

}

self -> flags |= kMCTypeInfoTypeIsForeign;

self -> foreign . descriptor . size = p_descriptor -> size;

self -> foreign . descriptor . basetype = MCValueRetain(p_descriptor -> basetype);

self -> foreign . descriptor . bridgetype = MCValueRetain(p_descriptor -> bridgetype);

MCMemoryCopy(self -> foreign . descriptor . layout, p_descriptor -> layout, p_descriptor -> layout_size * sizeof(self -> foreign . descriptor . layout[0]));

self -> foreign . descriptor . initialize = p_descriptor -> initialize;

self -> foreign . descriptor . finalize = p_descriptor -> finalize;

self -> foreign . descriptor . defined = p_descriptor -> defined;

self -> foreign . descriptor . move = p_descriptor -> move;

self -> foreign . descriptor . copy = p_descriptor -> copy;

self -> foreign . descriptor . equal = p_descriptor -> equal;

self -> foreign . descriptor . hash = p_descriptor -> hash;

self -> foreign . descriptor . doimport = p_descriptor -> doimport;

self -> foreign . descriptor . doexport = p_descriptor -> doexport;

self -> foreign . descriptor . describe = p_descriptor -> describe;

self -> foreign . descriptor . promotedtype = MCValueRetain(p_descriptor->promotedtype);

self -> foreign . descriptor . promote = p_descriptor -> promote;

if (!__MCForeignTypeInfoComputeLayoutType(self))

{

MCValueRelease(self);

return false;

}

if (MCValueInterAndRelease(self, r_typeinfo))

return true;

MCValueRelease(self);

return false;

{

MCAssert(nil != p_fields || p_field_count == 0);

/* If the p_field_count < 0 then the p_fields are expected to be

if (p_field_count < 0)

for (p_field_count = 0; p_fields[p_field_count].name != nil; ++p_field_count);

__MCTypeInfo *self;

if (!__MCValueCreate(kMCValueTypeCodeTypeInfo, self))

return false;

if (!MCMemoryNewArray(p_field_count, self -> record . fields))

{

MCMemoryDelete(self);

return false;

}

self -> flags |= kMCValueTypeCodeRecord;

for (index_t i = 0; i < p_field_count; ++i)

{

__MCAssertIsName(p_fields[i].name);

__MCAssertIsTypeInfo(p_fields[i].type);

/* Verify that the field names are all caselessly distinct.

for (index_t j = 0; j < i; ++j)

{

MCAssert(!MCNameIsEqualToCaseless(p_fields[i] . name, p_fields[j] . name));

}

self -> record . fields[i] . name = MCValueRetain(p_fields[i] . name);

self -> record . fields[i] . type = MCValueRetain(p_fields[i] . type);

}

self -> record . field_count = p_field_count;

if (MCValueInterAndRelease(self, r_typeinfo))

return true;

MCValueRelease(self);

return false;

{

MCTypeInfoRef self;

self = __MCTypeInfoResolve(unresolved_self);

MCAssert(MCTypeInfoIsRecord (self));

return __MCRecordTypeInfoGetFieldCount(self);

{

MCTypeInfoRef self;

self = __MCTypeInfoResolve(unresolved_self);

MCAssert((self -> flags & kMCTypeInfoTypeCodeMask) == kMCValueTypeCodeRecord);

MCAssert(p_index < self->record.field_count);

return self -> record . fields[p_index] . name;

{

MCTypeInfoRef self;

self = __MCTypeInfoResolve(unresolved_self);

MCAssert((self -> flags & kMCTypeInfoTypeCodeMask) == kMCValueTypeCodeRecord);

MCAssert(p_index < self->record.field_count);

return self -> record . fields[p_index] . type;

{

__MCAssertIsTypeInfo(p_return_type);

MCAssert(nil != p_fields || 0 == p_field_count);

__MCTypeInfo *self;

if (!__MCValueCreate(kMCValueTypeCodeTypeInfo, self))

return false;

/* If the p_field_count < 0 then the p_fields are expected to be

if (p_field_count < 0)

for (p_field_count = 0; p_fields[p_field_count].type != nil; ++p_field_count);

if (!MCMemoryNewArray(p_field_count, self -> handler . fields))

{

MCMemoryDelete(self);

return false;

}

self -> flags |= kMCValueTypeCodeHandler;

if (p_is_foreign)

self -> flags |= kMCTypeInfoFlagHandlerIsForeign;

for (index_t i = 0; i < p_field_count; ++i)

{

__MCAssertIsTypeInfo(p_fields[i].type);

if (p_fields[i].mode == kMCHandlerTypeFieldModeVariadic)

{

if (i == 0 || p_field_count != i + 1)

{

MCValueRelease(self);

return MCErrorThrowGeneric(MCSTR("Variadic parameter cannot be first, and must be last"));

}

p_field_count = i;

self->flags |= kMCTypeInfoFlagHandlerIsVariadic;

break;

}

self -> handler . fields[i] . type = MCValueRetain(p_fields[i] . type);

self -> handler . fields[i] . mode = p_fields[i] . mode;

}

self -> handler . field_count = p_field_count;

self -> handler . return_type = MCValueRetain(p_return_type);

self -> handler . layout_args= nil;

self -> handler . layouts = nil;

if (MCValueInterAndRelease(self, r_typeinfo))

return true;

MCValueRelease(self);

return false;

{

MCTypeInfoRef self;

self = __MCTypeInfoResolve(unresolved_self);

MCAssert(MCTypeInfoIsHandler(self));

return (self -> flags & kMCTypeInfoFlagHandlerIsForeign) != 0;

{

MCTypeInfoRef self;

self = __MCTypeInfoResolve(unresolved_self);

MCAssert(MCTypeInfoIsHandler(self));

return (self -> flags & kMCTypeInfoFlagHandlerIsVariadic) != 0;

{

MCTypeInfoRef self;

self = __MCTypeInfoResolve(unresolved_self);

MCAssert((self -> flags & kMCTypeInfoTypeCodeMask) == kMCValueTypeCodeHandler);

return self -> handler . return_type;

{

MCTypeInfoRef self;

self = __MCTypeInfoResolve(unresolved_self);

MCAssert((self -> flags & kMCTypeInfoTypeCodeMask) == kMCValueTypeCodeHandler);

return self -> handler . field_count;

{

MCTypeInfoRef self;

self = __MCTypeInfoResolve(unresolved_self);

MCAssert((self -> flags & kMCTypeInfoTypeCodeMask) == kMCValueTypeCodeHandler);

MCAssert(self -> handler . field_count > p_index);

return self -> handler . fields[p_index] . mode;

{

MCTypeInfoRef self;

self = __MCTypeInfoResolve(unresolved_self);

MCAssert((self -> flags & kMCTypeInfoTypeCodeMask) == kMCValueTypeCodeHandler);

MCAssert(self -> handler . field_count > p_index);

return self -> handler . fields[p_index] . type;

{

MCTypeInfoRef self;

self = __MCTypeInfoResolve(unresolved_self);

MCAssert((self -> flags & kMCTypeInfoTypeCodeMask) == kMCValueTypeCodeHandler);

// If a layout for the given ABI already exists, then return it.

for(MCHandlerTypeLayout *t_layout = self -> handler . layouts; t_layout != nil; t_layout = t_layout -> next)

if (t_layout -> abi == p_abi)

{

r_cif = &t_layout -> cif;

return true;

}

// If we haven't computed the layout args yet, do so.

if (self -> handler . layout_args == nil)

{

MCTypeInfoRef t_return_type;

t_return_type = self -> handler . return_type;

MCResolvedTypeInfo t_resolved_return_type;

if (!MCTypeInfoResolve(t_return_type, t_resolved_return_type))

return MCErrorThrowUnboundType(t_return_type);

ffi_type *t_ffi_return_type;

if (t_resolved_return_type.named_type != kMCNullTypeInfo)

{

if (MCTypeInfoIsForeign(t_resolved_return_type . type))

t_ffi_return_type = (ffi_type *)MCForeignTypeInfoGetLayoutType(t_resolved_return_type . type);

else

t_ffi_return_type = &ffi_type_pointer;

}

else

t_ffi_return_type = &ffi_type_void;

uindex_t t_arity;

t_arity = self -> handler . field_count;

// We need arity + 1 ffi_type slots, as we use the first slot to store

// the return type (if any).

MCAutoPointer<ffi_type*[]> t_ffi_arg_types =

new (std::nothrow) ffi_type*[t_arity + 1];

if (!t_ffi_arg_types)

return false;

t_ffi_arg_types[0] = t_ffi_return_type;

for(uindex_t i = 0; i < t_arity; i++)

{

MCTypeInfoRef t_type;

MCHandlerTypeFieldMode t_mode;

t_type = self -> handler . fields[i] . type;

t_mode = self -> handler . fields[i] . mode;

MCResolvedTypeInfo t_resolved_type;

if (!MCTypeInfoResolve(t_type, t_resolved_type))

return MCErrorThrowUnboundType(t_type);

if (t_mode == kMCHandlerTypeFieldModeIn)

{

if (MCTypeInfoIsForeign(t_resolved_type . type))

t_ffi_arg_types[i + 1] = (ffi_type *)MCForeignTypeInfoGetLayoutType(t_resolved_type . type);

else

t_ffi_arg_types[i + 1] = &ffi_type_pointer;

}

else

t_ffi_arg_types[i + 1] = &ffi_type_pointer;

}

self -> handler . layout_args = t_ffi_arg_types.Release();

}

// Now we must create a new layout object.

MCHandlerTypeLayout *t_layout;

if (!MCMemoryAllocate(sizeof(MCHandlerTypeLayout) + sizeof(ffi_cif), t_layout))

return false;

t_layout -> abi = p_abi;

if (ffi_prep_cif((ffi_cif *)&t_layout -> cif, (ffi_abi)p_abi, self -> handler . field_count, self -> handler . layout_args[0], self -> handler . layout_args + 1) != FFI_OK)

{

MCMemoryDeallocate(t_layout);

return MCErrorThrowGeneric(MCSTR("unexpected libffi failure"));

}

t_layout -> next = self -> handler . layouts;

self -> handler . layouts = t_layout;