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

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <stdint.h>

#ifdef __OBJC__

#import <Foundation/Foundation.h>

#endif

#include "LiveCode.h"

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

#undef __WINDOWS__

#undef __LINUX__

#undef __MAC__

#undef __IOS__

#undef __ANDROID__

#if defined(_MSC_VER) && !defined(WINCE)

#define __WINDOWS__ 1

#elif defined(__GNUC__) && defined(__APPLE__) && defined(TARGET_OS_MAC) && !defined(TARGET_OS_IPHONE)

#define __MAC__ 1

#elif defined(__GNUC__) && !defined(__APPLE__) && !defined(ANDROID)

#define __LINUX__ 1

#elif defined(__GNUC__) && defined(__APPLE__) && defined(TARGET_OS_MAC) && defined(TARGET_OS_IPHONE)

#define __IOS__ 1

#elif defined(ANDROID)

#define __ANDROID__ 1

#endif

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

#ifdef __WINDOWS__

#include <windows.h>

#define strcasecmp _stricmp

#else

#include <pthread.h>

#endif

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

#ifndef nil

#define nil NULL

#endif

#define BEGIN_EXTERN_C extern "C" {

#define END_EXTERN_C }

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

typedef struct __MCVariable *MCVariableRef;

typedef struct __MCVariableIterator *MCVariableIteratorRef;

typedef struct __MCObject *MCObjectRef;

typedef enum MCError

{

kMCErrorNone = 0,

kMCErrorOutOfMemory = 1,

kMCErrorNotImplemented = 2,

kMCErrorNoVariable = 3,

kMCErrorNoValue = 4,

kMCErrorNoIterator = 5,

kMCErrorNoBuffer = 6,

kMCErrorNotAnExternalTemporary = 7,

kMCErrorInvalidValueType = 8,

kMCErrorNotABoolean = 9,

kMCErrorNotANumber = 10,

kMCErrorNotAnInteger = 11,

kMCErrorNotAString = 12,

kMCErrorNotACString = 13,

kMCErrorNotAnArray = 14,

kMCErrorDstNotAString = 15,

kMCErrorNumericOverflow = 16,

kMCErrorInvalidCovertOctalsOption = 17,

kMCErrorInvalidCaseSensitiveOption = 18,

kMCErrorInvalidVariableQuery = 19,

kMCErrorInvalidContextQuery = 20,

kMCErrorVariableNoLongerExists = 21,

kMCErrorVariableInvalidEdit = 22,

kMCErrorNoObject = 23,

kMCErrorNoObjectId = 24,

kMCErrorNoObjectMessage = 25,

kMCErrorNoObjectArguments = 26,

kMCErrorMalformedObjectChunk = 27,

kMCErrorCouldNotResolveObject = 28,

kMCErrorObjectDoesNotExist = 29,

kMCErrorNoDefaultStack = 30,

kMCErrorAborted = 31,

kMCErrorFailed = 32,

kMCErrorExited = 33,

kMCErrorNoObjectProperty = 34,

kMCErrorNoObjectPropertyValue = 35,

kMCErrorInvalidInterfaceQuery = 36,

kMCErrorNotSupported = 37,

kMCErrorUnlicensed = 42,

} MCError;

typedef uint32_t MCValueOptions;

enum

{

kMCOptionAsVariable = 0,

kMCOptionAsBoolean = 1,

kMCOptionAsInteger = 2,

kMCOptionAsCardinal = 3,

kMCOptionAsReal = 4,

kMCOptionAsString = 5,

kMCOptionAsCString = 6,

// SN-2014-07-01: [[ ExternalsApiV6 ]] New encoding for the strings

// and addition of the possibility to handle Obj-C parameter

kMCOptionAsUTF8String = 7,

kMCOptionAsUTF8CString = 8,

kMCOptionAsUTF16String = 9,

kMCOptionAsUTF16CString = 10,

// SN-2014-07-16: [[ ExternalsApiV6 ]] Update the numbering of the enum

// to match the enum in externalv1.cpp

// SN-2015-01-19: [[ Bug 14057 ]] Do not modify the enum in Support.mm,

// to avoid breaking backward-compatibility.

kMCOptionAsObjcNumber = 17,

kMCOptionAsObjcString = 18,

kMCOptionAsObjcData = 19,

kMCOptionAsObjcArray = 20,

kMCOptionAsObjcDictionary = 21,

// SN-2015-02-13: [[ Bug 14057 ]] Added forgotten C-char type

kMCOptionAsCChar = 22,

// SN-2015-02-13:[[ Bug 14057 ]] Added CF-types (non-releasing)

kMCOptionAsCFNumber = 23,

kMCOptionAsCFString = 24,

kMCOptionAsCFData = 25,

kMCOptionAsCFArray = 26,

kMCOptionAsCFDictionary = 27,

kMCOptionAsNothing = 28,

kMCOptionNumberFormatDefault = 0 << 26,

kMCOptionNumberFormatDecimal = 1 << 26,

kMCOptionNumberFormatScientific = 2 << 26,

kMCOptionNumberFormatGeneral = 3 << 26,

kMCOptionConvertOctalsDefault = 0 << 28,

kMCOptionConvertOctalsTrue = 1 << 28,

kMCOptionConvertOctalsFalse = 2 << 28,

kMCOptionCaseSensitiveDefault = 0 << 30,

kMCOptionCaseSensitiveTrue = 1 << 30,

kMCOptionCaseSensitiveFalse = 2 << 30

};

typedef enum MCDispatchType

{

kMCDispatchTypeCommand = 0,

kMCDispatchTypeFunction = 1

} MCDispatchType;

typedef enum MCDispatchStatus

{

kMCDispatchStatusHandled = 0,

kMCDispatchStatusNotHandled = 1,

kMCDispatchStatusPassed = 2,

kMCDispatchStatusError = 3,

kMCDispatchStatusExit = 4,

kMCDispatchStatusAbort = 5,

} MCDispatchStatus;

enum

{

kMCRunOnMainThreadSend = 0 << 0,

kMCRunOnMainThreadPost = 1 << 0,

kMCRunOnMainThreadOptional = 0 << 1,

kMCRunOnMainThreadRequired = 1 << 1,

kMCRunOnMainThreadSafe = 0 << 2,

kMCRunOnMainThreadUnsafe = 1 << 2,

kMCRunOnMainThreadImmediate = 0 << 3,

kMCRunOnMainThreadDeferred = 1 << 3,

kMCRunOnMainThreadJumpToUI = 1 << 4,

kMCRunOnMainThreadJumpToEngine = 2 << 4,

};

typedef struct MCExternalHandler

{

uint32_t type;

const char *name;

bool (*function)(MCVariableRef *, uint32_t, MCVariableRef);

} MCExternalHandler;

typedef enum MCExternalContextVar

{

kMCExternalContextVarMe = 1,

kMCExternalContextVarTarget = 2,

kMCExternalContextVarResult = 3,

kMCExternalContextVarIt = 4,

kMCExternalContextVarCaseSensitive = 5,

kMCExternalContextVarConvertOctals = 6,

kMCExternalContextVarNumberFormat = 7,

kMCExternalContextVarItemDelimiter = 8,

kMCExternalContextVarLineDelimiter = 9,

kMCExternalContextVarColumnDelimiter = 10,

kMCExternalContextVarRowDelimiter = 11,

kMCExternalContextVarDefaultStack = 12,

kMCExternalContextVarDefaultCard = 13,

kMCExternalContextVarWholeMatches = 14,

// SN-2015-01-19: [[ Bug 14057 ]] Add the enum for the

// unicode delimiters.

kMCExternalContextVarUnicodeItemDelimiter = 15,

kMCExternalContextVarUnicodeLineDelimiter = 16,

kMCExternalContextVarUnicodeColumnDelimiter = 17,

kMCExternalContextVarUnicodeRowDelimiter = 18,

kMCExternalContextVarHasLicenseCheck = 19,

} MCExternalContextVar;

typedef enum MCExternalVariableQuery

{

kMCExternalVariableQueryIsTemporary = 1,

kMCExternalVariableQueryIsTransient = 2,

kMCExternalVariableQueryFormat = 3,

kMCExternalVariableQueryRetention = 4,

kMCExternalVariableQueryIsAnArray = 5,

kMCExternalVariableQueryIsASequence = 6,

kMCExternalVariableQueryIsEmpty = 7,

} MCExternalVariableQuery;

typedef enum MCExternalInterfaceQuery

{

kMCExternalInterfaceQueryView = 1,

kMCExternalInterfaceQueryViewScale = 2,

kMCExternalInterfaceQueryViewController = 3,

kMCExternalInterfaceQueryActivity = 4,

kMCExternalInterfaceQueryContainer = 5,

kMCExternalInterfaceQueryScriptJavaEnv = 6,

kMCExternalInterfaceQuerySystemJavaEnv = 7,

kMCExternalInterfaceQueryEngine = 8,

} MCExternalInterfaceQuery;

enum

{

kMCExternalObjectUpdateOptionRect = 1 << 0,

};

typedef struct MCExternalInterface

{

uint32_t version;

MCError (*engine_run_on_main_thread)(void *callback, void *callback_state, uint32_t options);

// SN-2015-01-26: [[ Bug 14057 ]] Former context query set as legacy function

MCError (*context_query_legacy)(MCExternalContextVar op, void *result);

MCError (*variable_create)(MCVariableRef* var);

MCError (*variable_retain)(MCVariableRef var);

MCError (*variable_release)(MCVariableRef var);

MCError (*variable_query)(MCVariableRef var, MCExternalVariableQuery query, void *result);

MCError (*variable_clear)(MCVariableRef var);

MCError (*variable_exchange)(MCVariableRef var_a, MCVariableRef var_b);

MCError (*variable_store)(MCVariableRef var, MCValueOptions options, void *value);

MCError (*variable_fetch)(MCVariableRef var, MCValueOptions options, void *value);

MCError (*variable_append)(MCVariableRef var, MCValueOptions options, void *value);

MCError (*variable_prepend)(MCVariableRef var, MCValueOptions options, void *value);

MCError (*variable_edit)(MCVariableRef var, MCValueOptions options, uint32_t reserve_length, void **r_buffer, uint32_t *r_current_length);

MCError (*variable_count_keys)(MCVariableRef var, uint32_t* r_count);

MCError (*variable_iterate_keys)(MCVariableRef var, MCVariableIteratorRef *iterator, MCValueOptions options, void *key, MCVariableRef *r_value);

MCError (*variable_remove_key)(MCVariableRef var, MCValueOptions options, void *key);

MCError (*variable_lookup_key)(MCVariableRef var, MCValueOptions options, void *key, bool p_ensure, MCVariableRef *r_var);

MCError (*object_resolve)(const char *chunk, MCObjectRef* r_object);

MCError (*object_exists)(MCObjectRef object, bool *r_exists);

MCError (*object_retain)(MCObjectRef object);

MCError (*object_release)(MCObjectRef object);

MCError (*object_dispatch)(MCObjectRef object, MCDispatchType type, const char *message, MCVariableRef *argv, uint32_t argc, MCDispatchStatus *r_status);

MCError (*wait_run)(void *unused, unsigned int options);

MCError (*wait_break)(void *unused, unsigned int options);

MCError (*object_get)(MCObjectRef object, unsigned int options, const char *name, const char *key, MCVariableRef value);

MCError (*object_set)(MCObjectRef object, unsigned int options, const char *name, const char *key, MCVariableRef value);

MCError (*interface_query)(MCExternalInterfaceQuery query, void *result);

MCError (*object_update)(MCObjectRef object, unsigned int options, void *region);

// MW-2013-06-14: [[ ExternalsApiV5 ]] New context methods for script execution.

MCError (*context_evaluate)(const char *p_expression, unsigned int options, MCVariableRef *binds, unsigned int bind_count, MCVariableRef result);

MCError (*context_execute)(const char *p_expression, unsigned int options, MCVariableRef *binds, unsigned int bind_count);

// SN-2015-01-26: [[ Bug 14057 ]] Added new function in the API v6, to allow the users to choose their return type (for the delimiters)

MCError (*context_query)(MCExternalContextVar op, MCValueOptions p_options, void *result);

// MW-2016-02-17: [[ LicenseCheck ]] Method to check the engine's license

MCError (*license_check_edition)(unsigned int options, unsigned int min_edition);

} MCExternalInterface;

typedef struct MCExternalInfo

{

uint32_t version;

uint32_t flags;

const char *name;

MCExternalHandler *handlers;

} MCExternalInfo;

typedef struct MCExternalLibraryExport

{

const char *name;

void *address;

} MCExternalLibraryExport;

typedef struct MCExternalLibraryInfo

{

const char **name;

struct MCExternalLibraryExport *exports;

} MCExternalLibraryInfo;

static MCExternalInterface *s_interface = 0;

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

static MCError MCVariableCreate(MCVariableRef *r_var)

{

return s_interface -> variable_create(r_var);

}

static MCError MCVariableRetain(MCVariableRef var)

{

return s_interface -> variable_retain(var);

}

static MCError MCVariableRelease(MCVariableRef var)

{

return s_interface -> variable_release(var);

}

static MCError MCVariableClear(MCVariableRef var)

{

return s_interface -> variable_clear(var);

}

static MCError MCVariableIsTransient(MCVariableRef var, bool *r_transient)

{

return s_interface -> variable_query(var, kMCExternalVariableQueryIsTransient, r_transient);

}

static MCError MCVariableIsEmpty(MCVariableRef var, bool *r_empty)

{

return s_interface -> variable_query(var, kMCExternalVariableQueryIsEmpty, r_empty);

}

static MCError MCVariableIsAnArray(MCVariableRef var, bool *r_array)

{

return s_interface -> variable_query(var, kMCExternalVariableQueryIsAnArray, r_array);

}

static MCError MCVariableIsASequence(MCVariableRef var, bool *r_sequence)

{

return s_interface -> variable_query(var, kMCExternalVariableQueryIsASequence, r_sequence);

}

static MCError MCVariableStore(MCVariableRef var, MCValueOptions options, void *value)

{

return s_interface -> variable_store(var, options, value);

}

static MCError MCVariableFetch(MCVariableRef var, MCValueOptions options, void *value)

{

return s_interface -> variable_fetch(var, options, value);

}

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

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

BEGIN_EXTERN_C

// MW-2013-06-14: [[ ExternalsApiV5 ]] New methods to convert to/from an internal

// variable.

static LCError LCValueFetch(MCVariableRef var, unsigned int options, void *r_value);

static LCError LCValueStore(MCVariableRef var, unsigned int options, void *r_value);

// SN-2014-07-01: [[ ExternalsApiV6 ]] Keep the pre-7.0 way to build arrays in case

// the engine is pre-7.0

#ifdef __OBJC__

// MW-2013-06-14: [[ ExternalsApiV5 ]] New methods to convert to/from objc-arrays

// and dictionaries.

static LCError LCValueArrayToObjcArray(MCVariableRef src, NSArray*& r_dst);

static LCError LCValueArrayFromObjcArray(MCVariableRef src, NSArray* r_dst);

static LCError LCValueArrayToObjcDictionary(MCVariableRef src, NSDictionary*& r_dst);

static LCError LCValueArrayFromObjcDictionary(MCVariableRef src, NSDictionary* r_dst);

// Convert a LiveCode value into an element of an Objc Array/Dictionary. This

// converts all non-array values to strings, arrays which are sequences to

// NSArray, and arrays which are maps to NSDictionary.

static LCError LCValueArrayValueToObjcValue(MCVariableRef var, id& r_dst)

{

MCError t_error;

t_error = kMCErrorNone;

if (t_error == kMCErrorNone)

{

bool t_is_empty;

t_error = MCVariableIsEmpty(var, &t_is_empty);

if (t_error == kMCErrorNone && t_is_empty)

{

r_dst = @"";

return kLCErrorNone;

}

}

if (t_error == kMCErrorNone)

{

bool t_is_array;

t_error = MCVariableIsAnArray(var, &t_is_array);

if (t_error == kMCErrorNone && !t_is_array)

return LCValueFetch(var, kLCValueOptionAsObjcString, &r_dst);

}

if (t_error == kMCErrorNone)

{

bool t_is_sequence;

t_error = MCVariableIsASequence(var, &t_is_sequence);

if (t_error == kMCErrorNone && t_is_sequence)

return LCValueArrayToObjcArray(var, (NSArray*&)r_dst);

}

if (t_error == kMCErrorNone)

return LCValueArrayToObjcDictionary(var, (NSDictionary*&)r_dst);

return (LCError)t_error;

}

static LCError LCValueArrayValueFromObjcValue(MCVariableRef var, id src)

{

if ([src isKindOfClass: [NSNull class]])

return (LCError)MCVariableClear(var);

if ((CFBooleanRef)src == kCFBooleanTrue || (CFBooleanRef)src == kCFBooleanFalse)

{

bool t_bool;

t_bool = (CFBooleanRef)src == kCFBooleanTrue;

return LCValueStore(var, kLCValueOptionAsBoolean, &t_bool);

}

if ([src isKindOfClass: [NSNumber class]])

return LCValueStore(var, kLCValueOptionAsObjcNumber, &src);

if ([src isKindOfClass: [NSString class]])

return LCValueStore(var, kLCValueOptionAsObjcString, &src);

if ([src isKindOfClass: [NSData class]])

return LCValueStore(var, kLCValueOptionAsObjcData, &src);

if ([src isKindOfClass: [NSArray class]])

return LCValueArrayFromObjcArray(var, (NSArray *)src);

if ([src isKindOfClass: [NSDictionary class]])

return LCValueArrayFromObjcDictionary(var, (NSDictionary *)src);

NSString *t_as_string;

t_as_string = [src description];

return LCValueStore(var, kLCValueOptionAsObjcString, &t_as_string);

}

// Convert a LiveCode array into an NSArray. The returned NSArray is alloc'd.

static LCError LCValueArrayToObjcArray(MCVariableRef src, NSArray*& r_dst)

{

LCError t_error;

t_error = kLCErrorNone;

if (t_error == kLCErrorNone)

{

bool t_is_sequence;

t_error = (LCError)MCVariableIsASequence(src, &t_is_sequence);

if (t_error == kLCErrorNone && !t_is_sequence)

t_error = kLCErrorNotASequence;

}

uint32_t t_count;

t_count = 0;

if (t_error == kLCErrorNone)

t_error = (LCError)s_interface -> variable_count_keys(src, &t_count);

id *t_objects;

t_objects = nil;

if (t_error == kLCErrorNone)

{

t_objects = (id *)calloc(sizeof(id), t_count);

if (t_objects == nil)

t_error = kLCErrorOutOfMemory;

}

MCVariableIteratorRef t_iterator;

t_iterator = nil;

for(uint32_t i = 0; i < t_count && t_error == kLCErrorNone; i++)

{

// Fetch the key and value.

const char *t_key;

MCVariableRef t_value;

if (t_error == kLCErrorNone)

t_error = (LCError)s_interface -> variable_iterate_keys(src, &t_iterator, kMCOptionAsCString, &t_key, &t_value);

// Now convert the value - remembering that LC sequences are 1 based, and

// Objc arrays are 0 based. Note that we don't have to validate the key as

// its guaranteed to be of the correct form as we checked the array was a

// sequence.

if (t_error == kLCErrorNone)

t_error = LCValueArrayValueToObjcValue(t_value, t_objects[strtoul(t_key, nil, 10) - 1]);

}

// If we succeeded, then try to build an NSArray.

NSArray *t_array;

if (t_error == kLCErrorNone)

{

t_array = [[NSArray alloc] initWithObjects: t_objects count: t_count];

if (t_array == nil)

t_error = kLCErrorOutOfMemory;

}

if (t_error == kLCErrorNone)

r_dst = t_array;

// We free the objects array since its copied by NSArray.

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

[t_objects[i] release];

free(t_objects);

return t_error;

}

static LCError LCValueArrayFromObjcArray(MCVariableRef var, NSArray *src)

{

LCError t_error;

t_error = kLCErrorNone;

for(unsigned int t_index = 0; t_index < [src count] && t_error == kLCErrorNone; t_index++)

{

// We need to pass a pointer to the buffer variable to the lookup call so

// we use an array big enough to store an integer as a string and then

// assign that to a ptr var.

char t_key[12];

char *t_key_ptr;

t_key_ptr = t_key;

if (t_error == kLCErrorNone)

sprintf(t_key, "%u", t_index + 1);

MCVariableRef t_value;

if (t_error == kLCErrorNone)

t_error = (LCError)s_interface -> variable_lookup_key(var, kMCOptionAsCString, (void*)&t_key_ptr, true, &t_value);

if (t_error == kLCErrorNone)

t_error = LCValueArrayValueFromObjcValue(t_value, [src objectAtIndex: t_index]);

}

return t_error;

}

static LCError LCValueArrayToObjcDictionary(MCVariableRef src, NSDictionary*& r_dst)

{

LCError t_error;

t_error = kLCErrorNone;

uint32_t t_count;

t_count = 0;

if (t_error == kLCErrorNone)

t_error = (LCError)s_interface -> variable_count_keys(src, &t_count);

id *t_keys, *t_values;

t_keys = t_values = nil;

if (t_error == kLCErrorNone)

{

t_keys = (id *)calloc(sizeof(id), t_count);

t_values = (id *)calloc(sizeof(id), t_count);

if (t_keys == nil || t_values == nil)

t_error = kLCErrorOutOfMemory;

}

MCVariableIteratorRef t_iterator;

t_iterator = nil;

for(uint32_t i = 0; i < t_count && t_error == kLCErrorNone; i++)

{

// Fetch the key and value.

const char *t_key;

MCVariableRef t_value;

if (t_error == kLCErrorNone)

t_error = (LCError)s_interface -> variable_iterate_keys(src, &t_iterator, kMCOptionAsCString, &t_key, &t_value);

// Convert the key.

if (t_error == kLCErrorNone)

{

t_keys[i] = [[NSString alloc] initWithCString: t_key encoding: NSMacOSRomanStringEncoding];

if (t_keys[i] == nil)

t_error = kLCErrorOutOfMemory;

}

// Now convert the value.

if (t_error == kLCErrorNone)

t_error = LCValueArrayValueToObjcValue(t_value, t_values[i]);

}

// If we succeeded then build the dictionary.

NSDictionary *t_dictionary;

if (t_error == kLCErrorNone)

{

t_dictionary = [[NSDictionary alloc] initWithObjects: t_values forKeys: t_keys count: t_count];

if (t_dictionary == nil)

t_error = kLCErrorOutOfMemory;

}

if (t_error == kLCErrorNone)

r_dst = t_dictionary;

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

{

[t_keys[i] release];

[t_values[i] release];

}

free(t_keys);

free(t_values);

return t_error;

}

static LCError LCValueArrayFromObjcDictionary(MCVariableRef var, NSDictionary *p_src)

{

LCError t_error;

t_error = kLCErrorNone;

NSAutoreleasePool *t_pool;

t_pool = [[NSAutoreleasePool alloc] init];

#ifndef __OBJC2__

NSEnumerator *t_enumerator;

t_enumerator = [p_src keyEnumerator];

for(;;)

{

id t_key;

t_key = [t_enumerator nextObject];

if (t_key == nil)

break;

#else

for(id t_key in p_src)

{

#endif

if (t_error == kLCErrorNone && ![t_key isKindOfClass: [NSString class]])

t_error = kLCErrorCannotEncodeMap;

const char *t_key_cstring;

if (t_error == kLCErrorNone)

{

t_key_cstring = [(NSString *)t_key cStringUsingEncoding: NSMacOSRomanStringEncoding];

if (t_key_cstring == nil)

t_error = kLCErrorCannotEncodeCString;

}

MCVariableRef t_value;

if (t_error == kLCErrorNone)

t_error = (LCError)s_interface -> variable_lookup_key(var, kMCOptionAsCString, (void *)&t_key_cstring, true, &t_value);

if (t_error == kLCErrorNone)

t_error = LCValueArrayValueFromObjcValue(t_value, [p_src objectForKey: t_key]);

}

[t_pool release];

return t_error;

}

#endif

static unsigned int LCValueOptionsGetCaseSensitive(unsigned int p_options)

{

if ((p_options & kLCValueOptionMaskCaseSensitive) == 0)

return kMCOptionCaseSensitiveFalse;

return ((p_options & kLCValueOptionMaskCaseSensitive) + (1 << 30)) & kLCValueOptionMaskCaseSensitive;

}

static unsigned int LCValueOptionsGetConvertOctals(unsigned int p_options)

{

if ((p_options & kLCValueOptionMaskConvertOctals) == 0)

return kLCValueOptionConvertOctalsFalse;

return ((p_options & kLCValueOptionMaskConvertOctals) + (1 << 30)) & kLCValueOptionMaskConvertOctals;

}

static unsigned int LCValueOptionsGetNumberFormat(unsigned int p_options)

{

if ((p_options & kLCValueOptionMaskNumberFormat) == 0)

return kLCValueOptionConvertOctalsFalse;

return ((p_options & kLCValueOptionMaskNumberFormat) + (1 << 26)) & kLCValueOptionMaskNumberFormat;

}

static LCError LCValueFetch(MCVariableRef p_var, unsigned int p_options, void *r_value)

{

LCError t_error;

t_error = kLCErrorNone;

unsigned int t_options_to_use;

void *t_value_to_use;

union

{

double t_number_value;

LCBytes t_cdata_value;

char *t_cstring_value;

MCVariableRef t_array_value;

};

if (t_error == kLCErrorNone)

{

switch(p_options & kLCValueOptionMaskAs)

{

case kLCValueOptionAsBoolean:

t_options_to_use = kMCOptionAsBoolean;

t_value_to_use = r_value;

break;

case kLCValueOptionAsInteger:

t_options_to_use = kMCOptionAsInteger;

t_options_to_use |= LCValueOptionsGetConvertOctals(p_options);

t_value_to_use = r_value;

break;

case kLCValueOptionAsReal:

t_options_to_use = kMCOptionAsReal;

t_options_to_use |= LCValueOptionsGetConvertOctals(p_options);

t_value_to_use = r_value;

break;

case kLCValueOptionAsCData:

t_options_to_use = kMCOptionAsString;

t_options_to_use |= LCValueOptionsGetNumberFormat(p_options);

t_value_to_use = &t_cdata_value;

break;

case kLCValueOptionAsCString:

t_options_to_use = kMCOptionAsCString;

t_options_to_use |= LCValueOptionsGetNumberFormat(p_options);

t_value_to_use = &t_cstring_value;

break;

case kLCValueOptionAsCChar:

t_options_to_use = kMCOptionAsString;

t_options_to_use |= LCValueOptionsGetNumberFormat(p_options);

t_value_to_use = &t_cdata_value;

break;

case kLCValueOptionAsLCArray:

t_options_to_use = kMCOptionAsVariable;

t_error = (LCError)MCVariableCreate(&t_array_value);

t_value_to_use = t_array_value;

break;

// SN-2014-07-01: [[ ExternalsApiV6 ]] Handling unicode types

// There is no need to duplicate the strings fetched from the variable

// since the Unicode strings are already user-free'd

case kLCValueOptionAsUTF8CData:

t_options_to_use = kMCOptionAsUTF8String;

t_options_to_use |= LCValueOptionsGetNumberFormat(p_options);

t_value_to_use = r_value;

break;

case kLCValueOptionAsUTF8CString:

t_options_to_use = kMCOptionAsUTF8CString;

t_options_to_use |= LCValueOptionsGetNumberFormat(p_options);

t_value_to_use = r_value;

break;

case kLCValueOptionAsUTF16CData:

t_options_to_use = kMCOptionAsUTF16String;

t_options_to_use |= LCValueOptionsGetNumberFormat(p_options);

t_value_to_use = r_value;

break;

case kLCValueOptionAsUTF16CString:

t_options_to_use = kMCOptionAsUTF16CString;

t_options_to_use |= LCValueOptionsGetNumberFormat(p_options);

t_value_to_use = r_value;

break;

#ifdef __OBJC__

// SN-2014-07-01: [[ ExternalsApiV6 ]] Obj-C types can now be returned when asked so

// so no further conversion is required

case kLCValueOptionAsObjcNumber:

if (s_interface -> version < 6)

{

t_options_to_use = kMCOptionAsReal;

t_value_to_use = &t_number_value;

}

else

{

t_options_to_use = kMCOptionAsObjcNumber;

t_options_to_use |= LCValueOptionsGetConvertOctals(p_options);

t_value_to_use = r_value;

}

break;

case kLCValueOptionAsObjcString:

if (s_interface -> version < 6)

{

t_options_to_use = kMCOptionAsCString;

t_value_to_use = &t_cstring_value;

}

else

{

t_options_to_use = kMCOptionAsObjcString;

t_options_to_use |= LCValueOptionsGetNumberFormat(p_options);

t_value_to_use = r_value;

}

break;

case kLCValueOptionAsObjcData:

if (s_interface -> version < 6)

{

t_options_to_use = kMCOptionAsString;

t_value_to_use = &t_cdata_value;

}

else

{

t_options_to_use = kMCOptionAsObjcData;

t_options_to_use |= LCValueOptionsGetNumberFormat(p_options);

t_value_to_use = r_value;

}

break;

case kLCValueOptionAsObjcArray:

if (s_interface -> version < 6)

{

t_options_to_use = kMCOptionAsVariable;

t_error = (LCError)MCVariableCreate(&t_array_value);

t_value_to_use = t_array_value;

}

else

{

t_options_to_use = kMCOptionAsObjcArray;

t_value_to_use = r_value;

}

break;

case kLCValueOptionAsObjcDictionary:

if (s_interface -> version < 6)

{

t_options_to_use = kMCOptionAsVariable;

t_error = (LCError)MCVariableCreate(&t_array_value);

t_value_to_use = t_array_value;

}

else

{

t_options_to_use = kMCOptionAsObjcDictionary;

t_value_to_use = r_value;

}

break;

#endif

default:

t_error = kLCErrorBadValueOptions;

}

if (t_error == kLCErrorNone)

t_error = (LCError)s_interface -> variable_fetch(p_var, t_options_to_use, t_value_to_use);

}

// If the output value pointer was the one passed in, we are done.

if (t_error == kLCErrorNone && t_value_to_use == r_value)

return kLCErrorNone;

// Otherwise we need to process the output value.

if (t_error == kLCErrorNone)

{

switch(p_options & kLCValueOptionMaskAs)

{

case kLCValueOptionAsCString:

t_cstring_value = strdup(t_cstring_value);

if (t_cstring_value != nil)

*(char **)r_value = t_cstring_value;

else

t_error = kLCErrorOutOfMemory;

break;

case kLCValueOptionAsCData:

{

void *t_buffer;

t_buffer = malloc(t_cdata_value . length);

if (t_buffer != nil)

{

memcpy(t_buffer, t_cdata_value . buffer, t_cdata_value . length);

((LCBytes *)r_value) -> buffer = t_buffer;

((LCBytes *)r_value) -> length = t_cdata_value . length;

}

else

t_error = kLCErrorOutOfMemory;

}

break;

case kLCValueOptionAsCChar:

{

if (t_cdata_value . length == 1)

*(char *)r_value = *(char *)t_cdata_value . buffer;

else

t_error = kLCErrorNotAChar;

}

break;

case kLCValueOptionAsLCArray:

{

// Check the value is actually an array.

bool t_is_array;

t_is_array = false;

if (t_error == kLCErrorNone)

t_error = (LCError)MCVariableIsAnArray(t_array_value, &t_is_array);

if (t_error == kLCErrorNone && !t_is_array)

t_error = kLCErrorNotAnArray;

// Now clone the array.

MCVariableRef t_var_copy;

t_var_copy = nil;

if (t_error == kLCErrorNone)

t_error = (LCError)MCVariableCreate(&t_var_copy);

if (t_error == kLCErrorNone)

t_error = (LCError)MCVariableStore(t_var_copy, kMCOptionAsVariable, t_array_value);

if (t_error == kLCErrorNone)

*(LCArrayRef *)r_value = (LCArrayRef)t_array_value;

else

{

// Make sure we free the array if there's a problem.

if (t_var_copy != nil)

MCVariableRelease(t_var_copy);

}

}

break;

}

// SN-2014-07-01: [[ ExternalsApiV6 ]] Obj-C types now passed straight to the externals

// but we want to keep the old code for the former externals

#ifdef __OBJC__

if (s_interface -> version < 6)

{

switch (p_options & kLCValueOptionMaskAs)

{

case kLCValueOptionAsObjcNumber:

*(NSNumber **)r_value = [NSNumber numberWithDouble: t_number_value];

break;

case kLCValueOptionAsObjcString:

*(NSString **)r_value = [NSString stringWithCString: t_cstring_value encoding: NSMacOSRomanStringEncoding];

break;

case kLCValueOptionAsObjcData:

*(NSData **)r_value = [NSData dataWithBytes: t_cdata_value . buffer length: t_cdata_value . length];

break;

case kLCValueOptionAsObjcArray:

t_error = LCValueArrayToObjcArray(t_array_value, *(NSArray **)r_value);

if (t_error == kLCErrorNone)

[*(NSArray **)r_value autorelease];

break;

case kLCValueOptionAsObjcDictionary:

t_error = LCValueArrayToObjcDictionary(t_array_value, *(NSDictionary **)r_value);

if (t_error == kLCErrorNone)

[*(NSDictionary **)r_value autorelease];

break;

}

}

#endif

}

return t_error;

}

static LCError LCValueStore(MCVariableRef p_var, unsigned int p_options, void *p_value)

{

LCError t_error;

t_error = kLCErrorNone;

unsigned int t_options_to_use;

void *t_value_to_use;

union

{

double t_number_value;

const char *t_cstring_value;

LCBytes t_cdata_value;

};

switch(p_options & kLCValueOptionMaskAs)

{

case kLCValueOptionAsBoolean:

case kLCValueOptionAsInteger:

case kLCValueOptionAsReal:

case kLCValueOptionAsCString:

case kLCValueOptionAsCData:

// SN-2014-07-01: [[ ExternalsApiV6 ]] Obj-C types can now be passed as parameter to the externals

// and unicode-encoded string/data exist as well

case kLCValueOptionAsUTF8CData:

case kLCValueOptionAsUTF8CString:

case kLCValueOptionAsUTF16CData:

case kLCValueOptionAsUTF16CString:

t_options_to_use = p_options & kLCValueOptionMaskAs;

t_value_to_use = p_value;

break;

case kLCValueOptionAsCChar:

t_options_to_use = kMCOptionAsString;

t_value_to_use = &t_cdata_value;

t_cdata_value . buffer = p_value;

t_cdata_value . length = 1;

break;

case kLCValueOptionAsLCArray:

t_options_to_use = kMCOptionAsVariable;

t_value_to_use = *(void **)p_value;

break;

#ifdef __OBJC__

case kLCValueOptionAsObjcNumber:

if (s_interface -> version >= 6)