{

switch(p_kind)

{

case kMCScriptDefinitionKindNone: return MCSTR("unknown");

case kMCScriptDefinitionKindExternal: return MCSTR("external");

case kMCScriptDefinitionKindType: return MCSTR("type");

case kMCScriptDefinitionKindConstant: return MCSTR("constant");

case kMCScriptDefinitionKindVariable: return MCSTR("variable");

case kMCScriptDefinitionKindHandler: return MCSTR("handler");

case kMCScriptDefinitionKindForeignHandler: return MCSTR("handler");

case kMCScriptDefinitionKindProperty: return MCSTR("property");

case kMCScriptDefinitionKindEvent: return MCSTR("event");

case kMCScriptDefinitionKindSyntax: return MCSTR("syntax");

case kMCScriptDefinitionKindDefinitionGroup: return MCSTR("group");

default:

return MCSTR("unknown");

}

return kMCEmptyString;

{

__MCScriptValidateObjectAndKind__(self, kMCScriptObjectKindModule);

// Release the bits pickle-release doesn't touch.

for(uindex_t i = 0; i < self -> dependency_count; i++)

if (self -> dependencies[i] . instance != nil)

MCScriptReleaseInstance(self -> dependencies[i] . instance);

for(uindex_t i = 0; i < self -> type_count; i++)

if (self -> types[i] -> typeinfo != nil)

MCValueRelease(self -> types[i] -> typeinfo);

for(uindex_t i = 0; i < self -> definition_count; i++)

if (self -> definitions[i] -> kind == kMCScriptDefinitionKindForeignHandler)

{

MCScriptForeignHandlerDefinition *t_def;

t_def = static_cast<MCScriptForeignHandlerDefinition *>(self -> definitions[i]);

}

// Remove ourselves from the context slot owners list.

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

if (s_context_slot_owners[i] == self)

s_context_slot_owners[i] = nil;

// Remove ourselves from the global module list.

if (s_modules == self)

s_modules = self -> next_module;

else

for(MCScriptModule *t_module = s_modules; t_module != nil; t_module = t_module -> next_module)

if (t_module -> next_module == self)

{

t_module -> next_module = self -> next_module;

break;

}

MCPickleRelease(kMCScriptModulePickleInfo, self);

{

for(uindex_t i = 0; i < self -> definition_count; i++)

{

if (self -> definitions[i] -> kind == kMCScriptDefinitionKindVariable)

{

MCScriptVariableDefinition *t_variable;

t_variable = static_cast<MCScriptVariableDefinition *>(self -> definitions[i]);

t_variable -> slot_index = self -> slot_count++;

}

else if (self -> definitions[i] -> kind == kMCScriptDefinitionKindHandler)

{

MCScriptHandlerDefinition *t_handler;

t_handler = static_cast<MCScriptHandlerDefinition *>(self -> definitions[i]);

MCScriptValidateState t_state;

t_state.error = false;

t_state.module = self;

t_state.handler = t_handler;

MCTypeInfoRef t_signature;

t_signature = self -> types[t_handler -> type] -> typeinfo;

t_state.register_limit = MCHandlerTypeInfoGetParameterCount(t_signature) +

t_handler -> local_type_count;

const byte_t *t_bytecode;

const byte_t *t_bytecode_limit;

t_bytecode = self -> bytecode + t_handler -> start_address;

t_bytecode_limit = self -> bytecode + t_handler -> finish_address;

// If there is no bytecode, the bytecode is malformed.

if (t_bytecode == t_bytecode_limit)

goto invalid_bytecode_error;

while(t_bytecode != t_bytecode_limit)

{

t_state.current_address = uindex_t(t_bytecode - self-> bytecode);

if (!MCScriptBytecodeIterate(t_bytecode,

t_bytecode_limit,

t_state.operation,

t_state.argument_count,

t_state.arguments))

{

t_state.error = true;

break;

}

if (t_state.operation > kMCScriptBytecodeOp__Last)

{

t_state.error = true;

break;

}

MCScriptBytecodeValidate(t_state);

if (t_state.error)

{

break;

}

}

// If validation failed for a single operation, the bytecode is

// malformed.

if (t_state.error)

goto invalid_bytecode_error;

// If we didn't reach the limit, the bytecode is malformed.

if (t_bytecode != t_bytecode_limit)

goto invalid_bytecode_error;

// If the last operation was not return, the bytecode is malformed.

if (t_state.operation != kMCScriptBytecodeOpReturn)

goto invalid_bytecode_error;

// The total number of slots we need is recorded in register_limit.

t_handler -> slot_count = t_state.register_limit;

}

}

return true;

invalid_bytecode_error:

return MCErrorThrowGenericWithMessage(MCSTR("%{name} is not valid - malformed bytecode"),

"name", self -> name,

nil);

{

__MCScriptValidateObjectAndKind__(self, kMCScriptObjectKindModule);

return (MCScriptModuleRef)MCScriptRetainObject(self);

{

if (nil == self)

return;

__MCScriptValidateObjectAndKind__(self, kMCScriptObjectKindModule);

MCScriptReleaseObject(self);

{

if (nil == self)

return 0;

__MCScriptValidateObjectAndKind__(self, kMCScriptObjectKindModule);

return MCScriptGetRetainCountOfObject(self);

{

uint8_t t_header[4];

if (!MCStreamRead(stream, t_header, 4))

return false;

// If this fails, then it definitely isn't a LiveCode module.

if (t_header[0] != 'L' ||

t_header[1] != 'C')

return MCErrorThrowGeneric(MCSTR("not a module"));

// If this fails, then it is a potentially a LiveCode module, but in a format

// we do not support.

if (t_header[2] != ((kMCScriptCurrentModuleVersion >> 0) & 0xFF) ||

t_header[3] != ((kMCScriptCurrentModuleVersion >> 8) & 0xFF))

return MCErrorThrowGeneric(MCSTR("module format not supported"));

// If this fails then we've run out of memory (oh well - not much to be done!).

MCScriptModule *t_module;

if (!MCScriptCreateObject(kMCScriptObjectKindModule, sizeof(MCScriptModule), (MCScriptObject*&)t_module))

return false;

// If the unpickling fails, there's nothing we can do.

if (!MCPickleRead(stream, kMCScriptModulePickleInfo, t_module))

{

MCScriptDestroyObject(t_module);

// If there is a pending error then its out of memory, otherwise report

// that we haven't been able to unpickle.

if (!MCErrorIsPending())

return MCErrorThrowGeneric(MCSTR("error reading module"));

return false;

}

// If there is already a module with the same name in memory, there's nothing we can do.

for(MCScriptModule *t_other_module = s_modules; t_other_module != nil; t_other_module = t_other_module -> next_module)

if (MCNameIsEqualTo(t_other_module -> name, t_module -> name))

{

MCScriptDestroyObject(t_module);

return MCErrorThrowGeneric(MCSTR("module already loaded"));

}

// Link our module into the global module list.

t_module -> next_module = s_modules;

s_modules = t_module;

// Return the shiny new module.

r_module = t_module;

return true;

MCScriptModuleRef & r_module)

{

MCAutoValueRefBase<MCStreamRef> t_stream;

MCAutoScriptModuleRef t_module;

if (!MCMemoryInputStreamCreate (MCDataGetBytePtr (data),

MCDataGetLength (data),

&t_stream))

return false;

if (!MCScriptCreateModuleFromStream (*t_stream, &t_module))

return false;

r_module = MCScriptRetainModule (*t_module);

return true;

{

for(MCScriptModule *t_module = s_modules; t_module != nil; t_module = t_module -> next_module)

if (MCNameIsEqualTo(p_name, t_module -> name))

{

r_module = t_module;

return true;

}

return false;

{

// If the module has already been ensured as usable, we are done.

if (self -> is_usable)

return true;

/* If the module is already marked as being checked for usability,

if (self -> is_in_usable_check)

return MCErrorThrowGeneric(MCSTR("cyclic module dependency"));

self -> is_in_usable_check = true;

// First ensure we can resolve all its external dependencies.

for(uindex_t i = 0; i < self -> dependency_count; i++)

{

MCScriptModuleRef t_module;

if (!MCScriptLookupModule(self -> dependencies[i] . name, t_module))

{

MCErrorThrowGenericWithMessage(MCSTR("%{name} not usable - dependent module not found %{dependency}"),

"name", self -> name,

"dependency", self -> dependencies[i] . name,

nil);

goto error_cleanup;

}

// A used module must not be a widget.

if (t_module -> module_kind == kMCScriptModuleKindWidget)

{

MCErrorThrowGenericWithMessage(MCSTR("%{name} not usable - depends on widget module %{dependency}"),

"name", self -> name,

"dependency", self -> dependencies[i] . name,

nil);

goto error_cleanup;

}

// A used module must be usable - do this before resolving imports so

// chained imports work.

if (!MCScriptEnsureModuleIsUsable(t_module))

goto error_cleanup;

// Check all the imported definitions from the module, and compute indicies.

for(uindex_t t_import = 0; t_import < self -> imported_definition_count; t_import++)

{

MCScriptImportedDefinition *t_import_def;

t_import_def = &self -> imported_definitions[t_import];

if (t_import_def -> module != i)

continue;

MCScriptDefinition *t_def;

if (!MCScriptLookupDefinitionInModule(t_module, t_import_def -> name, t_def))

{

MCErrorThrowGenericWithMessage(MCSTR("%{name} not usable - %{dependency}.%{definition} not found"),

"name", self -> name,

"dependency", self -> dependencies[i] . name,

"definition", t_import_def -> name,

nil);

goto error_cleanup;

}

MCScriptModuleRef t_mod;

if (t_def -> kind == kMCScriptDefinitionKindExternal)

{

MCScriptExternalDefinition *t_ext_def;

t_ext_def = static_cast<MCScriptExternalDefinition *>(t_def);

t_mod = t_module -> imported_definitions[t_ext_def -> index] . resolved_module;

t_def = t_module -> imported_definitions[t_ext_def -> index] . resolved_definition;

}

else

t_mod = t_module;

if (t_def -> kind != t_import_def -> kind)

{

if (t_import_def -> kind != kMCScriptDefinitionKindHandler ||

t_def -> kind != kMCScriptDefinitionKindForeignHandler)

{

MCErrorThrowGenericWithMessage(MCSTR("%{name} not usable - %{dependency}.%{definition} expected to be %{expected}, but is %{actual}"),

"name", self -> name,

"dependency", self -> dependencies[i] . name,

"definition", t_import_def -> name,

"expected", __MCScriptDefinitionKindToString(t_import_def -> kind),

"actual", __MCScriptDefinitionKindToString(t_def -> kind),

nil);

goto error_cleanup;

}

}

// Check that signatures match.

t_import_def -> resolved_definition = t_def;

t_import_def -> resolved_module = t_mod;

}

// Now create the instance we need - if this fails its due to out of memory.

if (!MCScriptCreateInstanceOfModule(t_module, self -> dependencies[i] . instance))

goto error_cleanup;

}

// Now build all the typeinfo's

for(uindex_t i = 0; i < self -> type_count; i++)

{

MCAutoTypeInfoRef t_typeinfo;

switch(self -> types[i] -> kind)

{

case kMCScriptTypeKindDefined:

{

MCScriptDefinedType *t_type;

t_type = static_cast<MCScriptDefinedType *>(self -> types[i]);

MCScriptDefinition *t_def;

t_def = self -> definitions[t_type -> index];

if (t_def -> kind == kMCScriptDefinitionKindType)

{

MCNameRef t_public_name;

t_public_name = nil;

for(uindex_t j = 0; j < self -> exported_definition_count; j++)

if (self -> exported_definitions[j] . index == t_type -> index)

{

t_public_name = self -> exported_definitions[j] . name;

break;

}

MCScriptTypeDefinition *t_type_def;

t_type_def = static_cast<MCScriptTypeDefinition *>(t_def);

if (t_public_name != nil)

{

MCAutoStringRef t_name_string;

if (!MCStringFormat(&t_name_string, "%@.%@", self -> name, t_public_name))

goto error_cleanup; // oom

MCNewAutoNameRef t_name;

if (!MCNameCreate(*t_name_string, &t_name))

goto error_cleanup; // oom

// If the target type is an alias, named type or optional type then

// we just create an alias. Otherwise it must be a record, foreign,

// handler type - this means it must be named.

MCTypeInfoRef t_target_type;

t_target_type = self -> types[t_type_def -> type] -> typeinfo;

if (MCTypeInfoIsAlias(t_target_type) ||

MCTypeInfoIsNamed(t_target_type) ||

MCTypeInfoIsOptional(t_target_type))

{

if (!MCAliasTypeInfoCreate(*t_name, t_target_type, &t_typeinfo))

goto error_cleanup; // oom

}

else

{

if (!MCNamedTypeInfoCreate(*t_name, &t_typeinfo))

goto error_cleanup; // oom

if (!MCNamedTypeInfoBind(*t_typeinfo, t_target_type))

goto error_cleanup; // oom

}

}

else

{

if (!MCAliasTypeInfoCreate(kMCEmptyName, self -> types[t_type_def -> type] -> typeinfo, &t_typeinfo))

goto error_cleanup; // oom

}

}

else if (t_def -> kind == kMCScriptDefinitionKindExternal)

{

MCScriptExternalDefinition *t_ext_def;

t_ext_def = static_cast<MCScriptExternalDefinition *>(t_def);

MCScriptImportedDefinition *t_import;

t_import = &self -> imported_definitions[t_ext_def -> index];

MCScriptModuleRef t_module;

t_module = t_import -> resolved_module;

t_typeinfo = t_module -> types[static_cast<MCScriptTypeDefinition *>(t_import -> resolved_definition) -> type] -> typeinfo;

}

else

goto error_cleanup;

}

break;

case kMCScriptTypeKindOptional:

{

MCScriptOptionalType *t_type;

t_type = static_cast<MCScriptOptionalType *>(self -> types[i]);

if (!MCOptionalTypeInfoCreate(self -> types[t_type -> type] -> typeinfo, &t_typeinfo))

goto error_cleanup; // oom

}

break;

case kMCScriptTypeKindForeign:

{

MCScriptForeignType *t_type;

t_type = static_cast<MCScriptForeignType *>(self -> types[i]);

void *t_symbol;

#ifdef _WIN32

t_symbol = GetProcAddress(GetModuleHandle(NULL), MCStringGetCString(t_type -> binding));

#elif defined(__EMSCRIPTEN__)

void *t_handle = dlopen(NULL, RTLD_LAZY);

t_symbol = dlsym(t_handle, MCStringGetCString(t_type->binding));

dlclose(t_handle);

#else

t_symbol = dlsym(RTLD_DEFAULT, MCStringGetCString(t_type -> binding));

#endif

if (t_symbol == nil)

{

MCErrorThrowGenericWithMessage(MCSTR("%{name} not usable - unable to resolve foreign type '%{type}'"),

"name", self -> name,

"type", t_type -> binding,

nil);

goto error_cleanup;

}

/* The symbol is a function that returns a type info reference. */

MCTypeInfoRef (*t_type_func)(void) = (MCTypeInfoRef (*)(void)) t_symbol;

t_typeinfo = MCValueRetain(t_type_func());

}

break;

case kMCScriptTypeKindRecord:

{

MCScriptRecordType *t_type;

t_type = static_cast<MCScriptRecordType *>(self -> types[i]);

MCAutoArray<MCRecordTypeFieldInfo> t_fields;

for(uindex_t j = 0; j < t_type -> field_count; j++)

{

MCRecordTypeFieldInfo t_field;

t_field . name = t_type -> fields[j] . name;

t_field . type = self -> types[t_type -> fields[j] . type] -> typeinfo;

if (!t_fields . Push(t_field))

goto error_cleanup; // oom

}

if (!MCRecordTypeInfoCreate(t_fields . Ptr(), t_type -> field_count, self -> types[t_type -> base_type] -> typeinfo, &t_typeinfo))

goto error_cleanup; // oom

}

break;

case kMCScriptTypeKindHandler:

case kMCScriptTypeKindForeignHandler:

{

MCScriptHandlerType *t_type;

t_type = static_cast<MCScriptHandlerType *>(self -> types[i]);

MCAutoArray<MCHandlerTypeFieldInfo> t_parameters;

for(uindex_t j = 0; j < t_type -> parameter_count; j++)

{

MCHandlerTypeFieldInfo t_parameter;

t_parameter . mode = t_type -> parameters[j] . GetFieldMode();

t_parameter . type = self -> types[t_type -> parameters[j] . type] -> typeinfo;

if (!t_parameters . Push(t_parameter))

goto error_cleanup;

}

if (t_type -> kind == kMCScriptTypeKindHandler)

{

if (!MCHandlerTypeInfoCreate(t_parameters . Ptr(), t_type -> parameter_count, self -> types[t_type -> return_type] -> typeinfo, &t_typeinfo))

goto error_cleanup; // oom

}

else

{

if (!MCForeignHandlerTypeInfoCreate(t_parameters . Ptr(), t_type -> parameter_count, self -> types[t_type -> return_type] -> typeinfo, &t_typeinfo))

goto error_cleanup; // oom

}

}

break;

}

self -> types[i] -> typeinfo = MCValueRetain(*t_typeinfo);

}

// First validate the module - if this fails we do nothing more.

if (!MCScriptValidateModule(self))

goto error_cleanup;

// Now bind all the public types.

self -> is_usable = true;

self -> is_in_usable_check = false;

return true;

error_cleanup:

self -> is_in_usable_check = false;

return false;

MCScriptDefinitionKind p_kind,

/* copy */ MCProperListRef& r_names)

{

MCAutoProperListRef t_names;

if (!MCProperListCreateMutable(&t_names))

{

return false;

}

for(uindex_t i = 0; i < self -> exported_definition_count; i++)

{

MCScriptDefinition *t_definition =

self->definitions[self->exported_definitions[i].index];

if (p_kind != kMCScriptDefinitionKindNone &&

t_definition->kind != p_kind)

{

continue;

}

if (!MCProperListPushElementOntoBack(*t_names,

self->exported_definitions[i].name))

{

return false;

}

}

if (!t_names.MakeImmutable())

{

return false;

}

r_names = t_names.Take();

return true;

{

MCAutoProperListRef t_modules;

if (!MCProperListCreateMutable(&t_modules))

return false;

for(uindex_t i = 0; i < self -> dependency_count; i++)

if (!MCProperListPushElementOntoBack(*t_modules, self -> dependencies[i] . name))

return false;

if (!MCProperListCopy(*t_modules, r_module_names))

return false;

return true;

{

return __MCScriptCopyDefinitionsOfModule(self,

kMCScriptDefinitionKindConstant,

r_constant_names);

{

MCScriptConstantDefinition *t_constant_def = nil;

if (!self -> is_usable)

return false;

if (!MCScriptLookupConstantDefinitionInModule(self,

p_constant,

t_constant_def))

{

return false;

}

r_constant_value = self->values[t_constant_def->value];

return true;

{

return __MCScriptCopyDefinitionsOfModule(self,

kMCScriptDefinitionKindProperty,

r_property_names);

{

MCScriptPropertyDefinition *t_def;

if (!self -> is_usable)

return false;

if (!MCScriptLookupPropertyDefinitionInModule(self, p_property, t_def))

return false;

MCScriptDefinition *t_getter;

t_getter = t_def -> getter != 0 ? self -> definitions[t_def -> getter - 1] : nil;

if (t_getter != nil)

{

if (t_getter -> kind == kMCScriptDefinitionKindVariable)

r_getter = self -> types[static_cast<MCScriptVariableDefinition *>(t_getter) -> type] -> typeinfo;

else

r_getter = MCHandlerTypeInfoGetReturnType(self -> types[static_cast<MCScriptHandlerDefinition *>(t_getter) -> type] -> typeinfo);

}

else

r_getter = nil;

MCScriptDefinition *t_setter;

t_setter = t_def -> setter != 0 ? self -> definitions[t_def -> setter - 1] : nil;

if (t_setter != nil)

{

if (t_setter -> kind == kMCScriptDefinitionKindVariable)

r_setter = self -> types[static_cast<MCScriptVariableDefinition *>(t_setter) -> type] -> typeinfo;

else

r_setter = MCHandlerTypeInfoGetParameterType(self -> types[static_cast<MCScriptHandlerDefinition *>(t_setter) -> type] -> typeinfo, 0);

}

else

r_setter = nil;

return true;

{

return __MCScriptCopyDefinitionsOfModule(self,

kMCScriptDefinitionKindEvent,

r_event_names);

{

MCScriptEventDefinition *t_def;

if (!self -> is_usable)

return false;

if (!MCScriptLookupEventDefinitionInModule(self, p_event, t_def))

return false;

r_signature = self -> types[t_def -> type] -> typeinfo;

return true;

{

return __MCScriptCopyDefinitionsOfModule(self,

kMCScriptDefinitionKindHandler,

r_handler_names);

{

MCScriptHandlerDefinition *t_def;

if (!self -> is_usable)

return false;

if (!MCScriptLookupHandlerDefinitionInModule(self, p_handler, t_def))

return false;

r_signature = self -> types[t_def -> type] -> typeinfo;

return true;

{

MCScriptHandlerDefinition *t_def;

if (!self -> is_usable)

{

return false;

}

if (!MCScriptLookupHandlerDefinitionInModule(self, p_handler, t_def))

{

return false;

}

MCAutoProperListRef t_names;

if (!MCProperListCreateMutable(&t_names))

{

return false;

}

for(uindex_t i = 0; i < MCHandlerTypeInfoGetParameterCount(self->types[t_def->type]->typeinfo); i++)

{

if (!MCProperListPushElementOntoBack(*t_names,

MCScriptGetNameOfParameterInModule(self,

t_def,

i)))

{

return false;

}

}

r_names = t_names.Take();

return true;

MCNameRef p_name,