/* Copyright (C) 2003-2015 LiveCode Ltd.

This file is part of LiveCode.

LiveCode is free software; you can redistribute it and/or modify it under

the terms of the GNU General Public License v3 as published by the Free

Software Foundation.

LiveCode is distributed in the hope that it will be useful, but WITHOUT ANY

WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License

for more details.

You should have received a copy of the GNU General Public License

along with LiveCode. If not see <http://www.gnu.org/licenses/>. */

#include "libscript/script.h"

#include "script-private.h"

#include "ffi.h"

#include "foundation-auto.h"

#ifdef _WIN32

#include <windows.h>

#else

#include <dlfcn.h>

#endif

////////////////////////////////////////////////////////////////////////////////

// This context struct, callbacks and associated functions provide an implementation

// of MCHandler for handlers coming from libscript. It enables an MCHandlerRef

// created from within LCB to be used 'out-of-frame' - i.e. not just from direct

// invocation within the LCB VM.

struct __MCScriptHandlerContext

{

MCScriptInstanceRef instance;

MCScriptCommonHandlerDefinition *definition;

};

extern MCHandlerCallbacks __kMCScriptHandlerCallbacks;

bool __MCScriptHandlerInvoke(void *context, MCValueRef *p_arguments, uindex_t p_argument_count, MCValueRef& r_value);

void __MCScriptHandlerRelease(void *context);

bool __MCScriptHandlerDescribe(void *context, MCStringRef &r_desc);

////////////////////////////////////////////////////////////////////////////////

template <typename WORD, size_t LENGTH>

class __MCScriptStackStorage

{

public:

__MCScriptStackStorage()

: m_used(0)

{

}

void *Allocate(size_t p_request)

{

/* Ensure the amount allocated is aligned to the word size */

size_t t_amount = (~(sizeof(WORD)-1)) & ((sizeof(WORD)-1) + p_request);

MCAssert(t_amount % sizeof(WORD) == 0);

MCAssert(t_amount >= p_request);

/* Ensure there's enough space left in the storage */

MCAssert(m_used + t_amount < sizeof(m_storage));

/* Create and return the pointer, updating the current offset */

MCAssert(m_used % sizeof(WORD) == 0);

void *t_ptr = &m_storage[m_used / sizeof(WORD)];

m_used += t_amount;

return t_ptr;

}

private:

WORD m_storage[LENGTH];

size_t m_used;

};

#if defined(__EMSCRIPTEN__)

/* On emscripten, we require double alignment */

typedef __MCScriptStackStorage<double,32> MCScriptStackStorage;

#else

typedef __MCScriptStackStorage<void *,32> MCScriptStackStorage;

#endif

////////////////////////////////////////////////////////////////////////////////

// This is the module of the most recent LCB stack frame on the current thread's

// stack. It is set before and after a foreign handler call so that the native

// code can get some element of context.

static MCScriptModuleRef s_current_module = nil;

////////////////////////////////////////////////////////////////////////////////

bool MCScriptCreateInstanceOfModule(MCScriptModuleRef p_module, MCScriptInstanceRef& r_instance)

{

bool t_success;

t_success = true;

MCScriptInstanceRef t_instance;

t_instance = nil;

// If the module is not usable, then we cannot create an instance.

if (t_success)

if (!p_module -> is_usable)

return false;

// If this is a module which shares a single instance, then return that if we have

// one.

if (p_module -> module_kind != kMCScriptModuleKindWidget &&

p_module -> shared_instance != nil)

{

r_instance = MCScriptRetainInstance(p_module -> shared_instance);

return true;

}

// Attempt to create a script object.

if (t_success)

t_success = MCScriptCreateObject(kMCScriptObjectKindInstance, sizeof(MCScriptInstance), (MCScriptObject*&)t_instance);

// Now associate the script object with the module (so the 'slots' field make sense).

if (t_success)

{

t_instance -> module = MCScriptRetainModule(p_module);

}

// Now allocate the slots field.

if (t_success)

t_success = MCMemoryNewArray(p_module -> slot_count, t_instance -> slots);

if (t_success)

{

/* Loop over all of the variables of the module, initialising

* the corresponding slot to a default value of the

* appropriate type, if available. */

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

{

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

continue; /* Not a variable */

MCScriptVariableDefinition *t_variable =

static_cast<MCScriptVariableDefinition *>(p_module->definitions[i]);

uindex_t t_slot_index = t_variable->slot_index;

/* COMPUTE CHECK */ __MCScriptAssert__(t_slot_index < p_module->slot_count,

"computed variable slot out of range");

MCTypeInfoRef t_type = p_module->types[t_variable->type]->typeinfo;

if (nil == t_type)

continue; /* Variable is untyped */

MCValueRef t_default = MCTypeInfoGetDefault(t_type);

if (nil == t_default)

continue; /* Type has no default value */

t_instance->slots[t_slot_index] = MCValueRetain(t_default);

}

// If this is a module which shares its instance, then add a link to it.

// (Note this is weak reference - we don't retain, otherwise we would have

// a cycle!).

if (p_module -> module_kind != kMCScriptModuleKindWidget)

p_module -> shared_instance = t_instance;

r_instance = t_instance;

}

else

MCScriptDestroyObject(t_instance);

return t_success;

}

void MCScriptDestroyInstance(MCScriptInstanceRef self)

{

__MCScriptValidateObjectAndKind__(self, kMCScriptObjectKindInstance);

// If the object had slots initialized, then free them.

if (self -> slots != nil)

{

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

MCValueRelease(self -> slots[i]);

MCMemoryDeleteArray(self -> slots);

}

// If the instance has handler-refs, then free them.

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

MCValueRelease(self -> handlers[i] . value);

MCMemoryDeleteArray(self -> handlers);

// If the instance has a module, and this is the shared instance then set

// the shared instance field to nil.

if (self -> module != nil &&

self -> module -> shared_instance == self)

self -> module -> shared_instance = nil;

// If the instance was associated with its module, then release it.

if (self -> module != nil)

MCScriptReleaseModule(self -> module);

// The rest of the deallocation is handled by MCScriptDestroyObject.

}

////////////////////////////////////////////////////////////////////////////////

MCScriptInstanceRef MCScriptRetainInstance(MCScriptInstanceRef self)

{

__MCScriptValidateObjectAndKind__(self, kMCScriptObjectKindInstance);

return (MCScriptInstanceRef)MCScriptRetainObject(self);

}

void MCScriptReleaseInstance(MCScriptInstanceRef self)

{

if (nil == self)

return;

__MCScriptValidateObjectAndKind__(self, kMCScriptObjectKindInstance);

MCScriptReleaseObject(self);

}

////////////////////////////////////////////////////////////////////////////////

MCScriptModuleRef MCScriptGetModuleOfInstance(MCScriptInstanceRef self)

{

return self -> module;

}

////////////////////////////////////////////////////////////////////////////////

MCScriptVariableDefinition *MCScriptDefinitionAsVariable(MCScriptDefinition *self)

{

__MCScriptAssert__(self -> kind == kMCScriptDefinitionKindVariable,

"definition not a variable");

return static_cast<MCScriptVariableDefinition *>(self);

}

MCScriptHandlerDefinition *MCScriptDefinitionAsHandler(MCScriptDefinition *self)

{

__MCScriptAssert__(self -> kind == kMCScriptDefinitionKindHandler,

"definition not a handler");

return static_cast<MCScriptHandlerDefinition *>(self);

}

MCScriptForeignHandlerDefinition *MCScriptDefinitionAsForeignHandler(MCScriptDefinition *self)

{

__MCScriptAssert__(self -> kind == kMCScriptDefinitionKindForeignHandler,

"definition not a foreign handler");

return static_cast<MCScriptForeignHandlerDefinition *>(self);

}

MCScriptDefinitionGroupDefinition *MCScriptDefinitionAsDefinitionGroup(MCScriptDefinition *self)

{

__MCScriptAssert__(self -> kind == kMCScriptDefinitionKindDefinitionGroup,

"definition not a definition group");

return static_cast<MCScriptDefinitionGroupDefinition *>(self);

}

////////////////////////////////////////////////////////////////////////////////

static bool MCHandlerTypeInfoConformsToPropertyGetter(MCTypeInfoRef typeinfo)

{

return MCHandlerTypeInfoGetParameterCount(typeinfo) == 0 &&

MCHandlerTypeInfoGetReturnType(typeinfo) != kMCNullTypeInfo;

}

static bool MCHandlerTypeInfoConformsToPropertySetter(MCTypeInfoRef typeinfo)

{

return MCHandlerTypeInfoGetParameterCount(typeinfo) == 1 &&

MCHandlerTypeInfoGetParameterMode(typeinfo, 0) == kMCHandlerTypeFieldModeIn;

}

////////////////////////////////////////////////////////////////////////////////

//

// ERROR PROPAGATORS

//

static bool MCScriptThrowAttemptToSetReadOnlyPropertyError(MCScriptModuleRef p_module, MCNameRef p_property)

{

return MCErrorCreateAndThrow(kMCScriptCannotSetReadOnlyPropertyErrorTypeInfo,

"module",

p_module -> name,

"property",

p_property,

nil);

}

static bool MCScriptThrowInvalidValueForPropertyError(MCScriptModuleRef p_module, MCNameRef p_property, MCTypeInfoRef p_expected_type, MCValueRef p_value)

{

return MCErrorCreateAndThrow(kMCScriptInvalidPropertyValueErrorTypeInfo,

"module",

p_module -> name,

"property",

p_property,

"type",

MCNamedTypeInfoGetName(p_expected_type),

"value",

p_value,

nil);

}

static bool MCScriptThrowInvalidValueForResultError(MCScriptModuleRef p_module, MCScriptDefinition *p_handler, MCTypeInfoRef p_expected_type, MCValueRef p_value)

{

return MCErrorCreateAndThrow(kMCScriptInvalidReturnValueErrorTypeInfo,

"module",

p_module -> name,

"handler",

MCScriptGetNameOfDefinitionInModule(p_module, p_handler),

"type",

MCNamedTypeInfoGetName(p_expected_type),

"value",

p_value,

nil);

}

static bool MCScriptThrowInParameterNotDefinedError(MCScriptModuleRef p_module, MCScriptDefinition *p_handler, uindex_t p_index)

{

return MCErrorCreateAndThrow(kMCScriptInParameterNotDefinedErrorTypeInfo,

"module",

p_module -> name,

"handler",

MCScriptGetNameOfDefinitionInModule(p_module, p_handler),

"parameter",

MCScriptGetNameOfParameterInModule(p_module, p_handler, p_index),

nil);

}

static bool MCScriptThrowOutParameterNotDefinedError(MCScriptModuleRef p_module, MCScriptDefinition *p_handler, uindex_t p_index)

{

return MCErrorCreateAndThrow(kMCScriptOutParameterNotDefinedErrorTypeInfo,

"module",

p_module -> name,

"handler",

MCScriptGetNameOfDefinitionInModule(p_module, p_handler),

"parameter",

MCScriptGetNameOfParameterInModule(p_module, p_handler, p_index),

nil);

}

static bool MCScriptThrowLocalVariableUsedBeforeDefinedError(MCScriptModuleRef p_module, MCScriptDefinition *p_handler, uindex_t p_index)

{

return MCErrorCreateAndThrow(kMCScriptVariableUsedBeforeDefinedErrorTypeInfo,

"module",

p_module -> name,

"handler",

MCScriptGetNameOfDefinitionInModule(p_module, p_handler),

"variable",

MCScriptGetNameOfLocalVariableInModule(p_module, p_handler, p_index),

nil);

}

static bool MCScriptThrowGlobalVariableUsedBeforeDefinedError(MCScriptModuleRef p_module, MCScriptVariableDefinition *p_definition)

{

return MCErrorCreateAndThrow(kMCScriptVariableUsedBeforeDefinedErrorTypeInfo,

"module",

p_module -> name,

"variable",

MCScriptGetNameOfDefinitionInModule(p_module, p_definition),

nil);

}

static bool MCScriptThrowInvalidValueForLocalVariableError(MCScriptModuleRef p_module, MCScriptDefinition *p_handler, uindex_t p_index, MCTypeInfoRef p_expected_type, MCValueRef p_value)

{

return MCErrorCreateAndThrow(kMCScriptInvalidVariableValueErrorTypeInfo,

"module",

p_module -> name,

"handler",

MCScriptGetNameOfDefinitionInModule(p_module, p_handler),

"variable",

MCScriptGetNameOfLocalVariableInModule(p_module, p_handler, p_index),

"type",

MCNamedTypeInfoGetName(p_expected_type),

"value",

p_value,

nil);

}

static bool MCScriptThrowInvalidValueForGlobalVariableError(MCScriptModuleRef p_module, MCScriptVariableDefinition *p_index, MCTypeInfoRef p_expected_type, MCValueRef p_value)

{

return MCErrorCreateAndThrow(kMCScriptInvalidVariableValueErrorTypeInfo,

"module",

p_module -> name,

"variable",

MCScriptGetNameOfDefinitionInModule(p_module, p_index),

"type",

MCNamedTypeInfoGetName(p_expected_type),

"value",

p_value,

nil);

}

static bool MCScriptThrowNotABooleanError(MCValueRef p_value)

{

return MCErrorCreateAndThrow(kMCScriptNotABooleanValueErrorTypeInfo,

"value",

p_value,

nil);

}

static bool MCScriptThrowNotAStringError(MCValueRef p_value)

{

return MCErrorCreateAndThrow(kMCScriptNotAStringValueErrorTypeInfo,

"value",

p_value,

nil);

}

static bool MCScriptThrowWrongNumberOfArgumentsForInvokeError(MCScriptModuleRef p_module, MCScriptDefinition *p_definition, uindex_t p_provided)

{

// TODO: Encode provided / expected.

return MCErrorCreateAndThrow(kMCScriptWrongNumberOfArgumentsErrorTypeInfo,

"module",

p_module -> name,

"handler",

MCScriptGetNameOfDefinitionInModule(p_module, p_definition),

nil);

}

static bool MCScriptThrowInvalidValueForArgumentError(MCScriptModuleRef p_module, MCScriptDefinition *p_definition, uindex_t p_arg_index, MCTypeInfoRef p_expected_type, MCValueRef p_value)

{

return MCErrorCreateAndThrow(kMCScriptInvalidArgumentValueErrorTypeInfo,

"module",

p_module -> name,

"handler",

MCScriptGetNameOfDefinitionInModule(p_module, p_definition),

"parameter",

MCScriptGetNameOfParameterInModule(p_module, p_definition, p_arg_index),

"type",

MCNamedTypeInfoGetName(p_expected_type),

"value",

p_value,

nil);

}

static bool MCScriptThrowUnableToResolveForeignHandlerError(MCScriptModuleRef p_module, MCScriptDefinition *p_definition)

{

return MCErrorCreateAndThrow(kMCScriptForeignHandlerBindingErrorTypeInfo,

"module",

p_module -> name,

"handler",

MCScriptGetNameOfDefinitionInModule(p_module, p_definition),

nil);

}

static bool MCScriptThrowUnableToResolveTypeError(MCTypeInfoRef p_type)

{

return MCErrorThrowUnboundType(p_type);

}

static bool MCScriptThrowUnableToResolveMultiInvoke(MCScriptModuleRef p_module, MCScriptDefinition *p_definition, MCProperListRef p_arguments)

{

MCAutoListRef t_handlers;

if (!MCListCreateMutable(',', &t_handlers))

return false;

MCScriptDefinitionGroupDefinition *t_group;

t_group = static_cast<MCScriptDefinitionGroupDefinition *>(p_definition);

for(uindex_t i = 0; i < t_group -> handler_count; i++)

{

MCNameRef t_name;

t_name = MCScriptGetNameOfDefinitionInModule(p_module, p_module -> definitions[t_group -> handlers[i]]);

if (!MCListAppend(*t_handlers, t_name))

return false;

}

MCAutoListRef t_types;

if (!MCListCreateMutable(',', &t_types))

return false;

for(uindex_t i = 0; i < MCProperListGetLength(p_arguments); i++)

{

MCTypeInfoRef t_type;

t_type = MCValueGetTypeInfo(MCProperListFetchElementAtIndex(p_arguments, i));

MCNewAutoNameRef t_type_name;

if (MCTypeInfoIsNamed(t_type))

t_type_name = MCNamedTypeInfoGetName(t_type);

else

t_type_name = MCNAME("unknown");

if (!MCListAppend(*t_types, *t_type_name))

return false;

}

MCAutoStringRef t_handler_list, t_type_list;

if (!MCListCopyAsString(*t_handlers, &t_handler_list) ||

!MCListCopyAsString(*t_types, &t_type_list))

return false;

return MCErrorCreateAndThrow(kMCScriptNoMatchingHandlerErrorTypeInfo,

"handlers",

*t_handler_list,

"types",

*t_type_list,

nil);

}

static bool MCScriptThrowNotAHandlerValueError(MCValueRef p_value)

{

return MCErrorCreateAndThrow(kMCScriptNotAHandlerValueErrorTypeInfo,

"value",

p_value,

nil);

}

static bool MCScriptThrowHandlerNotFoundError(MCScriptModuleRef p_module, MCNameRef p_handler)

{

return MCErrorCreateAndThrow(kMCScriptHandlerNotFoundErrorTypeInfo,

"module",

p_module -> name,

"handler",

p_handler,

nil);

}

static bool MCScriptThrowPropertyNotFoundError(MCScriptModuleRef p_module, MCNameRef p_property)

{

return MCErrorCreateAndThrow(kMCScriptPropertyNotFoundErrorTypeInfo,

"module",

p_module -> name,

"property",

p_property,

nil);

}

////////////////////////////////////////////////////////////////////////////////

//

// INSTANCE AND MODULE MANIPULATION

//

static bool

MCScriptCheckedFetchFromVariableInInstance(MCScriptInstanceRef self,

MCScriptVariableDefinition *p_definition,

MCValueRef& r_value)

{

MCValueRef t_value;

t_value = self -> slots[p_definition -> slot_index];

if (t_value == nil)

return MCScriptThrowGlobalVariableUsedBeforeDefinedError(self -> module,

p_definition);

r_value = t_value;

return true;

}

static bool

MCScriptCheckedStoreToVariableInInstance(MCScriptInstanceRef self,

MCScriptVariableDefinition *p_definition,

MCValueRef p_value)

{

MCTypeInfoRef t_output_type;

t_output_type = self -> module -> types[p_definition -> type] -> typeinfo;

if (!MCTypeInfoConforms(MCValueGetTypeInfo(p_value), t_output_type))

return MCScriptThrowInvalidValueForGlobalVariableError(self -> module,

p_definition,

t_output_type,

p_value);

MCValueAssign(self -> slots[p_definition -> slot_index], p_value);

return true;

}

static inline

void MCScriptResolveDefinitionInInstance(MCScriptInstanceRef self,

uindex_t p_index,

MCScriptInstanceRef& r_instance,

MCScriptDefinition*& r_definition)

{

MCScriptDefinition *t_definition;

t_definition = self -> module -> definitions[p_index];

MCScriptInstanceRef t_instance;

if (t_definition -> kind != kMCScriptDefinitionKindExternal)

{

t_instance = self;

}

else

{

MCScriptExternalDefinition *t_ext_def;

t_ext_def = static_cast<MCScriptExternalDefinition *>(t_definition);

MCScriptImportedDefinition *t_import_def;

t_import_def = &self -> module -> imported_definitions[t_ext_def -> index];

t_instance = t_import_def -> resolved_module -> shared_instance;

t_definition = t_import_def -> resolved_definition;

}

r_instance = t_instance;

r_definition = t_definition;

}

////////////////////////////////////////////////////////////////////////////////

bool MCScriptGetPropertyOfInstance(MCScriptInstanceRef self, MCNameRef p_property, MCValueRef& r_value)

{

__MCScriptValidateObjectAndKind__(self, kMCScriptObjectKindInstance);

// Lookup the definition (throws if not found).

MCScriptPropertyDefinition *t_definition;

if (!MCScriptLookupPropertyDefinitionInModule(self -> module, p_property, t_definition))

return MCScriptThrowPropertyNotFoundError(self -> module, p_property);

MCScriptDefinition *t_getter;

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

/* LOAD CHECK */ __MCScriptAssert__(t_getter != nil,

"property has no getter");

/* LOAD CHECK */ __MCScriptAssert__(t_getter -> kind == kMCScriptDefinitionKindVariable ||

t_getter -> kind == kMCScriptDefinitionKindHandler,

"property getter is not a variable or handler");

if (t_getter -> kind == kMCScriptDefinitionKindVariable)

{

// The easy case - fetching a variable-based property.

MCScriptVariableDefinition *t_variable_def;

t_variable_def = MCScriptDefinitionAsVariable(t_getter);

MCValueRef t_value;

if (!MCScriptCheckedFetchFromVariableInInstance(self,

t_variable_def,

t_value))

return false;

// Copy the value out

r_value = MCValueRetain(t_value);

}

else if (t_getter -> kind == kMCScriptDefinitionKindHandler)

{

// The more difficult case - we have to execute a handler.

MCScriptHandlerDefinition *t_handler_def;

t_handler_def = MCScriptDefinitionAsHandler(t_getter);

/* LOAD CHECK */ __MCScriptAssert__(MCHandlerTypeInfoConformsToPropertyGetter(self -> module -> types[t_handler_def -> type] -> typeinfo),

"incorrect signature for property getter");

if (!MCScriptCallHandlerOfInstanceInternal(self, t_handler_def, nil, 0, r_value))

return false;

}

else

{

__MCScriptUnreachable__("inconsistency with definition kind in property fetching");

}

return true;

}

bool MCScriptSetPropertyOfInstance(MCScriptInstanceRef self, MCNameRef p_property, MCValueRef p_value)

{

__MCScriptValidateObjectAndKind__(self, kMCScriptObjectKindInstance);

// Lookup the definition.

MCScriptPropertyDefinition *t_definition;

if (!MCScriptLookupPropertyDefinitionInModule(self -> module, p_property, t_definition))

return MCScriptThrowPropertyNotFoundError(self -> module, p_property);

MCScriptDefinition *t_setter;

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

// If there is no setter for the property then this is an error.

if (t_setter == nil)

return MCScriptThrowAttemptToSetReadOnlyPropertyError(self -> module, p_property);

/* LOAD CHECK */ __MCScriptAssert__(t_setter != nil,

"property has no setter");

/* LOAD CHECK */ __MCScriptAssert__(t_setter -> kind == kMCScriptDefinitionKindVariable ||

t_setter -> kind == kMCScriptDefinitionKindHandler,

"property setter is not a variable or handler");

if (t_setter -> kind == kMCScriptDefinitionKindVariable)

{

// The easy case - storing a variable-based property.

MCScriptVariableDefinition *t_variable_def;

t_variable_def = MCScriptDefinitionAsVariable(t_setter);

MCTypeInfoRef t_type;

t_type = self -> module -> types[t_variable_def -> type] -> typeinfo;

// Make sure the value is of the correct type - if not it is an error.

// (The caller has to ensure things are converted as appropriate).

if (!MCTypeInfoConforms(MCValueGetTypeInfo(p_value), t_type))

return MCScriptThrowInvalidValueForPropertyError(self -> module, p_property, t_type, p_value);

// Store the value

if (!MCScriptCheckedStoreToVariableInInstance(self,

t_variable_def,

p_value))

return false;

}

else if (t_setter -> kind == kMCScriptDefinitionKindHandler)

{

// The more difficult case - we have to execute a handler.

MCScriptHandlerDefinition *t_handler_def;

t_handler_def = MCScriptDefinitionAsHandler(t_setter);

/* LOAD CHECK */ __MCScriptAssert__(MCHandlerTypeInfoConformsToPropertySetter(self -> module -> types[t_handler_def -> type] -> typeinfo),

"incorrect signature for property setter");

// Get the required type of the parameter.

MCTypeInfoRef t_property_type;

t_property_type = MCHandlerTypeInfoGetParameterType(self -> module -> types[t_handler_def -> type] -> typeinfo, 0);

// Make sure the value if of the correct type - if not it is an error.

// (The caller has to ensure things are converted as appropriate).

if (!MCTypeInfoConforms(MCValueGetTypeInfo(p_value), t_property_type))

return MCScriptThrowInvalidValueForPropertyError(self -> module, p_property, t_property_type, p_value);

MCValueRef t_result;

if (!MCScriptCallHandlerOfInstanceInternal(self, t_handler_def, &p_value, 1, t_result))

return false;

MCValueRelease(t_result);

}

else

{

__MCScriptUnreachable__("inconsistency with definition kind in property fetching");

}

return true;

}

static bool MCScriptCallHandlerOfInstanceDirect(MCScriptInstanceRef self, MCScriptHandlerDefinition *p_handler, MCValueRef *p_arguments, uindex_t p_argument_count, MCValueRef& r_value)

{

// Get the signature of the handler.

MCTypeInfoRef t_signature;

t_signature = self -> module -> types[p_handler -> type] -> typeinfo;

// Check the number of arguments.

uindex_t t_required_param_count;

t_required_param_count = MCHandlerTypeInfoGetParameterCount(t_signature);

if (t_required_param_count != p_argument_count)

return MCScriptThrowWrongNumberOfArgumentsForInvokeError(self -> module, p_handler, p_argument_count);

// Check the types of the arguments.

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

{

MCHandlerTypeFieldMode t_mode;

t_mode = MCHandlerTypeInfoGetParameterMode(t_signature, i);

if (t_mode != kMCHandlerTypeFieldModeOut)

{

if (p_arguments[i] == nil)

return MCScriptThrowInParameterNotDefinedError(self -> module, p_handler, i);

MCTypeInfoRef t_type;

t_type = MCHandlerTypeInfoGetParameterType(t_signature, i);

if (!MCTypeInfoConforms(MCValueGetTypeInfo(p_arguments[i]), t_type))

return MCScriptThrowInvalidValueForArgumentError(self -> module, p_handler, i, t_type, p_arguments[i]);

}

}

// Now the input argument array is appropriate, we can just call the handler.

if (!MCScriptCallHandlerOfInstanceInternal(self, p_handler, p_arguments, p_argument_count, r_value))

return false;

return true;

}

bool MCScriptCallHandlerOfInstance(MCScriptInstanceRef self, MCNameRef p_handler, MCValueRef *p_arguments, uindex_t p_argument_count, MCValueRef& r_value)

{

__MCScriptValidateObjectAndKind__(self, kMCScriptObjectKindInstance);

// Lookup the definition (throws if not found).

MCScriptHandlerDefinition *t_definition;

if (!MCScriptLookupHandlerDefinitionInModule(self -> module, p_handler, t_definition))

return MCScriptThrowHandlerNotFoundError(self -> module, p_handler);

return MCScriptCallHandlerOfInstanceDirect(self, t_definition, p_arguments, p_argument_count, r_value);

}

bool MCScriptCallHandlerOfInstanceIfFound(MCScriptInstanceRef self, MCNameRef p_handler, MCValueRef *p_arguments, uindex_t p_argument_count, MCValueRef& r_value)

{

__MCScriptValidateObjectAndKind__(self, kMCScriptObjectKindInstance);

// Lookup the definition (throws if not found).

MCScriptHandlerDefinition *t_definition;

if (!MCScriptLookupHandlerDefinitionInModule(self -> module, p_handler, t_definition))

{

r_value = MCValueRetain(kMCNull);

return true;

}

return MCScriptCallHandlerOfInstanceDirect(self, t_definition, p_arguments, p_argument_count, r_value);

}

////////////////////////////////////////////////////////////////////////////////

struct MCScriptFrameContext

{

uindex_t count;

MCValueRef slots[1];

};

// This structure is a single frame on the execution stack.

struct MCScriptFrame

{

// The calling frame.

MCScriptFrame *caller;

// The instance we are executing within.

MCScriptInstanceRef instance;

// The handler of the instance's module being run right now.

MCScriptHandlerDefinition *handler;

// The address (instruction pointer) into the instance's module bytecode.

uindex_t address;

// The slots for the current handler invocation. The slots are in this order:

// <parameters>

// <locals>

// <registers>

MCValueRef *slots;

// The context slots for the current handler invocation (if initialized)

MCScriptFrameContext *context;

// The result register in the caller.

uindex_t result;

// The mapping array - this lists the mapping from parameters to registers

// in the callers frame, for handling inout/out parameters.

uindex_t *mapping;

};

static inline bool MCScriptIsRegisterValidInFrame(MCScriptFrame *p_frame, uindex_t p_register)

{

return p_register < p_frame -> handler -> slot_count;

}

static inline bool MCScriptIsConstantValidInFrame(MCScriptFrame *p_frame, uindex_t p_constant)

{

return p_constant < p_frame -> instance -> module -> value_count;

}

static inline MCTypeInfoRef MCScriptGetSignatureForFrame(MCScriptFrame *p_frame)

{

return p_frame->instance->module->types[p_frame->handler->type]->typeinfo;

}

static bool MCScriptCreateFrame(MCScriptFrame *p_caller, MCScriptInstanceRef p_instance, MCScriptHandlerDefinition *p_handler, MCScriptFrame*& r_frame)

{

MCScriptFrame *self;

self = nil;

if (!MCMemoryNew(self) ||

!MCMemoryNewArray(p_handler -> slot_count, self -> slots))

{

MCMemoryDelete(self);

return false;

}

self -> caller = p_caller;

self -> instance = MCScriptRetainInstance(p_instance);

self -> handler = p_handler;

self -> address = p_handler -> start_address;

self -> mapping = nil;

r_frame = self;

return true;

}

static bool

MCScriptFrameInitializeParametersCaller(MCScriptFrame *self,

uindex_t *p_arguments,

uindex_t p_arity)

{

MCTypeInfoRef t_signature = MCScriptGetSignatureForFrame(self);

bool t_needs_mapping = false;

for (uindex_t i = 0; i < MCHandlerTypeInfoGetParameterCount(t_signature); ++i)

{

MCHandlerTypeFieldMode t_mode =

MCHandlerTypeInfoGetParameterMode(t_signature, i);

if (t_mode != kMCHandlerTypeFieldModeIn)

{

t_needs_mapping = true;

}

if (t_mode == kMCHandlerTypeFieldModeOut)

{

continue;

}

MCValueRef t_value;

t_value = self->caller->slots[p_arguments[i]];

MCValueAssign(self->slots[i], t_value);

}

if (t_needs_mapping)

{

if (!MCMemoryNewArray(p_arity, self->mapping))

{

return false;

}

MCMemoryCopy(self->mapping, p_arguments, p_arity * sizeof(*p_arguments));

}

return true;

}

static bool

MCScriptFrameInitializeParametersImmediate(MCScriptFrame *self,

MCValueRef *p_arguments,

uindex_t p_arity)

{

MCTypeInfoRef t_signature = MCScriptGetSignatureForFrame(self);

uindex_t t_param_count = MCHandlerTypeInfoGetParameterCount(t_signature);

for (uindex_t i = 0; i < MCMin(p_arity, t_param_count); ++i)

{

MCHandlerTypeFieldMode t_mode =

MCHandlerTypeInfoGetParameterMode(t_signature, i);

if (t_mode == kMCHandlerTypeFieldModeOut)

continue;

MCValueRef t_value;

t_value = p_arguments[i];

MCValueAssign(self->slots[i], t_value);

}

return true;

}

static MCScriptFrame *MCScriptDestroyFrame(MCScriptFrame *self)

{

MCScriptFrame *t_caller;

t_caller = self -> caller;

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

MCValueRelease(self -> slots[i]);

MCScriptReleaseInstance(self -> instance);

MCMemoryDeleteArray(self -> slots);

MCMemoryDeleteArray(self -> mapping);

MCMemoryDelete(self);

return t_caller;

}

static inline void MCScriptBytecodeDecodeOp(byte_t*& x_bytecode_ptr, MCScriptBytecodeOp& r_op, uindex_t& r_arity)

{

byte_t t_op_byte;

t_op_byte = *x_bytecode_ptr++;

// The lower nibble is the bytecode operation.

MCScriptBytecodeOp t_op;

t_op = (MCScriptBytecodeOp)(t_op_byte & 0xf);

// The upper nibble is the arity.

uindex_t t_arity;

t_arity = (t_op_byte >> 4);

// If the arity is 15, then overflow to a subsequent byte.

if (t_arity == 15)

t_arity += *x_bytecode_ptr++;

r_op = t_op;

r_arity = t_arity;

}

// TODO: Make this better for negative numbers.

static inline uindex_t MCScriptBytecodeDecodeArgument(byte_t*& x_bytecode_ptr)

{

uindex_t t_value;

t_value = 0;

int t_shift;

t_shift = 0;

for(;;)

{

byte_t t_next;

t_next = *x_bytecode_ptr++;

t_value |= (t_next & 0x7f) << t_shift;

if ((t_next & 0x80) == 0)

break;

t_shift += 7;

}

return t_value;

}