/* 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 <foundation.h>

#include <foundation-auto.h>

#include <libscript/script.h>

#include "script-private.h"

#include "script-bytecode.hpp"

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

// Utility functor, used to fetch the bytecode info struct for the given

// opcode.

struct MCScriptDescribeBytecodeOp_Impl

{

public:

template<typename OpStruct>

bool Visit(const MCScriptBytecodeOpInfo*& r_info) const

{

r_info = &OpStruct::Describe();

return true;

}

};

static bool

MCScriptDescribeBytecodeOp(uindex_t p_opcode,

const MCScriptBytecodeOpInfo*& r_info)

{

if (p_opcode > kMCScriptBytecodeOp__Last ||

!MCScriptBytecodeDispatchR((MCScriptBytecodeOp)p_opcode,

MCScriptDescribeBytecodeOp_Impl(),

r_info))

{

return false;

}

return true;

}

//////////

class MCScriptCopyBytecodeNames_Impl

{

public:

template<typename OpStruct>

bool Visit(MCProperListRef x_bytecode_names) const

{

if (!MCProperListPushElementOntoBack(x_bytecode_names,

MCSTR(OpStruct::Describe().name)))

return false;

return true;

}

};

bool MCScriptCopyBytecodeNames(MCProperListRef& r_bytecode_names)

{

MCAutoProperListRef t_bytecode_names;

if (!MCProperListCreateMutable(&t_bytecode_names))

return false;

MCProperListRef t_bytecode_names_arg = *t_bytecode_names;

if (!MCScriptBytecodeForEach(MCScriptCopyBytecodeNames_Impl(),

t_bytecode_names_arg))

return false;

r_bytecode_names = t_bytecode_names.Take();

return true;

}

//////////

struct MCScriptLookupBytecode_Impl

{

public:

struct Args

{

const char *name;

uindex_t& _opcode;

Args(const char *p_name,

uindex_t& r_opcode)

: name(p_name),

_opcode(r_opcode)

{

}

};

template<typename OpStruct>

bool Visit(Args p_args) const

{

if (0 != strcmp(p_args.name, OpStruct::Describe().name))

return true;

p_args._opcode = (uindex_t)OpStruct::Describe().code;

return false;

}

};

bool MCScriptLookupBytecode(const char *p_name, uindex_t& r_opcode)

{

// If we get all the way through the bytecodes without returning false, then

// it means it wasn't found.

MCScriptLookupBytecode_Impl::Args t_args(p_name,

r_opcode);

if (MCScriptBytecodeForEach(MCScriptLookupBytecode_Impl(),

t_args))

return false;

return true;

}

//////////

const char *MCScriptDescribeBytecode(uindex_t p_opcode)

{

const MCScriptBytecodeOpInfo *t_info;

if (!MCScriptDescribeBytecodeOp(p_opcode, t_info))

return "<unknown>";

return t_info->name;

}

//////////

MCScriptBytecodeParameterType MCScriptDescribeBytecodeParameter(uindex_t p_opcode, uindex_t p_index)

{

const MCScriptBytecodeOpInfo *t_info;

if (!MCScriptDescribeBytecodeOp(p_opcode, t_info))

return kMCScriptBytecodeParameterTypeUnknown;

const char *t_desc;

t_desc = t_info->format;

size_t t_desc_length;

t_desc_length = strlen(t_desc);

char t_param_type;

switch(t_desc[t_desc_length - 1])

{

case '?':

if (p_index >= t_desc_length - 1)

return kMCScriptBytecodeParameterTypeUnknown;

t_param_type = t_desc[p_index];

break;

case '*':

case '%':

if (p_index >= t_desc_length - 1)

t_param_type = t_desc[t_desc_length - 2];

else

t_param_type = t_desc[p_index];

break;

default:

if (p_index >= t_desc_length)

return kMCScriptBytecodeParameterTypeUnknown;

t_param_type = t_desc[p_index];

break;

}

switch(t_param_type)

{

case 'l':

return kMCScriptBytecodeParameterTypeLabel;

case 'r':

return kMCScriptBytecodeParameterTypeRegister;

case 'c':

return kMCScriptBytecodeParameterTypeConstant;

case 'd':

return kMCScriptBytecodeParameterTypeDefinition;

case 'v':

return kMCScriptBytecodeParameterTypeVariable;

case 'h':

return kMCScriptBytecodeParameterTypeHandler;

default:

break;

}

return kMCScriptBytecodeParameterTypeUnknown;

}

bool MCScriptCheckBytecodeParameterCount(uindex_t p_opcode, uindex_t p_proposed_count)

{

const MCScriptBytecodeOpInfo *t_info;

if (!MCScriptDescribeBytecodeOp(p_opcode, t_info))

return kMCScriptBytecodeParameterTypeUnknown;

const char *t_desc;

t_desc = t_info->format;

size_t t_desc_length;

t_desc_length = strlen(t_desc);

switch(t_desc[t_desc_length - 1])

{

case '?':

if (p_proposed_count == t_desc_length - 2 ||

p_proposed_count == t_desc_length - 1)

return true;

break;

case '*':

if (p_proposed_count >= t_desc_length - 2)

return true;

break;

case '%':

if (p_proposed_count >= t_desc_length - 2 &&

((p_proposed_count - (t_desc_length - 2)) % 2 == 0))

return true;

break;

default:

if (p_proposed_count == t_desc_length)

return true;

break;

}

return false;

}

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

struct MCScriptBytecodeLabel

{

uindex_t instruction;

};

struct MCScriptBytecodeInstruction

{

MCScriptBytecodeOp operation;

uindex_t arity;

uindex_t operands;

uindex_t address;

uindex_t file;

uindex_t line;

};

struct MCScriptModuleBuilder

{

bool valid;

MCScriptModule module;

uindex_t current_handler;

uindex_t current_param_count;

uindex_t current_local_count;

uindex_t *current_handler_group;

uindex_t current_handler_group_size;

uindex_t current_syntax;

MCScriptType *current_type;

MCScriptBytecodeLabel *labels;

uindex_t label_count;

MCScriptBytecodeInstruction *instructions;

uindex_t instruction_count;

uindex_t *operands;

uindex_t operand_count;

uindex_t current_file;

uindex_t current_line;

MCProperListRef current_list_value;

MCArrayRef current_array_value;

MCScriptDefinitionKind *definition_kinds;

uindex_t definition_kind_count;

};

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

static void __emit_constant(MCScriptModuleBuilderRef self, MCValueRef p_constant, uindex_t& r_index);

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

static bool __append_definition_name(MCScriptModuleBuilderRef self, MCNameRef p_name)

{

if (!MCMemoryResizeArray(self -> module . definition_name_count + 1, self -> module . definition_names, self -> module . definition_name_count))

return false;

self -> module . definition_names[self -> module . definition_name_count - 1] = MCValueRetain(p_name);

return true;

}

static void __assign_definition_name(MCScriptModuleBuilderRef self, uindex_t p_index, MCNameRef p_name)

{

MCValueRelease(self -> module . definition_names[p_index]);

self -> module . definition_names[p_index] = MCValueRetain(p_name);

}

template<typename T> static bool __extend_array(MCScriptModuleBuilderRef self, T*& x_array, uindex_t& x_array_size, uindex_t& r_index)

{

if (!MCMemoryResizeArray(x_array_size + 1, x_array, x_array_size))

{

r_index = 0;

self -> valid = false;

return false;

}

r_index = x_array_size - 1;

return true;

}

void MCScriptBeginModule(MCScriptModuleKind p_kind, MCNameRef p_name, MCScriptModuleBuilderRef& r_builder)

{

MCScriptModuleBuilder *self;

if (!MCMemoryNew(self))

{

r_builder = nil;

return;

}

self -> valid = true;

self -> module . module_kind = p_kind;

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

self -> current_handler = UINDEX_MAX;

self -> current_handler_group = nil;

self -> current_handler_group_size = 0;

self -> current_syntax = UINDEX_MAX;

self -> current_file = 0;

self -> current_line = 0;

self -> current_list_value = nil;

self -> current_array_value = nil;

self -> definition_kind_count = 0;

self -> definition_kinds = nil;

r_builder = self;

}

static bool

MCScriptValidateModuleBytecode(MCScriptModule *self)

{

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

{

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;

MCScriptHandlerType *t_signature;

t_signature = static_cast<MCScriptHandlerType *>(self -> types[t_handler -> type]);

t_state.register_limit = t_signature->parameter_count +

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)

return false;

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)

return false;

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

if (t_bytecode != t_bytecode_limit)

return false;

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

if (t_state.operation != kMCScriptBytecodeOpReturn)

return false;

}

}

return true;

}

bool MCScriptEndModule(MCScriptModuleBuilderRef self, MCStreamRef p_stream)

{

if (self == nil)

return false;

for(uindex_t i = 0; self -> valid && i < self -> module . definition_count; i++)

{

if (self -> module . definitions[i] != nil)

continue;

self -> valid = false;

}

if (self->valid)

{

if (!MCScriptValidateModuleBytecode(&self->module))

{

self->valid = false;

}

}

bool t_success;

if (self -> valid)

{

byte_t t_header[4];

t_header[0] = 'L';

t_header[1] = 'C';

t_header[2] = ((kMCScriptCurrentModuleVersion >> 0) & 0xFF);

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

t_success = MCStreamWrite(p_stream, t_header, 4) &&

MCScriptWriteRawModule(p_stream, &self -> module);

}

else

t_success = false;

MCScriptReleaseRawModule(&self -> module);

MCMemoryDeleteArray(self -> labels);

MCMemoryDeleteArray(self -> instructions);

MCMemoryDeleteArray(self -> operands);

MCValueRelease(self -> current_list_value);

MCValueRelease(self -> current_array_value);

MCMemoryDeleteArray(self -> definition_kinds);

MCMemoryDelete(self);

return t_success;

}

void MCScriptAddDependencyToModule(MCScriptModuleBuilderRef self, MCNameRef p_dependency, uindex_t& r_index)

{

if (self == nil || !self -> valid)

return;

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

if (MCNameIsEqualTo(p_dependency, self -> module . dependencies[i] . name))

{

r_index = i;

return;

}

if (!__extend_array(self, self -> module . dependencies, self -> module . dependency_count, r_index))

return;

self -> module . dependencies[r_index] . name = MCValueRetain(p_dependency);

self -> module . dependencies[r_index] . version = 0;

}

void MCScriptAddExportToModule(MCScriptModuleBuilderRef self, uindex_t p_definition)

{

if (self == nil || !self -> valid)

return;

uindex_t t_index;

if (!__extend_array(self, self -> module . exported_definitions, self -> module . exported_definition_count, t_index))

return;

self -> module . exported_definitions[t_index] . name = MCValueRetain(self -> module . definition_names[p_definition]);

self -> module . exported_definitions[t_index] . index = p_definition;

// If the definition is a type, then make sure we make it a 'defined' type otherwise

// it won't get bound globally.

if (self -> module . definitions[p_definition] -> kind == kMCScriptDefinitionKindType)

{

uindex_t t_type_index;

MCScriptAddDefinedTypeToModule(self, p_definition, t_type_index);

}

}

void MCScriptAddImportToModuleWithIndex(MCScriptModuleBuilderRef self, uindex_t p_module_index, MCNameRef p_name, MCScriptDefinitionKind p_kind, uindex_t p_type_index, uindex_t p_def_index)

{

uindex_t t_imp_index;

if (!__extend_array(self, self -> module . imported_definitions, self -> module . imported_definition_count, t_imp_index) ||

!MCMemoryNew((MCScriptExternalDefinition*&)self -> module . definitions[p_def_index]))

{

self -> valid = false;

return;

}

__assign_definition_name(self, p_def_index, p_name);

MCScriptImportedDefinition *t_import;

t_import = &self -> module . imported_definitions[t_imp_index];

t_import -> module = p_module_index;

t_import -> kind = p_kind;

t_import -> name = MCValueRetain(p_name);

MCScriptExternalDefinition *t_definition;

t_definition = static_cast<MCScriptExternalDefinition *>(self -> module . definitions[p_def_index]);

t_definition -> kind = kMCScriptDefinitionKindExternal;

t_definition -> index = t_imp_index;

}

void MCScriptAddImportToModule(MCScriptModuleBuilderRef self, uindex_t p_index, MCNameRef p_name, MCScriptDefinitionKind p_kind, uindex_t p_type_index, uindex_t& r_index)

{

if (self == nil || !self -> valid)

{

r_index = 0;

return;

}

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

if (MCNameIsEqualTo(p_name, self -> module . imported_definitions[i] . name) &&

p_kind == self -> module . imported_definitions[i] . kind &&

p_index == self -> module . imported_definitions[i] . module)

{

for(uindex_t j = 0; j < self -> module . definition_count; j++)

if (self -> module . definitions[j] != nil &&

self -> module . definitions[j] -> kind == kMCScriptDefinitionKindExternal &&

static_cast<MCScriptExternalDefinition *>(self -> module . definitions[j]) -> index == i)

{

r_index = j;

return;

}

}

MCScriptAddDefinitionToModule(self, p_kind, r_index);

MCScriptAddImportToModuleWithIndex(self, p_index, p_name, p_kind, p_type_index, r_index);

if (!self -> valid)

r_index = 0;

}

void MCScriptAddDefinitionToModule(MCScriptModuleBuilderRef self, MCScriptDefinitionKind p_kind, uindex_t& r_index)

{

if (self == nil || !self -> valid)

return;

uindex_t t_dindex;

if (!__extend_array(self, self -> module . definitions, self -> module . definition_count, r_index) ||

!__extend_array(self, self -> definition_kinds, self -> definition_kind_count, t_dindex) ||

!__append_definition_name(self, kMCEmptyName))

{

r_index = 0;

self -> valid = false;

return;

}

self -> definition_kinds[t_dindex] = p_kind;

}

void MCScriptAddValueToModule(MCScriptModuleBuilderRef self, MCValueRef p_value, uindex_t& r_index)

{

if (self == nil || !self -> valid)

return;

__emit_constant(self, p_value, r_index);

}

void MCScriptBeginListValueInModule(MCScriptModuleBuilderRef self)

{

if (self == nil || !self -> valid)

return;

if (self -> current_list_value != nil ||

!MCProperListCreateMutable(self -> current_list_value))

{

self -> valid = false;

return;

}

}

void MCScriptContinueListValueInModule(MCScriptModuleBuilderRef self, uindex_t p_const_idx)

{

if (self == nil || !self -> valid)

return;

if (self -> current_list_value == nil ||

!MCProperListPushElementOntoBack(self -> current_list_value, self -> module . values[p_const_idx]))

{

self -> valid = false;

return;

}

}

void MCScriptEndListValueInModule(MCScriptModuleBuilderRef self, uindex_t& r_index)

{

if (self == nil || !self -> valid)

return;

MCScriptAddValueToModule(self, self -> current_list_value, r_index);

MCValueRelease(self -> current_list_value);

self -> current_list_value = nil;

}

void MCScriptBeginArrayValueInModule(MCScriptModuleBuilderRef self)

{

if (self == nil || !self -> valid)

return;

if (self -> current_array_value != nil ||

!MCArrayCreateMutable(self -> current_array_value))

{

self -> valid = false;

return;

}

}

void MCScriptContinueArrayValueInModule(MCScriptModuleBuilderRef self,

uindex_t p_key_idx,

uindex_t p_value_idx)

{

MCNewAutoNameRef t_key;

if (self == nil || !self -> valid)

return;

if (self -> current_array_value == nil ||

!MCNameCreate(reinterpret_cast<MCStringRef>(self->module.values[p_key_idx]), &t_key) ||

!MCArrayStoreValue(self -> current_array_value, false,

*t_key, self -> module . values[p_value_idx]))

{

self -> valid = false;

return;

}

}

void MCScriptEndArrayValueInModule(MCScriptModuleBuilderRef self, uindex_t& r_index)

{

if (self == nil || !self -> valid)

return;

MCScriptAddValueToModule(self, self -> current_array_value, r_index);

MCValueRelease(self -> current_array_value);

self -> current_array_value = nil;

}

void MCScriptAddTypeToModule(MCScriptModuleBuilderRef self, MCNameRef p_name, uindex_t p_type, uindex_t p_index)

{

if (self == nil || !self -> valid)

return;

if (p_index >= self -> module . definition_count ||

self -> module . definitions[p_index] != nil ||

!MCMemoryNew((MCScriptTypeDefinition*&)self -> module . definitions[p_index]))

{

self -> valid = false;

return;

}

__assign_definition_name(self, p_index, p_name);

MCScriptTypeDefinition *t_definition;

t_definition = static_cast<MCScriptTypeDefinition *>(self -> module . definitions[p_index]);

t_definition -> kind = kMCScriptDefinitionKindType;

t_definition -> type = p_type;

}

void MCScriptAddConstantToModule(MCScriptModuleBuilderRef self, MCNameRef p_name, uindex_t p_const_idx, uindex_t p_index)

{

if (self == nil || !self -> valid)

return;

if (p_index >= self -> module . definition_count ||

self -> module . definitions[p_index] != nil ||

!MCMemoryNew((MCScriptConstantDefinition*&)self -> module . definitions[p_index]))

{

self -> valid = false;

return;

}

__assign_definition_name(self, p_index, p_name);

MCScriptConstantDefinition *t_definition;

t_definition = static_cast<MCScriptConstantDefinition *>(self -> module . definitions[p_index]);

t_definition -> kind = kMCScriptDefinitionKindConstant;

t_definition -> value = p_const_idx;

}

void MCScriptAddVariableToModule(MCScriptModuleBuilderRef self, MCNameRef p_name, uindex_t p_type, uindex_t p_index)

{

if (self == nil || !self -> valid)

return;

if (p_index >= self -> module . definition_count ||

self -> module . definitions[p_index] != nil ||

!MCMemoryNew((MCScriptVariableDefinition*&)self -> module . definitions[p_index]))

{

self -> valid = false;

return;

}

__assign_definition_name(self, p_index, p_name);

MCScriptVariableDefinition *t_definition;

t_definition = static_cast<MCScriptVariableDefinition *>(self -> module . definitions[p_index]);

t_definition -> kind = kMCScriptDefinitionKindVariable;

t_definition -> type = p_type;

}

void MCScriptAddForeignHandlerToModule(MCScriptModuleBuilderRef self, MCNameRef p_name, uindex_t p_signature, MCStringRef p_binding, uindex_t p_index)

{

if (self == nil || !self -> valid)

return;

if (p_index >= self -> module . definition_count ||

self -> module . definitions[p_index] != nil ||

!MCMemoryNew((MCScriptForeignHandlerDefinition*&)self -> module . definitions[p_index]))

{

self -> valid = false;

return;

}

__assign_definition_name(self, p_index, p_name);

MCScriptForeignHandlerDefinition *t_definition;

t_definition = static_cast<MCScriptForeignHandlerDefinition *>(self -> module . definitions[p_index]);

t_definition -> kind = kMCScriptDefinitionKindForeignHandler;

t_definition -> type = p_signature;

t_definition -> binding = MCValueRetain(p_binding);

}

void MCScriptAddPropertyToModule(MCScriptModuleBuilderRef self, MCNameRef p_name, uindex_t p_getter, uindex_t p_setter, uindex_t p_index)

{

if (self == nil || !self -> valid)

return;

if (p_index >= self -> module . definition_count ||

self -> module . definitions[p_index] != nil ||

!MCMemoryNew((MCScriptPropertyDefinition *&)self -> module . definitions[p_index]))

{

self -> valid = false;

return;

}

__assign_definition_name(self, p_index, p_name);

MCScriptPropertyDefinition *t_definition;

t_definition = static_cast<MCScriptPropertyDefinition *>(self -> module . definitions[p_index]);

// The property getters and setter references are stored with +1 indices, 0 meaning

// no getter/setter.

t_definition -> kind = kMCScriptDefinitionKindProperty;

t_definition -> getter = p_getter + 1;

t_definition -> setter = p_setter == UINDEX_MAX ? 0 : p_setter + 1;

}

void MCScriptAddEventToModule(MCScriptModuleBuilderRef self, MCNameRef p_name, uindex_t p_type, uindex_t p_index)

{

if (self == nil || !self -> valid)

return;

if (p_index >= self -> module . definition_count ||

self -> module . definitions[p_index] != nil ||

!MCMemoryNew((MCScriptEventDefinition*&)self -> module . definitions[p_index]))

{

self -> valid = false;

return;

}

__assign_definition_name(self, p_index, p_name);

MCScriptEventDefinition *t_definition;

t_definition = static_cast<MCScriptEventDefinition *>(self -> module . definitions[p_index]);

t_definition -> kind = kMCScriptDefinitionKindEvent;

t_definition -> type = p_type;

}

///////////

static void __add_script_type(MCScriptModuleBuilderRef self, MCScriptType *p_type, uindex_t& r_index)

{

if (!__extend_array(self, self -> module . types, self -> module . type_count, r_index))

return;

self -> module . types[r_index] = p_type;

}

void MCScriptAddDefinedTypeToModule(MCScriptModuleBuilderRef self, uindex_t p_index, uindex_t& r_type)

{

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

if (self -> module . types[i] -> kind == kMCScriptTypeKindDefined)

if (static_cast<MCScriptDefinedType *>(self -> module . types[i]) -> index == p_index)

{

r_type = i;

return;

}

MCScriptDefinedType *t_type;

if (!MCMemoryNew(t_type))

{

self -> valid = false;

return;

}

t_type -> kind = kMCScriptTypeKindDefined;

t_type -> index = p_index;

__add_script_type(self, t_type, r_type);

}

void MCScriptAddForeignTypeToModule(MCScriptModuleBuilderRef self, MCStringRef p_binding, uindex_t& r_type)

{

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

if (self -> module . types[i] -> kind == kMCScriptTypeKindForeign)

if (MCStringIsEqualTo(static_cast<MCScriptForeignType *>(self -> module . types[i]) -> binding, p_binding, kMCStringOptionCompareExact))

{

r_type = i;

return;

}

MCScriptForeignType *t_type;

if (!MCMemoryNew(t_type))

{

self -> valid = false;

return;

}

t_type -> kind = kMCScriptTypeKindForeign;

t_type -> binding = MCValueRetain(p_binding);

__add_script_type(self, t_type, r_type);

}

void MCScriptAddOptionalTypeToModule(MCScriptModuleBuilderRef self, uindex_t p_type, uindex_t& r_type)

{

if (self -> module . types[p_type] -> kind == kMCScriptTypeKindOptional)

{

r_type = p_type;

return;

}

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

if (self -> module . types[i] -> kind == kMCScriptTypeKindOptional)

if (static_cast<MCScriptOptionalType *>(self -> module . types[i]) -> type == p_type)

{

r_type = i;

return;

}

MCScriptOptionalType *t_type;

if (!MCMemoryNew(t_type))

{

self -> valid = false;

return;

}

t_type -> kind = kMCScriptTypeKindOptional;

t_type -> type = p_type;

__add_script_type(self, t_type, r_type);

}

static void MCScriptBeginCommonHandlerTypeInModule(MCScriptModuleBuilderRef self, bool p_is_foreign, uindex_t p_return_type)

{

if (self == nil ||

!self -> valid)

return;

MCScriptHandlerType *t_type;

if (!MCMemoryNew(t_type))

{

self -> valid = false;

return;

}

t_type -> kind = p_is_foreign ? kMCScriptTypeKindForeignHandler : kMCScriptTypeKindHandler;

t_type -> return_type = p_return_type;

self -> current_type = t_type;

}

void MCScriptBeginHandlerTypeInModule(MCScriptModuleBuilderRef self, uindex_t p_return_type)

{

MCScriptBeginCommonHandlerTypeInModule(self, false, p_return_type);

}

void MCScriptBeginForeignHandlerTypeInModule(MCScriptModuleBuilderRef self, uindex_t p_return_type)

{

MCScriptBeginCommonHandlerTypeInModule(self, true, p_return_type);

}

void MCScriptContinueHandlerTypeInModule(MCScriptModuleBuilderRef self, MCScriptHandlerTypeParameterMode p_mode, MCNameRef p_name, uindex_t p_type)

{

if (self == nil ||

!self -> valid ||

self -> current_type == nil)

return;

MCScriptHandlerType *t_type;

t_type = static_cast<MCScriptHandlerType *>(self -> current_type);

uindex_t t_param_index, t_name_index;

if (!__extend_array(self, t_type -> parameters, t_type -> parameter_count, t_param_index) ||

!__extend_array(self, t_type -> parameter_names, t_type -> parameter_name_count, t_name_index))

return;

t_type -> parameters[t_param_index] . mode = p_mode;

t_type -> parameters[t_param_index] . type = p_type;

t_type -> parameter_names[t_name_index] = MCValueRetain(p_name);

}

void MCScriptEndHandlerTypeInModule(MCScriptModuleBuilderRef self, uindex_t& r_new_type)

{

if (self == nil ||

!self -> valid ||

self -> current_type == nil)

return;

MCScriptHandlerType *t_type;

t_type = static_cast<MCScriptHandlerType *>(self -> current_type);

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

{

if (self -> module . types[i] -> kind != t_type -> kind)

continue;

MCScriptHandlerType *t_other_type;

t_other_type = static_cast<MCScriptHandlerType *>(self -> module . types[i]);

if (t_type -> parameter_count != t_other_type -> parameter_count)

continue;

if (t_type -> return_type != t_other_type -> return_type)

continue;

bool t_equal;

t_equal = true;

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

if (t_type -> parameters[j] . mode != t_other_type -> parameters[j] . mode ||

t_type -> parameters[j] . type != t_other_type -> parameters[j] . type)

{

t_equal = false;

break;

}

if (!t_equal)

continue;

MCMemoryDeleteArray(t_type -> parameters);

MCMemoryDelete(t_type);

r_new_type = i;

return;

}

__add_script_type(self, t_type, r_new_type);