{

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]);

// Compute the temporary (register) count from scanning the bytecode.

uindex_t t_temporary_count;

t_temporary_count = 0;

byte_t *t_bytecode, *t_bytecode_limit;

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

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

while(t_bytecode != t_bytecode_limit)

{

MCScriptBytecodeOp t_operation;

uindex_t t_arity;

uindex_t t_operands[256];

if (!MCScriptBytecodeIterate(t_bytecode, t_bytecode_limit, t_operation, t_arity, t_operands))

break;

switch(t_operation)

{

case kMCScriptBytecodeOpJump:

// jump <offset>

if (t_arity != 1)

goto invalid_bytecode_error;

// check resolved address is within handler

break;

case kMCScriptBytecodeOpJumpIfFalse:

case kMCScriptBytecodeOpJumpIfTrue:

// jumpiftrue <register>, <offset>

// jumpiffalse <register>, <offset>

if (t_arity != 2)

goto invalid_bytecode_error;

// check resolved address is within handler

t_temporary_count = MCMax(t_temporary_count, t_operands[0] + 1);

break;

case kMCScriptBytecodeOpAssignConstant:

// assignconst <dst>, <index>

if (t_arity != 2)

goto invalid_bytecode_error;

// check index argument is within value pool range

t_temporary_count = MCMax(t_temporary_count, t_operands[0] + 1);

break;

case kMCScriptBytecodeOpAssign:

// assign <dst>, <src>

if (t_arity != 2)

goto invalid_bytecode_error;

t_temporary_count = MCMax(t_temporary_count, t_operands[0] + 1);

t_temporary_count = MCMax(t_temporary_count, t_operands[1] + 1);

break;

case kMCScriptBytecodeOpReturn:

// return

// return <value>

if (t_arity != 0 && t_arity != 1)

goto invalid_bytecode_error;

if (t_arity == 1)

t_temporary_count = MCMax(t_temporary_count, t_operands[0] + 1);

break;

case kMCScriptBytecodeOpInvoke:

// invoke <index>, <result>, [ <arg_1>, ..., <arg_n> ]

if (t_arity < 2)

goto invalid_bytecode_error;

// check index operand is within definition range

// check definition[index] is handler or definition group

// check signature of defintion[index] conforms with invoke arity

for(uindex_t j = 1; j < t_arity; j++)

t_temporary_count = MCMax(t_temporary_count, t_operands[j] + 1);

break;

case kMCScriptBytecodeOpInvokeIndirect:

// invoke *<src>, <result>, [ <arg_1>, ..., <arg_n> ]

if (t_arity < 2)

goto invalid_bytecode_error;

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

t_temporary_count = MCMax(t_temporary_count, t_operands[j] + 1);

break;

case kMCScriptBytecodeOpFetch:

case kMCScriptBytecodeOpStore:

// fetch <dst>, <index>

// store <src>, <index>

if (t_arity != 2)

goto invalid_bytecode_error;

// check definition[index] is variable or handler

// check level is appropriate.

t_temporary_count = MCMax(t_temporary_count, t_operands[0] + 1);

break;

case kMCScriptBytecodeOpAssignList:

// assignlist <dst>, [ <elem_1>, ..., <elem_n> ]

if (t_arity < 1)

goto invalid_bytecode_error;

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

t_temporary_count = MCMax(t_temporary_count, t_operands[j] + 1);

break;

case kMCScriptBytecodeOpAssignArray:

// assignarray <dst>, [ <key_1>, <value_1>, ..., <key_n>, <value_n> ]

if (t_arity < 1)

goto invalid_bytecode_error;

if (t_arity % 2 != 1) // parameters must come in pairs

goto invalid_bytecode_error;

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

{

t_temporary_count = MCMax(t_temporary_count, t_operands[j] + 1);

}

break;

case kMCScriptBytecodeOpReset:

// create <reg_1>, ..., <reg_n>

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

t_temporary_count = MCMax(t_temporary_count, t_operands[j] + 1);

break;

}

}

// check the last instruction is 'return'.

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

if (t_bytecode != t_bytecode_limit)

goto invalid_bytecode_error;

// The total number of slots we need is params (inc result) + temps.

MCTypeInfoRef t_signature;

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

t_handler -> slot_count = MCHandlerTypeInfoGetParameterCount(t_signature) + t_handler -> local_type_count + t_temporary_count;

}

// If the module has context

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}'"),

"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 = (MCHandlerTypeFieldMode)t_type -> parameters[j] . mode;

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;

{

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;

{

MCAutoProperListRef t_props;

if (!MCProperListCreateMutable(&t_props))

return false;

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

if (self -> definitions[self -> exported_definitions[i] . index] -> kind == kMCScriptDefinitionKindProperty)

if (!MCProperListPushElementOntoBack(*t_props, self -> exported_definitions[i] . name))

return false;

if (!MCProperListCopy(*t_props, r_property_names))

return false;

return true;

{

MCScriptPropertyDefinition *t_def;

if (!self -> is_usable)

return false; // TODO - throw error

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

return false; // TODO - throw error

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;

{

MCAutoProperListRef t_events;

if (!MCProperListCreateMutable(&t_events))

return false;

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

if (self -> definitions[self -> exported_definitions[i] . index] -> kind == kMCScriptDefinitionKindEvent)

if (!MCProperListPushElementOntoBack(*t_events, self -> exported_definitions[i] . name))

return false;

if (!MCProperListCopy(*t_events, r_event_names))

return false;

return true;

{

MCScriptEventDefinition *t_def;

if (!self -> is_usable)

return false; // TODO - throw error

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

return false; // TODO - throw error

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

return true;

{

MCAutoProperListRef t_handlers;

if (!MCProperListCreateMutable(&t_handlers))

return false;

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

if (self -> definitions[self -> exported_definitions[i] . index] -> kind == kMCScriptDefinitionKindHandler)

if (!MCProperListPushElementOntoBack(*t_handlers, self -> exported_definitions[i] . name))

return false;

if (!MCProperListCopy(*t_handlers, r_handler_names))

return false;

return true;

{

MCScriptHandlerDefinition *t_def;

if (!self -> is_usable)

return false; // TODO - throw error

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

return false; // TODO - throw error

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

return true;

{

__MCScriptValidateObjectAndKind__(self, kMCScriptObjectKindModule);

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

{

if (self -> definitions[self -> exported_definitions[i] . index] -> kind != kMCScriptDefinitionKindProperty)

continue;

if (!MCNameIsEqualTo(p_property, self -> exported_definitions[i] . name))

continue;

r_definition = static_cast<MCScriptPropertyDefinition *>(self -> definitions[self -> exported_definitions[i] . index]);

return true;

}