/* Copyright (C) 2003-2013 Runtime Revolution 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 "prefix.h"

#include "core.h"

#include "globdefs.h"

#include "filedefs.h"

#include "objdefs.h"

#include "parsedef.h"

#include "execpt.h"

#include "param.h"

#include "scriptpt.h"

#include "chunk.h"

#include "handler.h"

#include "license.h"

#include "util.h"

#include "mcerror.h"

#include "osspec.h"

#include "globals.h"

#include "object.h"

#include "control.h"

#include "notify.h"

#include "stack.h"

#include "card.h"

#include "eventqueue.h"

#include "external.h"

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

typedef MCVariableValue *MCExternalVariableRef;

typedef MCObjectHandle *MCExternalObjectRef;

typedef void *MCExternalVariableIteratorRef;

typedef uint32_t MCExternalValueOptions;

typedef uint32_t MCExternalRunOnMainThreadOptions;

typedef void (*MCExternalThreadOptionalCallback)(void *state);

typedef void (*MCExternalThreadRequiredCallback)(void *state, int flags);

#define kMCExternalInterfaceVersion 4

enum

{

// Post the callback and wait until the callback is invoked

kMCExternalRunOnMainThreadSend = 0 << 0,

// Post the callback and return immediately

kMCExternalRunOnMainThreadPost = 1 << 0,

// The callback does not have to be executed

kMCExternalRunOnMainThreadOptional = 0 << 1,

// The callback has to be executed (changes signature)

kMCExternalRunOnMainThreadRequired = 1 << 1,

// The callback should be invoked in a script-safe environment

kMCExternalRunOnMainThreadSafe = 0 << 2,

// The callback should can be invoked in a non-script-safe environment

kMCExternalRunOnMainThreadUnsafe = 1 << 2,

// The callback should be invoked as soon as possible

kMCExternalRunOnMainThreadImmediate = 0 << 3,

// The callback should be invoked synchronized to the event queue

kMCExternalRunOnMainThreadDeferred = 1 << 3,

// Call the callback on the UI thread (V4+).

kMCExternalRunOnMainThreadJumpToUI = 1 << 4,

// Call the callback on the Engine thread (V4+)

kMCExternalRunOnMainThreadJumpToEngine = 2 << 4,

};

enum

{

kMCExternalWaitOptionBlocking = 0,

kMCExternalWaitOptionDispatching = 1 << 0

};

enum

{

kMCExternalValueOptionAsVariable = 0,

kMCExternalValueOptionAsBoolean = 1,

kMCExternalValueOptionAsInteger = 2,

kMCExternalValueOptionAsCardinal = 3,

kMCExternalValueOptionAsReal = 4,

kMCExternalValueOptionAsString = 5,

kMCExternalValueOptionAsCString = 6,

kMCExternalValueOptionCaseSensitiveMask = 3 << 30,

kMCExternalValueOptionDefaultCaseSensitive = 0 << 30,

kMCExternalValueOptionCaseSensitive = 1 << 30,

kMCExternalValueOptionNotCaseSensitive = 2 << 30,

kMCExternalValueOptionConvertOctalsMask = 3 << 28,

kMCExternalValueOptionDefaultConvertOctals = 0 << 28,

kMCExternalValueOptionConvertOctals = 1 << 28,

kMCExternalValueOptionDoNotConvertOctals = 2 << 28,

kMCExternalValueOptionNumberFormatMask = 3 << 26,

kMCExternalValueOptionDefaultNumberFormat = 0 << 26,

kMCExternalValueOptionDecimalNumberFormat = 1 << 26,

kMCExternalValueOptionScientificNumberFormat = 2 << 26,

kMCExternalValueOptionCompactNumberFormat = 3 << 26

};

enum MCExternalError

{

kMCExternalErrorNone = 0,

kMCExternalErrorOutOfMemory = 1,

kMCExternalErrorNotImplemented = 2,

kMCExternalErrorNoVariable = 3,

kMCExternalErrorNoValue = 4,

kMCExternalErrorNoIterator = 5,

kMCExternalErrorNoBuffer = 6,

kMCExternalErrorNotAnExternalTemporary = 7,

kMCExternalErrorInvalidValueType = 8,

kMCExternalErrorNotABoolean = 9,

kMCExternalErrorNotANumber = 10,

kMCExternalErrorNotAnInteger = 11,

kMCExternalErrorNotAString = 12,

kMCExternalErrorNotACString = 13,

kMCExternalErrorNotAnArray = 14,

kMCExternalErrorDstNotAString = 15,

kMCExternalErrorNumericOverflow = 16,

kMCExternalErrorInvalidConvertOctalsOption = 17,

kMCExternalErrorInvalidCaseSensitiveOption = 18,

kMCExternalErrorInvalidVariableQuery = 19,

kMCExternalErrorInvalidContextQuery = 20,

kMCExternalErrorVariableDoesNotExist = 21,

kMCExternalErrorInvalidEdit = 22,

kMCExternalErrorNoObject = 23,

kMCExternalErrorNoObjectId = 24,

kMCExternalErrorNoObjectMessage = 25,

kMCExternalErrorNoObjectArguments = 26,

kMCExternalErrorMalformedObjectChunk = 27,

kMCExternalErrorCouldNotResolveObject = 18,

kMCExternalErrorObjectDoesNotExist = 29,

kMCExternalErrorNoDefaultStack = 30,

kMCExternalErrorAborted = 31,

kMCExternalErrorFailed = 32,

kMCExternalErrorExited = 33,

kMCExternalErrorNoObjectProperty = 34,

kMCExternalErrorNoObjectPropertyValue = 35,

kMCExternalErrorInvalidInterfaceQuery = 36,

kMCExternalErrorNotSupported = 37,

};

enum MCExternalContextQueryTag

{

kMCExternalContextQueryMe = 1,

kMCExternalContextQueryTarget,

kMCExternalContextQueryResult,

kMCExternalContextQueryIt,

kMCExternalContextQueryCaseSensitive,

kMCExternalContextQueryConvertOctals,

kMCExternalContextQueryNumberFormat,

kMCExternalContextQueryItemDelimiter,

kMCExternalContextQueryLineDelimiter,

kMCExternalContextQueryColumnDelimiter,

kMCExternalContextQueryRowDelimiter,

kMCExternalContextQueryDefaultStack,

kMCExternalContextQueryDefaultCard,

};

enum MCExternalVariableQueryTag

{

kMCExternalVariableQueryIsTemporary = 1,

kMCExternalVariableQueryIsTransient,

kMCExternalVariableQueryFormat,

kMCExternalVariableQueryRetention,

kMCExternalVariableQueryIsAnArray,

};

enum MCExternalInterfaceQueryTag

{

kMCExternalInterfaceQueryView = 1,

kMCExternalInterfaceQueryViewScale = 2,

kMCExternalInterfaceQueryViewController = 3,

kMCExternalInterfaceQueryActivity = 4,

kMCExternalInterfaceQueryContainer = 5,

};

enum

{

kMCExternalObjectUpdateOptionRect = 1 << 0,

};

enum MCExternalDispatchType

{

kMCExternalDispatchCommand,

kMCExternalDispatchFunction

};

enum MCExternalDispatchStatus

{

kMCExternalDispatchStatusHandled,

kMCExternalDispatchStatusNotHandled,

kMCExternalDispatchStatusPassed,

kMCExternalDispatchStatusError,

kMCExternalDispatchStatusExit,

kMCExternalDispatchStatusAbort,

};

enum MCExternalHandlerType

{

kMCExternalHandlerTypeNone,

kMCExternalHandlerTypeCommand,

kMCExternalHandlerTypeFunction

};

struct MCExternalHandler

{

MCExternalHandlerType type;

const char *name;

bool (*handler)(MCExternalVariableRef *argv, uint32_t argc, MCExternalVariableRef result);

};

struct MCExternalInfo

{

uint32_t version;

uint32_t flags;

const char *name;

MCExternalHandler *handlers;

};

struct MCExternalInterface

{

uint32_t version;

//////////

MCExternalError (*engine_run_on_main_thread)(void *callback, void *callback_state, MCExternalRunOnMainThreadOptions options);

//////////

MCExternalError (*context_query)(MCExternalContextQueryTag op, void *result);

//////////

MCExternalError (*variable_create)(MCExternalVariableRef* var);

MCExternalError (*variable_retain)(MCExternalVariableRef var);

MCExternalError (*variable_release)(MCExternalVariableRef var);

MCExternalError (*variable_query)(MCExternalVariableRef var, MCExternalVariableQueryTag tag, void *result);

MCExternalError (*variable_clear)(MCExternalVariableRef var);

MCExternalError (*variable_exchange)(MCExternalVariableRef var_a, MCExternalVariableRef var_b);

MCExternalError (*variable_store)(MCExternalVariableRef var, MCExternalValueOptions options, void *value);

MCExternalError (*variable_fetch)(MCExternalVariableRef var, MCExternalValueOptions options, void *value);

MCExternalError (*variable_append)(MCExternalVariableRef var, MCExternalValueOptions options, void *value);

MCExternalError (*variable_prepend)(MCExternalVariableRef var, MCExternalValueOptions options, void *value);

MCExternalError (*variable_edit)(MCExternalVariableRef var, MCExternalValueOptions options, uint32_t reserve_length, void **r_buffer, uint32_t *r_length);

MCExternalError (*variable_count_keys)(MCExternalVariableRef var, uint32_t* r_count);

MCExternalError (*variable_iterate_keys)(MCExternalVariableRef var, MCExternalVariableIteratorRef *iterator, MCExternalValueOptions options, void *key, MCExternalVariableRef *r_value);

MCExternalError (*variable_remove_key)(MCExternalVariableRef var, MCExternalValueOptions options, void *key);

MCExternalError (*variable_lookup_key)(MCExternalVariableRef var, MCExternalValueOptions options, void *key, bool ensure, MCExternalVariableRef *r_var);

/////////

MCExternalError (*object_resolve)(const char *chunk, MCExternalObjectRef* r_object);

MCExternalError (*object_exists)(MCExternalObjectRef object, bool *r_exists);

MCExternalError (*object_retain)(MCExternalObjectRef object);

MCExternalError (*object_release)(MCExternalObjectRef object);

MCExternalError (*object_dispatch)(MCExternalObjectRef object, MCExternalDispatchType type, const char *message, MCExternalVariableRef *argv, uint32_t argc, MCExternalDispatchStatus *r_status);

/////////

MCExternalError (*wait_run)(void *unused, unsigned int options); // V2, changed in V3

MCExternalError (*wait_break)(void *unused, unsigned int options); // V2, changed in V3

/////////

MCExternalError (*object_get)(MCExternalObjectRef object, unsigned int options, const char *name, const char *key, MCExternalVariableRef value); // V3

MCExternalError (*object_set)(MCExternalObjectRef object, unsigned int options, const char *name, const char *key, MCExternalVariableRef value); // V3

/////////

MCExternalError (*interface_query)(MCExternalInterfaceQueryTag op, void *result); // V3

/////////

MCExternalError (*object_update)(MCExternalObjectRef object, unsigned int options, void *region); // V3

};

typedef MCExternalInfo *(*MCExternalDescribeProc)(void);

typedef bool (*MCExternalInitializeProc)(const MCExternalInterface *intf);

typedef void (*MCExternalFinalizeProc)(void);

extern MCExternalInterface g_external_interface;

extern MCExecPoint *MCEPptr;

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

class MCExternalV1: public MCExternal

{

public:

MCExternalV1(void);

virtual ~MCExternalV1(void);

virtual const char *GetName(void) const;

virtual Handler_type GetHandlerType(uint32_t index) const;

virtual bool ListHandlers(MCExternalListHandlersCallback callback, void *state);

virtual Exec_stat Handle(MCObject *p_context, Handler_type p_type, uint32_t p_index, MCParameter *p_parameters);

private:

virtual bool Prepare(void);

virtual bool Initialize(void);

virtual void Finalize(void);

MCExternalInfo *m_info;

};

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

MCExternalV1::MCExternalV1(void)

{

m_info = nil;

}

MCExternalV1::~MCExternalV1(void)

{

}

bool MCExternalV1::Prepare(void)

{

// Fetch the description callback - this symbol has to exist since a V1

// external is only created if it does!

MCExternalDescribeProc t_describe;

t_describe = (MCExternalDescribeProc)MCS_resolvemodulesymbol(m_module, "MCExternalDescribe");

// Query the info record - if this returns nil something odd is going on!

m_info = t_describe();

if (m_info == nil)

return false;

return true;

}

bool MCExternalV1::Initialize(void)

{

// Fetch the initialize entry point.

MCExternalInitializeProc t_initialize;

t_initialize = (MCExternalInitializeProc)MCS_resolvemodulesymbol(m_module, "MCExternalInitialize");

if (t_initialize == nil)

return true;

// See if initialization succeeds.

if (!t_initialize(&g_external_interface))

return false;

return true;

}

void MCExternalV1::Finalize(void)

{

// Fetch the finalize entry point.

MCExternalFinalizeProc t_finalize;

t_finalize = (MCExternalFinalizeProc)MCS_resolvemodulesymbol(m_module, "MCExternalFinalize");

if (t_finalize == nil)

return;

t_finalize();

}

const char *MCExternalV1::GetName(void) const

{

return m_info -> name;

}

Handler_type MCExternalV1::GetHandlerType(uint32_t p_index) const

{

if (m_info -> handlers[p_index] . type == kMCExternalHandlerTypeCommand)

return HT_MESSAGE;

return HT_FUNCTION;

}

bool MCExternalV1::ListHandlers(MCExternalListHandlersCallback p_callback, void *p_state)

{

for(uint32_t i = 0; m_info -> handlers[i] . type != kMCExternalHandlerTypeNone; i++)

if (!p_callback(p_state, m_info -> handlers[i] . type == kMCExternalHandlerTypeCommand ? HT_MESSAGE : HT_FUNCTION, m_info -> handlers[i] . name, i))

return false;

return true;

}

Exec_stat MCExternalV1::Handle(MCObject *p_context, Handler_type p_type, uint32_t p_index, MCParameter *p_parameters)

{

MCExternalHandlerType t_type;

if (p_type == HT_FUNCTION)

t_type = kMCExternalHandlerTypeFunction;

else

t_type = kMCExternalHandlerTypeCommand;

MCExternalHandler *t_handler;

t_handler = &m_info -> handlers[p_index];

if (t_handler -> type != t_type)

return ES_NOT_HANDLED;

Exec_stat t_stat;

t_stat = ES_NORMAL;

// Count the number of parameters.

uint32_t t_parameter_count;

t_parameter_count = 0;

for(MCParameter *t_param = p_parameters; t_param != nil; t_param = t_param -> getnext())

t_parameter_count += 1;

// Allocate an array of values.

MCVariableValue **t_parameter_vars;

t_parameter_vars = NULL;

if (t_parameter_count != 0)

{

t_parameter_vars = new MCVariableValue *[t_parameter_count];

if (t_parameter_vars == nil)

return ES_ERROR;

}

// Now iterate through the parameters, fetching the parameter values as we go.

for(uint32_t i = 0; p_parameters != nil && t_stat == ES_NORMAL; i++, p_parameters = p_parameters -> getnext())

{

MCVariable* t_var;

t_var = p_parameters -> eval_argument_var();

if (t_var != nil)

{

// We are a variable parameter so use the value directly (i.e. pass by

// reference).

t_parameter_vars[i] = &t_var -> getvalue();

}

else

{

// We need a temporary so do an exchange. Note that unlike other handlers,

// external handlers can't 'pass' so we don't need the value in the parameter

// anymore after this 'Handle' call.

t_parameter_vars[i] = new MCVariableValue;

if (t_parameter_vars[i] != nil)

{

t_parameter_vars[i] -> set_temporary();

t_parameter_vars[i] -> exchange(p_parameters -> getvalue());

}

else

t_stat = ES_ERROR;

}

}

// We have our list of parameters (hopefully), so now call - passing a temporary

// result.

if (t_stat == ES_NORMAL)

{

MCVariableValue t_result;

t_result . set_temporary();

t_result . assign_empty();

// Invoke the external handler. If 'false' is returned, treat the result as a

// string value containing an error hint.

if ((t_handler -> handler)(t_parameter_vars, t_parameter_count, &t_result))

MCresult -> getvalue() . exchange(t_result);

else

{

MCeerror -> add(EE_EXTERNAL_EXCEPTION, 0, 0, t_result . is_string() ? t_result . get_string() : "");

t_stat = ES_ERROR;

}

}

// Finally, loop through and free the parameters as necessary.

for(uint32_t i = 0; i < t_parameter_count; i++)

if (t_parameter_vars[i] -> get_temporary())

delete t_parameter_vars[i];

delete t_parameter_vars;

return t_stat;

}

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

MCExternal *MCExternalCreateV1(void)

{

return new MCExternalV1;

}

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

static bool options_get_convert_octals(MCExternalValueOptions p_options)

{

switch(p_options & kMCExternalValueOptionConvertOctalsMask)

{

case kMCExternalValueOptionDefaultConvertOctals:

return MCEPptr -> getconvertoctals() == True;

case kMCExternalValueOptionConvertOctals:

return true;

case kMCExternalValueOptionDoNotConvertOctals:

return false;

default:

break;

}

return false;

}

static MCExternalError string_to_boolean(const MCString& p_string, MCExternalValueOptions p_options, void *r_value)

{

if (p_string == MCtruemcstring)

*(bool *)r_value = true;

else if (p_string == MCfalsemcstring)

*(bool *)r_value = false;

else

return kMCExternalErrorNotABoolean;

return kMCExternalErrorNone;

}

static MCExternalError string_to_integer(const MCString& p_string, MCExternalValueOptions p_options, void *r_value)

{

const char *s;

uint32_t l;

s = p_string . getstring();

l = p_string . getlength();

// Skip any whitespace before the number.

MCU_skip_spaces(s, l);

if (l == 0)

return kMCExternalErrorNotANumber;

// Check to see if we have a sign.

bool t_negative;

t_negative = false;

if (*s == '-' || *s == '+')

{

t_negative = (*s == '-');

s++;

l--;

}

if (l == 0)

return kMCExternalErrorNotANumber;

// Check to see what base we are using.

uint32_t t_base;

t_base = 10;

if (*s == '0')

{

if (l >= 2 && (s[1] == 'X' || s[1] == 'x'))

{

t_base = 16;

s += 2;

l -= 2;

}

else if (options_get_convert_octals(p_options))

{

t_base = 8;

s += 1;

l -= 1;

}

}

uint32_t t_value;

t_value = 0;

bool t_is_integer;

t_is_integer = true;

if (t_base == 10)

{

uint32_t sl;

sl = l;

while(l != 0 && isdigit(*s))

{

uint32_t t_new_value;

t_new_value = t_value * 10 + (*s - '0');

if (t_new_value < t_value)

return kMCExternalErrorNumericOverflow;

t_value = t_new_value;

s += 1;

l -= 1;

}

if (l != 0 && *s == '.')

{

if (sl <= 1)

return kMCExternalErrorNotANumber;

do

{

s += 1;

l -= 1;

if (l != 0 && *s != '0')

t_is_integer = false;

}

while(l != 0 && isdigit(*s));

}

}

else if (t_base == 16)

{

while(l != 0 && isxdigit(*s))

{

uint32_t t_new_value;

if (isdigit(*s))

t_new_value = t_value * 16 + (*s - '0');

else

t_new_value = t_value * 16 + (((*s) & ~32) - 'A');

if (t_new_value < t_value)

return kMCExternalErrorNumericOverflow;

t_value = t_new_value;

s += 1;

l -= 1;

}

}

else

{

while(l != 0 && isdigit(*s) && *s < '8')

{

uint32_t t_new_value;

t_new_value = t_value * 8 + (*s - '0');

if (t_new_value < t_value)

return kMCExternalErrorNumericOverflow;

t_value = t_new_value;

}

}

MCU_skip_spaces(s, l);

if (l != 0)

return kMCExternalErrorNotANumber;

if (!t_is_integer)

return kMCExternalErrorNotAnInteger;

if ((p_options & 0xf) == kMCExternalValueOptionAsInteger)

{

int32_t t_as_value;

if (t_negative)

{

if (t_value > 0x80000000U)

return kMCExternalErrorNumericOverflow;

t_as_value = -(int32_t)t_value;

}

else

{

if (t_value > MAXINT4)

return kMCExternalErrorNumericOverflow;

t_as_value = t_value;

}

*(int32_t *)r_value = t_as_value;

}

else

{

if (t_negative)

return kMCExternalErrorNumericOverflow;

*(uint32_t *)r_value = t_value;

}

return kMCExternalErrorNone;

}

static MCExternalError string_to_real(const MCString& p_string, MCExternalValueOptions p_options, void *r_value)

{

const char *s;

uint32_t l;

s = p_string . getstring();

l = p_string . getlength();

// Skip space before the number.

MCU_skip_spaces(s, l);

if (l == 0)

return kMCExternalErrorNotANumber;

// See if the number is negative.

bool t_negative;

t_negative = false;

if (*s == '-' || *s == '+')

{

t_negative = (*s == '-');

s++;

l--;

}

if (l == 0)

return kMCExternalErrorNotANumber;

// Now see if it has to be interpreted as an integer (0x or 0 prefix).

if (*s == '0' &&

(l >= 2 && (s[1] == 'X' || s[1] == 'x')) ||

options_get_convert_octals(p_options))

{

MCExternalError t_error;

uint32_t t_value;

t_error = string_to_integer(MCString(s, l), (p_options & ~0xf) | kMCExternalValueOptionAsCardinal, &t_value);

if (t_error != kMCExternalErrorNone)

return t_error;

*(double *)r_value = !t_negative ? (double)t_value : -(double)t_value;

return kMCExternalErrorNone;

}

// Otherwise we convert as a double - note that we need a NUL terminated

// string here so temporarily copy into a buffer...

char t_tmp_s[R8L];

uint32_t t_tmp_l;

t_tmp_l = MCU_min(R8L - 1U, l);

memcpy(t_tmp_s, s, t_tmp_l);

t_tmp_s[t_tmp_l] = '\0';

double t_value;

char *t_tmp_end;

t_value = strtod(t_tmp_s, &t_tmp_end);

s += t_tmp_end - t_tmp_s;

l -= t_tmp_end - t_tmp_s;

MCU_skip_spaces(s, l);

if (l != 0)

return kMCExternalErrorNotANumber;

*(double *)r_value = !t_negative ? t_value : -t_value;

return kMCExternalErrorNone;

}

static MCExternalError number_to_integer(double p_number, MCExternalValueOptions p_options, void *r_value)

{

bool t_negative;

if (p_number >= 0.0)

t_negative = false;

else

{

t_negative = true;

p_number = -p_number;

}

double t_integer, t_fraction;

t_fraction = modf(p_number, &t_integer);

uint32_t t_value;

if (t_fraction < MC_EPSILON)

t_value = (uint32_t)t_integer;

else if ((1.0 - t_fraction) < MC_EPSILON)

t_value = (uint32_t)t_integer + 1;

else

return kMCExternalErrorNotAnInteger;

if ((p_options & 0xf) == kMCExternalValueOptionAsInteger)

{

int32_t t_as_value;

if (t_negative)

{

if (t_value > 0x80000000U)

return kMCExternalErrorNumericOverflow;

t_as_value = -(int32_t)t_value;

}

else

{

if (t_value > MAXINT4)

return kMCExternalErrorNumericOverflow;

t_as_value = t_value;

}

*(int32_t *)r_value = t_as_value;

}

else

{

if (t_negative)

return kMCExternalErrorNumericOverflow;

*(uint32_t *)r_value = t_value;

}

return kMCExternalErrorNone;

}

static MCExternalError number_to_real(double p_number, MCExternalValueOptions p_options, void *r_value)

{

*(double *)r_value = p_number;

return kMCExternalErrorNone;

}

static void number_to_string(double p_number, MCExternalValueOptions p_options, char p_buffer[R8L])

{

switch(p_options & kMCExternalValueOptionNumberFormatMask)

{

case kMCExternalValueOptionDefaultNumberFormat:

{

char *v;

v = p_buffer;

uint4 l;

l = R8L;

MCU_r8tos(v, l, p_number, MCEPptr -> getnffw(), MCEPptr -> getnftrailing(), MCEPptr -> getnfforce());

}

break;

case kMCExternalValueOptionDecimalNumberFormat:

sprintf(p_buffer, "%f", p_number);

break;

case kMCExternalValueOptionScientificNumberFormat:

sprintf(p_buffer, "%e", p_number);

break;

case kMCExternalValueOptionCompactNumberFormat:

sprintf(p_buffer, "%0.16g", p_number);

break;

}

}

static MCExternalError fetch_as_string(MCExternalVariableRef p_var, MCExternalValueOptions p_options, void *r_value)

{

if (p_var -> is_number())

{

double t_number;

t_number = p_var -> get_real();

char t_buffer[R8L];

number_to_string(t_number, p_options, t_buffer);

if (!p_var -> assign_custom_both(t_buffer, t_number))

return kMCExternalErrorOutOfMemory;

if ((p_options & 0xf) == kMCExternalValueOptionAsString)

*(MCString *)r_value = p_var -> get_custom_string();

else

*(const char **)r_value = p_var -> get_custom_string() . getstring();

}

else if (p_var -> is_string())

{

if ((p_options & 0xf) == kMCExternalValueOptionAsString)

*(MCString *)r_value = p_var -> get_string();

else

{

if (memchr(p_var -> get_string() . getstring(), '\0', p_var -> get_string() . getlength()) != NULL)

return kMCExternalErrorNotACString;

if (!p_var -> ensure_cstring())

return kMCExternalErrorOutOfMemory;

*(const char **)r_value = p_var -> get_string() . getstring();

}

}

else

return kMCExternalErrorNotAString;

return kMCExternalErrorNone;

}

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

#if defined(TARGET_SUBPLATFORM_IPHONE)

extern bool iphone_run_on_main_thread(void *p_callback, void *p_callback_state, int p_options);

static MCExternalError MCExternalEngineRunOnMainThread(void *p_callback, void *p_callback_state, MCExternalRunOnMainThreadOptions p_options)

{

if (!iphone_run_on_main_thread(p_callback, p_callback_state, p_options))

return kMCExternalErrorNotImplemented;

return kMCExternalErrorNone;

}

#elif defined(TARGET_SUBPLATFORM_ANDROID)

extern bool android_run_on_main_thread(void *p_callback, void *p_callback_state, int p_options);

static MCExternalError MCExternalEngineRunOnMainThread(void *p_callback, void *p_callback_state, MCExternalRunOnMainThreadOptions p_options)

{

if (!android_run_on_main_thread(p_callback, p_callback_state, p_options))

return kMCExternalErrorNotImplemented;

return kMCExternalErrorNone;

}

#else

static MCExternalError MCExternalEngineRunOnMainThread(void *p_callback, void *p_callback_state, MCExternalRunOnMainThreadOptions p_options)

{

#if defined(_DESKTOP)

if (!MCNotifyPush((MCExternalThreadOptionalCallback)p_callback, p_callback_state, (p_options & kMCExternalRunOnMainThreadPost) == 0, true))

return kMCExternalErrorOutOfMemory;

return kMCExternalErrorNone;

#else

return kMCExternalErrorNotImplemented;

#endif

}

#endif

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

static MCExternalError MCExternalContextQuery(MCExternalContextQueryTag op, void *result)

{

switch(op)

{

case kMCExternalContextQueryMe:

{

MCObjectHandle *t_handle;

t_handle = MCEPptr -> getobj() -> gethandle();

if (t_handle == nil)

return kMCExternalErrorOutOfMemory;

*(MCObjectHandle **)result = t_handle;

}

break;

case kMCExternalContextQueryTarget:

{

MCObjectHandle *t_handle;

t_handle = MCtargetptr -> gethandle();

if (t_handle == nil)

return kMCExternalErrorOutOfMemory;

*(MCObjectHandle **)result = t_handle;

}

break;

case kMCExternalContextQueryResult:

*(MCExternalVariableRef *)result = &MCresult -> getvalue();

break;

case kMCExternalContextQueryIt:

{

MCVariable *t_var;

t_var = MCEPptr -> gethandler() -> getit();

*(MCExternalVariableRef *)result = (t_var != NULL) ? &t_var -> getvalue() : NULL;

}

break;

case kMCExternalContextQueryCaseSensitive:

*(bool *)result = MCEPptr -> getcasesensitive() == True;

break;

case kMCExternalContextQueryConvertOctals:

*(bool *)result = MCEPptr -> getconvertoctals() == True;

break;

case kMCExternalContextQueryItemDelimiter:

*(uint32_t *)result = MCEPptr -> getitemdel();

break;

case kMCExternalContextQueryLineDelimiter:

*(uint32_t *)result = MCEPptr -> getlinedel();

break;

case kMCExternalContextQueryColumnDelimiter:

*(uint32_t *)result = MCEPptr -> getcolumndel();

break;

case kMCExternalContextQueryRowDelimiter:

*(uint32_t *)result = MCEPptr -> getrowdel();

break;

case kMCExternalContextQueryDefaultStack:

{

if (MCdefaultstackptr == nil)

return kMCExternalErrorNoDefaultStack;

MCObjectHandle *t_handle;

t_handle = MCdefaultstackptr -> gethandle();

if (t_handle == nil)

return kMCExternalErrorOutOfMemory;

*(MCObjectHandle **)result = t_handle;

}

break;

case kMCExternalContextQueryDefaultCard:

{

if (MCdefaultstackptr == nil)

return kMCExternalErrorNoDefaultStack;

MCObjectHandle *t_handle;

t_handle = MCdefaultstackptr -> getcurcard() -> gethandle();

if (t_handle == nil)

return kMCExternalErrorOutOfMemory;

*(MCObjectHandle **)result = t_handle;

}

break;

default:

return kMCExternalErrorInvalidContextQuery;

}

return kMCExternalErrorNone;

}

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

struct MCTemporaryVariable: public MCVariableValue

{

uint32_t references;

};

static MCExternalError MCExternalVariableCreate(MCExternalVariableRef* r_var)

{

*r_var = new MCTemporaryVariable;

if (r_var == nil)

return kMCExternalErrorOutOfMemory;

(*r_var) -> set_external();

static_cast<MCTemporaryVariable *>(*r_var) -> references = 1;

return kMCExternalErrorNone;

}

static MCExternalError MCExternalVariableRetain(MCExternalVariableRef var)

{

if (var == nil)

return kMCExternalErrorNoVariable;

if (!var -> get_external())