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

#include "globdefs.h"

#include "filedefs.h"

#include "objdefs.h"

#include "parsedef.h"

#include "mcio.h"

#include "dispatch.h"

#include "stack.h"

#include "tooltip.h"

#include "card.h"

#include "field.h"

#include "button.h"

#include "image.h"

#include "aclip.h"

#include "vclip.h"

#include "stacklst.h"

#include "mcerror.h"

#include "hc.h"

#include "util.h"

#include "param.h"

#include "debug.h"

#include "statemnt.h"

#include "funcs.h"

#include "magnify.h"

#include "sellst.h"

#include "undolst.h"

#include "styledtext.h"

#include "external.h"

#include "osspec.h"

#include "flst.h"

#include "globals.h"

#include "license.h"

#include "mode.h"

#include "redraw.h"

#include "printer.h"

#include "font.h"

#include "stacksecurity.h"

#include "scriptpt.h"

#include "widget-events.h"

#include "exec.h"

#include "exec-interface.h"

#include "graphics_util.h"

#include "stackfileformat.h"

#define UNLICENSED_TIME 6.0

#ifdef _DEBUG_MALLOC_INC

#define LICENSED_TIME 1.0

#else

#define LICENSED_TIME 3.0

#endif

MCImage *MCDispatch::imagecache;

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

MCPropertyInfo MCDispatch::kProperties[] =

{

DEFINE_RO_OBJ_PROPERTY(P_TEXT_FONT, String, MCDispatch, DefaultTextFont)

DEFINE_RO_OBJ_PROPERTY(P_TEXT_SIZE, UInt32, MCDispatch, DefaultTextSize)

DEFINE_RO_OBJ_ENUM_PROPERTY(P_TEXT_ALIGN, InterfaceTextAlign, MCDispatch, DefaultTextAlign)

DEFINE_RO_OBJ_CUSTOM_PROPERTY(P_TEXT_STYLE, InterfaceTextStyle, MCDispatch, DefaultTextStyle)

DEFINE_RO_OBJ_PROPERTY(P_TEXT_HEIGHT, UInt32, MCDispatch, DefaultTextHeight)

DEFINE_RO_OBJ_PROPERTY(P_FORE_PIXEL, UInt32, MCDispatch, DefaultForePixel)

DEFINE_RO_OBJ_PROPERTY(P_HILITE_PIXEL, UInt32, MCDispatch, DefaultForePixel)

DEFINE_RO_OBJ_PROPERTY(P_BORDER_PIXEL, UInt32, MCDispatch, DefaultForePixel)

DEFINE_RO_OBJ_PROPERTY(P_BOTTOM_PIXEL, UInt32, MCDispatch, DefaultForePixel)

DEFINE_RO_OBJ_PROPERTY(P_SHADOW_PIXEL, UInt32, MCDispatch, DefaultForePixel)

DEFINE_RO_OBJ_PROPERTY(P_FOCUS_PIXEL, UInt32, MCDispatch, DefaultForePixel)

DEFINE_RO_OBJ_PROPERTY(P_BACK_PIXEL, UInt32, MCDispatch, DefaultBackPixel)

DEFINE_RO_OBJ_PROPERTY(P_TOP_PIXEL, UInt32, MCDispatch, DefaultTopPixel)

DEFINE_RO_OBJ_CUSTOM_PROPERTY(P_FORE_COLOR, InterfaceNamedColor, MCDispatch, DefaultForeColor)

DEFINE_RO_OBJ_CUSTOM_PROPERTY(P_BORDER_COLOR, InterfaceNamedColor, MCDispatch, DefaultForeColor)

DEFINE_RO_OBJ_CUSTOM_PROPERTY(P_TOP_COLOR, InterfaceNamedColor, MCDispatch, DefaultForeColor)

DEFINE_RO_OBJ_CUSTOM_PROPERTY(P_BOTTOM_COLOR, InterfaceNamedColor, MCDispatch, DefaultForeColor)

DEFINE_RO_OBJ_CUSTOM_PROPERTY(P_SHADOW_COLOR, InterfaceNamedColor, MCDispatch, DefaultForeColor)

DEFINE_RO_OBJ_CUSTOM_PROPERTY(P_FOCUS_COLOR, InterfaceNamedColor, MCDispatch, DefaultForeColor)

DEFINE_RO_OBJ_CUSTOM_PROPERTY(P_BACK_COLOR, InterfaceNamedColor, MCDispatch, DefaultBackColor)

DEFINE_RO_OBJ_CUSTOM_PROPERTY(P_HILITE_COLOR, InterfaceNamedColor, MCDispatch, DefaultBackColor)

DEFINE_RO_OBJ_PROPERTY(P_FORE_PATTERN, OptionalUInt32, MCDispatch, DefaultPattern)

DEFINE_RO_OBJ_PROPERTY(P_BACK_PATTERN, OptionalUInt32, MCDispatch, DefaultPattern)

DEFINE_RO_OBJ_PROPERTY(P_HILITE_PATTERN, OptionalUInt32, MCDispatch, DefaultPattern)

DEFINE_RO_OBJ_PROPERTY(P_BORDER_PATTERN, OptionalUInt32, MCDispatch, DefaultPattern)

DEFINE_RO_OBJ_PROPERTY(P_TOP_PATTERN, OptionalUInt32, MCDispatch, DefaultPattern)

DEFINE_RO_OBJ_PROPERTY(P_BOTTOM_PATTERN, OptionalUInt32, MCDispatch, DefaultPattern)

DEFINE_RO_OBJ_PROPERTY(P_SHADOW_PATTERN, OptionalUInt32, MCDispatch, DefaultPattern)

DEFINE_RO_OBJ_PROPERTY(P_FOCUS_PATTERN, OptionalUInt32, MCDispatch, DefaultPattern)

};

MCObjectPropertyTable MCDispatch::kPropertyTable =

{

&MCObject::kPropertyTable,

sizeof(kProperties) / sizeof(kProperties[0]),

&kProperties[0],

};

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

MCDispatch::MCDispatch()

{

license = NULL;

stacks = NULL;

fonts = NULL;

setname_cstring("dispatch");

handling = False;

menu = NULL;

panels = NULL;

startdir = NULL;

enginedir = NULL;

flags = 0;

m_drag_source = false;

m_drag_target = false;

m_drag_end_sent = false;

m_showing_mnemonic_underline = false;

m_externals = nil;

m_transient_stacks = nil;

// AL-2015-02-10: [[ Standalone Inclusions ]] Add resource mapping array to MCDispatch. This stores

// any universal name / relative path pairs included in a standalone executable for locating included

// resources.

/* UNCHECKED */ MCArrayCreateMutable(m_library_mapping);

}

MCDispatch::~MCDispatch()

{

delete license;

while (stacks != NULL)

{

MCStack *sptr = stacks->prev()->remove(stacks);

delete sptr;

}

while (imagecache != NULL)

{

MCImage *iptr = imagecache->remove(imagecache);

delete iptr;

}

delete fonts;

MCMemoryDeleteArray(startdir); /* Allocated by MCStringConvertToCString() */

MCMemoryDeleteArray(enginedir); /* Allocated by MCStringConvertToCString() */

delete m_externals;

// AL-2015-02-10: [[ Standalone Inclusions ]] Delete library mapping

MCValueRelease(m_library_mapping);

}

bool MCDispatch::isdragsource(void)

{

return m_drag_source;

}

bool MCDispatch::isdragtarget(void)

{

return m_drag_target;

}

// bogus "cut" call actually checks license

Boolean MCDispatch::cut(Boolean home)

{

if (home)

return True;

return MCnoui || (flags & F_WAS_LICENSED) != 0;

}

Exec_stat MCDispatch::handle(Handler_type htype, MCNameRef mess, MCParameter *params, MCObject *pass_from)

{

Exec_stat stat = ES_NOT_HANDLED;

bool t_has_passed;

t_has_passed = false;

if (MCcheckstack && MCU_abs(MCstackbottom - (char *)&stat) > MCrecursionlimit)

{

MCeerror->add(EE_RECURSION_LIMIT, 0, 0);

MCerrorptr = stacks;

return ES_ERROR;

}

// MW-2011-06-30: Move handling of library stacks from MCStack::handle.

if (MCnusing > 0)

{

for (uint32_t i = MCnusing; i > 0 && (stat == ES_PASS || stat == ES_NOT_HANDLED); i -= 1)

{

stat = MCusing[i - 1]->handle(htype, mess, params, nil);

// MW-2011-08-22: [[ Bug 9686 ]] Make sure we exit as soon as the

// message is handled.

if (stat != ES_NOT_HANDLED && stat != ES_PASS)

return stat;

if (stat == ES_PASS)

t_has_passed = true;

}

if (t_has_passed && stat == ES_NOT_HANDLED)

stat = ES_PASS;

}

if ((stat == ES_NOT_HANDLED || stat == ES_PASS) && MCbackscripts != NULL)

{

MCObjectList *optr = MCbackscripts;

do

{

if (!optr->getremoved())

{

stat = optr->getobject()->handle(htype, mess, params, nil);

if (stat != ES_NOT_HANDLED && stat != ES_PASS)

return stat;

if (stat == ES_PASS)

t_has_passed = true;

}

optr = optr->next();

}

while (optr != MCbackscripts);

}

if ((stat == ES_NOT_HANDLED || stat == ES_PASS) && m_externals != nil)

{

// TODO[19681]: This can be removed when all engine messages are sent with

// target.

bool t_target_was_valid = MCtargetptr.IsValid();

Exec_stat oldstat = stat;

stat = m_externals -> Handle(this, htype, mess, params);

// MW-2011-08-22: [[ Bug 9686 ]] Make sure we exit as soon as the

// message is handled.

if (stat != ES_NOT_HANDLED && stat != ES_PASS)

return stat;

if (oldstat == ES_PASS && stat == ES_NOT_HANDLED)

stat = ES_PASS;

if (stat == ES_PASS || stat == ES_NOT_HANDLED)

{

if (t_target_was_valid && !MCtargetptr.IsValid())

{

stat = ES_NORMAL;

t_has_passed = false;

}

}

}

//#ifdef TARGET_SUBPLATFORM_IPHONE

// extern Exec_stat MCIPhoneHandleMessage(MCNameRef message, MCParameter *params);

// if (stat == ES_NOT_HANDLED || stat == ES_PASS)

// {

// stat = MCIPhoneHandleMessage(mess, params);

//

// if (stat != ES_NOT_HANDLED && stat != ES_PASS)

// return stat;

// }

//#endif

//

//#ifdef _MOBILE

// if (stat == ES_NOT_HANDLED || stat == ES_PASS)

// {

// stat = MCHandlePlatformMessage(htype, MCNameGetOldString(mess), params);

//

// // MW-2011-08-22: [[ Bug 9686 ]] Make sure we exit as soon as the

// // message is handled.

// if (stat != ES_NOT_HANDLED && stat != ES_PASS)

// return stat;

// }

//#endif

if ((stat == ES_NOT_HANDLED || stat == ES_PASS))

{

// TODO[19681]: This can be removed when all engine messages are sent with

// target.

bool t_target_was_valid = MCtargetptr.IsValid();

extern Exec_stat MCEngineHandleLibraryMessage(MCNameRef name, MCParameter *params);

stat = MCEngineHandleLibraryMessage(mess, params);

if (stat == ES_PASS || stat == ES_NOT_HANDLED)

{

if (t_target_was_valid && !MCtargetptr.IsValid())

{

stat = ES_NORMAL;

t_has_passed = false;

}

}

}

if (MCmessagemessages && stat != ES_PASS && MCtargetptr)

MCtargetptr -> sendmessage(htype, mess, False);

if (t_has_passed)

return ES_PASS;

return stat;

}

bool MCDispatch::getmainstacknames(MCListRef& r_list)

{

MCAutoListRef t_list;

if (!MCListCreateMutable('\n', &t_list))

return false;

MCStack *tstk = stacks;

do

{

MCAutoValueRef t_string;

if (!tstk->names(P_SHORT_NAME, &t_string))

return false;

if (!MCListAppend(*t_list, (MCStringRef)*t_string))

return false;

tstk = (MCStack *)tstk->next();

}

while (tstk != stacks);

return MCListCopy(*t_list, r_list);

}

void MCDispatch::appendstack(MCStack *sptr)

{

sptr->appendto(stacks);

// MW-2013-03-20: [[ MainStacksChanged ]]

MCmainstackschanged = True;

}

void MCDispatch::removestack(MCStack *sptr)

{

sptr->remove(stacks);

// MW-2013-03-20: [[ MainStacksChanged ]]

MCmainstackschanged = True;

}

void MCDispatch::destroystack(MCStack *sptr, Boolean needremove)

{

if (needremove)

{

MCStack *t_substacks = sptr -> getsubstacks();

while (t_substacks)

{

t_substacks -> dodel();

t_substacks = sptr -> getsubstacks();

}

sptr -> dodel();

}

if (sptr == MCstaticdefaultstackptr)

MCstaticdefaultstackptr = stacks;

if (sptr == MCdefaultstackptr)

MCdefaultstackptr = MCstaticdefaultstackptr;

if (MCacptr && MCacptr->getmessagestack() == sptr)

MCacptr->setmessagestack(NULL);

Boolean oldstate = MClockmessages;

MClockmessages = True;

delete sptr;

MClockmessages = oldstate;

}

static bool attempt_to_loadfile(IO_handle& r_stream, MCStringRef& r_path, const char *p_path_format, ...)

{

MCAutoStringRef t_trial_path;

va_list t_args;

va_start(t_args, p_path_format);

/* UNCHECKED */ MCStringFormatV(&t_trial_path, p_path_format, t_args);

va_end(t_args);

IO_handle t_trial_stream;

t_trial_stream = MCS_open(*t_trial_path, kMCOpenFileModeRead, True, False, 0);

if (t_trial_stream != nil)

{

r_path = (MCStringRef)MCValueRetain(*t_trial_path);

r_stream = t_trial_stream;

return true;

}

return false;

}

Boolean MCDispatch::openstartup(MCStringRef sname, MCStringRef& outpath, IO_handle &stream)

{

if (enginedir == nil)

return False;

if (attempt_to_loadfile(stream, outpath, "%s/%@", startdir, sname))

return True;

if (attempt_to_loadfile(stream, outpath, "%s/%@", enginedir, sname))

return True;

return False;

}

Boolean MCDispatch::openenv(MCStringRef sname, MCStringRef env,

MCStringRef& outpath, IO_handle &stream, uint4 offset)

{

MCAutoStringRef t_env;

if (!MCS_getenv(env, &t_env))

return False;

bool t_found;

t_found = false;

MCStringRef t_rest_of_env;

t_rest_of_env = MCValueRetain(env);

while(!t_found && !MCStringIsEmpty(t_rest_of_env))

{

MCAutoStringRef t_env_path;

MCStringRef t_next_rest_of_env;

/* UNCHECKED */ MCStringDivideAtChar(t_rest_of_env, ENV_SEPARATOR, kMCStringOptionCompareExact, &t_env_path, t_next_rest_of_env);

if (attempt_to_loadfile(stream, outpath, "%@/%@", *t_env_path, sname))

t_found = true;

MCValueRelease(t_rest_of_env);

t_rest_of_env = t_next_rest_of_env;

}

MCValueRelease(t_rest_of_env);

return t_found;

}

IO_stat readheader(IO_handle& stream, uint32_t& r_version)

{

char tnewheader[kMCStackFileVersionStringLength + 1];

if (IO_read(tnewheader, kMCStackFileVersionStringLength, stream) != IO_NORMAL)

return IO_ERROR;

tnewheader[kMCStackFileVersionStringLength] = '\0'; /* nul-terminate */

// AL-2014-10-27: [[ Bug 12558 ]] Check for valid header prefix

if (!MCStackFileParseVersionNumber(tnewheader, r_version))

{

char theader[kMCStackFileMetaCardVersionStringLength + 1];

theader[kMCStackFileMetaCardVersionStringLength] = '\0';

uint4 offset;

strncpy(theader, tnewheader, kMCStackFileVersionStringLength);

if (IO_read(theader + kMCStackFileVersionStringLength, kMCStackFileMetaCardVersionStringLength - kMCStackFileVersionStringLength, stream) == IO_NORMAL

&& MCU_offset(kMCStackFileMetaCardSignature, theader, offset))

{

if (theader[offset - 1] != '\n' || theader[offset - 2] == '\r')

{

MCresult->sets("stack was corrupted by a non-binary file transfer");

return IO_ERROR;

}

r_version = (theader[offset + kMCStackFileMetaCardSignatureLength] - '0') * 1000;

r_version += (theader[offset + kMCStackFileMetaCardSignatureLength + 2] - '0') * 100;

}

else

return IO_ERROR;

}

return IO_NORMAL;

}

bool MCDispatch::streamstackisscriptonly(IO_handle stream)

{

uint32_t t_version;

return readheader(stream, t_version) != IO_NORMAL;

}

// This method reads a stack from the given stream. The stack is set to

// have parent MCDispatch, and filename MCcmd. It is designed to be used

// for embedded stacks/deployed stacks/revlet stacks.

IO_stat MCDispatch::readstartupstack(IO_handle stream, MCStack*& r_stack)

{

MCAutoStringRef t_filename;

// MM-2013-10-30: [[ Bug 11333 ]] Set the filename of android mainstack to apk/mainstack (previously was just apk).

// This solves relative file path referencing issues.

#ifdef TARGET_SUBPLATFORM_ANDROID

/* UNCHECKED */ MCStringFormat(&t_filename, "%@/mainstack", MCcmd);

#else

t_filename = MCcmd;

#endif

const char* t_result = nullptr;

MCStack* t_stack = nullptr;

if (trytoreadbinarystack(*t_filename, kMCEmptyString, stream, this,

t_stack, t_result) != IO_NORMAL ||

t_stack == nullptr)

{

return IO_ERROR;

}

// We are reading the startup stack, so this becomes the root of the

// stack list. This must happen prior to resolving parent scripts

// because otherwise there are no mainstacks, which can cause a

// crash when searching substacks.

stacks = t_stack;

#ifndef _MOBILE

// Make sure parent script references are up to date.

if (s_loaded_parent_script_reference)

t_stack -> resolveparentscripts();

#else

// Mark the stack as needed parentscript resolution. This is done after

// aux stacks have been loaded.

if (s_loaded_parent_script_reference)

t_stack -> setextendedstate(True, ECS_USES_PARENTSCRIPTS);

#endif

r_stack = t_stack;

return IO_NORMAL;

}

IO_stat MCDispatch::readscriptonlystartupstack(IO_handle stream, uindex_t p_length, MCStack*& r_stack)

{

MCAutoStringRef t_filename;

// MM-2013-10-30: [[ Bug 11333 ]] Set the filename of android mainstack to apk/mainstack (previously was just apk).

// This solves relative file path referencing issues.

#ifdef TARGET_SUBPLATFORM_ANDROID

/* UNCHECKED */ MCStringFormat(&t_filename, "%@/mainstack", MCcmd);

#else

t_filename = MCcmd;

#endif

const char* t_result = nullptr;

MCStack* t_stack = nullptr;

// Read a script-only stack from the stream

if (trytoreadscriptonlystackofsize(*t_filename, stream,

p_length, this,

t_stack, t_result) != IO_NORMAL

|| t_stack == nullptr)

return IO_ERROR;

// We are reading the startup stack, so this becomes the root of the

// stack list.

stacks = t_stack;

r_stack = t_stack;

return IO_NORMAL;

}

// MW-2012-02-17: [[ LogFonts ]] Load a stack file, ensuring we clear up any

// font table afterwards - regardless of errors.

IO_stat MCDispatch::readfile(MCStringRef p_openpath, MCStringRef p_name, IO_handle &stream, MCStack *&sptr)

{

// Various places like to call this function with the first two parameters as NULL

if (p_openpath == nil)

p_openpath = kMCEmptyString;

if (p_name == nil)

p_name = kMCEmptyString;

IO_stat stat;

stat = doreadfile(p_openpath, p_name, stream, sptr);

MCLogicalFontTableFinish();

return stat;

}

IO_stat MCDispatch::trytoreadbinarystack(MCStringRef p_openpath,

MCStringRef p_name,

IO_handle &x_stream,

MCObject* p_parent,

MCStack* &r_stack,

const char* &r_result)

{

uint32_t t_version;

if (readheader(x_stream, t_version) != IO_NORMAL)

{

return IO_NORMAL;

}

if (t_version > kMCStackFileFormatCurrentVersion)

{

r_result = "stack was produced by a newer version";

return checkloadstat(IO_ERROR);

}

// MW-2008-10-20: [[ ParentScripts ]] Set the boolean flag that tells us whether

// parentscript resolution is required to false.

s_loaded_parent_script_reference = false;

// MW-2013-11-19: [[ UnicodeFileFormat ]] newsf is no longer used.

uint1 charset, type;

char* t_newsf = nullptr;

if (IO_read_uint1(&charset, x_stream) != IO_NORMAL

|| IO_read_uint1(&type, x_stream) != IO_NORMAL

|| IO_read_cstring_legacy(t_newsf, x_stream, 2) != IO_NORMAL)

{

r_result = "stack is corrupted, check for ~ backup file";

return checkloadstat(IO_ERROR);

}

MCMemoryDeallocate(t_newsf);

MCtranslatechars = charset != CHARSET;

MCStack *t_stack;

if (!MCStackSecurityCreateStack(t_stack))

{

r_result = "couldn't create stack";

return checkloadstat(IO_ERROR);

}

if (p_parent != nullptr)

t_stack -> setparent(p_parent);

else if (stacks != nullptr)

t_stack->setparent(stacks);

else

t_stack->setparent(this);

t_stack->setfilename(p_openpath);

if (MCModeCanLoadHome() && type == OT_HOME)

{

// MW-2013-11-19: [[ UnicodeFileFormat ]] These strings are never written out, so

// legacy.

char* lstring = nullptr;

char* cstring = nullptr;

if (IO_read_cstring_legacy(lstring, x_stream, 2) != IO_NORMAL

|| IO_read_cstring_legacy(cstring, x_stream, 2) != IO_NORMAL)

{

r_result = "stack is corrupted, check for ~ backup file";

return checkloadstat(IO_ERROR);

}

MCMemoryDeallocate(lstring);

MCMemoryDeallocate(cstring);

}

if (IO_read_uint1(&type, x_stream) != IO_NORMAL

|| (type != OT_STACK && type != OT_ENCRYPT_STACK)

|| t_stack->load(x_stream, t_version, type) != IO_NORMAL)

{

r_result = "stack is corrupted, check for ~ backup file";

destroystack(t_stack, False);

return checkloadstat(IO_ERROR);

}

// MW-2011-08-09: [[ Groups ]] Make sure F_GROUP_SHARED is set

// appropriately.

t_stack -> checksharedgroups();

if (t_stack->load_substacks(x_stream, t_version) != IO_NORMAL

|| IO_read_uint1(&type, x_stream) != IO_NORMAL

|| type != OT_END)

{

r_result = "stack is corrupted, check for ~ backup file";

destroystack(t_stack, False);

return checkloadstat(IO_ERROR);

}

r_stack = t_stack;

return IO_NORMAL;

}

static MCStack* script_only_stack_from_bytes(uint8_t *p_bytes,

uindex_t p_size,

MCStringEncoding p_encoding)

{

MCAutoStringRef t_raw_script_string, t_LC_script_string;

if (!MCStringCreateWithBytes(p_bytes, p_size, p_encoding, false,

&t_raw_script_string) ||

!MCStringConvertLineEndingsToLiveCode(*t_raw_script_string,

&t_LC_script_string))

{

return nullptr;

}

// Now attempt to parse the header line:

// 'script' <string>

MCScriptPoint sp(*t_LC_script_string);

// Parse 'script' token.

if (sp . skip_token(SP_FACTOR, TT_PROPERTY, P_SCRIPT) != PS_NORMAL)

{

return nullptr;

}

// Parse <string> token.

Symbol_type t_type;

if (sp . next(t_type) != PS_NORMAL || t_type != ST_LIT)

{

return nullptr;

}

MCNewAutoNameRef t_script_name;

if (!MCNameClone(sp . gettoken_nameref(), &t_script_name))

{

return nullptr;

}

// Parse end of line.

Parse_stat t_stat;

t_stat = sp . next(t_type);

if (t_stat != PS_EOL && t_stat != PS_EOF)

return nullptr;

// MW-2014-10-23: [[ Bug ]] Make sure we trim the correct number of lines.

// SN-2014-10-16: [[ Merge-6.7.0-rc-3 ]] Update to StringRef

// Now trim the ep down to the remainder of the script.

// Trim the header.

uint32_t t_lines = sp.getline();

uint32_t t_index = 0;

// Jump over the possible lines before the string token

while (MCStringFirstIndexOfChar(*t_LC_script_string, '\n', t_index,

kMCStringOptionCompareExact, t_index)

&& t_lines > 0)

{

t_lines -= 1;

}

// Add one to the index so we include the LF

t_index += 1;

// t_line now has the last LineFeed of the token

MCAutoStringRef t_LC_script_body;

// We copy the body of the stack script

if (!MCStringCopySubstring(*t_LC_script_string,

MCRangeMake(t_index,

MCStringGetLength(*t_LC_script_string)

- t_index), &t_LC_script_body))

{

return nullptr;

}

// Create a stack.

MCStack *t_stack;

if (!MCStackSecurityCreateStack(t_stack))

return nullptr;

// Set it up as script only.

t_stack -> setasscriptonly(*t_LC_script_body);

// Set its name.

t_stack -> setname(*t_script_name);

return t_stack;

}

IO_stat MCDispatch::trytoreadscriptonlystackofsize(MCStringRef p_openpath,

IO_handle &x_stream,

uindex_t p_size,

MCObject* p_parent,

MCStack* &r_stack,

const char* &r_result)

{

MCAutoPointer<byte_t> t_bytes = new byte_t[p_size];

if (IO_read(*t_bytes, p_size, x_stream) == IO_ERROR)

{

return checkloadstat(IO_ERROR);

}

uindex_t t_bom_size = 0;

MCFileEncodingType t_file_encoding =

MCS_resolve_BOM_from_bytes(*t_bytes, p_size, t_bom_size);

MCStringEncoding t_string_encoding;

switch (t_file_encoding)

{

case kMCFileEncodingUTF8:

t_string_encoding = kMCStringEncodingUTF8;

break;

case kMCFileEncodingUTF16:

t_string_encoding = kMCStringEncodingUTF16;

break;

case kMCFileEncodingUTF16BE:

t_string_encoding = kMCStringEncodingUTF16BE;

break;

case kMCFileEncodingUTF16LE:

t_string_encoding = kMCStringEncodingUTF16LE;

break;

default:

// Assume native

t_string_encoding = kMCStringEncodingNative;

break;

}

MCStack *t_stack = script_only_stack_from_bytes(*t_bytes + t_bom_size,

p_size - t_bom_size,

t_string_encoding);

if (t_stack == nullptr)

return IO_NORMAL;

// Set its parent.

if (p_parent != nullptr)

t_stack -> setparent(p_parent);

else if (stacks != nullptr)

t_stack->setparent(stacks);

else

t_stack->setparent(this);

// Set its filename.

t_stack->setfilename(p_openpath);

// Make it invisible

t_stack -> setflag(False, F_VISIBLE);

r_stack = t_stack;

return IO_NORMAL;

}

IO_stat MCDispatch::trytoreadscriptonlystack(MCStringRef p_openpath,

IO_handle &x_stream,

MCObject* p_parent,

MCStack* &r_stack,

const char* &r_result)

{

// Load the file into memory - we need to process a byteorder mark and any

// line endings.

uindex_t t_size = static_cast<uindex_t>(MCS_fsize(x_stream));

if (trytoreadscriptonlystackofsize(p_openpath, x_stream, t_size,

p_parent, r_stack, r_result)

!= IO_NORMAL)

{

r_result = "failed to load script only stack";

return checkloadstat(IO_ERROR);

}

return IO_NORMAL;

}

void MCDispatch::processstack(MCStringRef p_openpath, MCStack* &x_stack)

{

if (stacks != NULL)

{

MCStack *tstk = stacks;

do

{

if (x_stack->hasname(tstk->getname()))

{

MCAutoNameRef t_stack_name;

/* UNCHECKED */ t_stack_name . Clone(x_stack -> getname());

delete x_stack;

x_stack = nullptr;

if (MCStringIsEqualTo(tstk -> getfilename(), p_openpath, kMCStringOptionCompareCaseless))

x_stack = tstk;

else

{

MCdefaultstackptr->getcard()->message_with_valueref_args(MCM_reload_stack, tstk->getname(), p_openpath);

tstk = stacks;

do

{

if (MCNameIsEqualTo(t_stack_name, tstk->getname(), kMCCompareCaseless))

{

x_stack = tstk;

break;

}

tstk = (MCStack *)tstk->next();

}

while (tstk != stacks);

}

return;

}

tstk = (MCStack *)tstk->next();

}

while (tstk != stacks);

}

appendstack(x_stack);

x_stack->extraopen(false);

// MW-2008-10-28: [[ ParentScript ]]

// We just loaded a stackfile, so check to see if parentScript resolution

// is required and if so do it.

// MW-2009-01-28: [[ Inherited parentScripts ]]

// Resolving parentScripts may allocate memory, so 'resolveparentscripts'

// will return false if it fails to allocate what it needs. At some point

// this needs to be dealt with by deleting the stack and returning an error,

// *However* at the time of writing, 'readfile' isn't designed to handle

// this - so we just ignore the result for now (note that all the 'load'

// methods *fail* to check for no-memory errors!).

if (s_loaded_parent_script_reference)

x_stack -> resolveparentscripts();

}

// MW-2012-02-17: [[ LogFonts ]] Actually load the stack file (wrapped by readfile

// to handle font table cleanup).

IO_stat MCDispatch::doreadfile(MCStringRef p_openpath, MCStringRef p_name, IO_handle &stream, MCStack* &r_stack)

{

MCresult -> clear();

const char* t_result = nullptr;

MCStack *t_stack = nullptr;

if (trytoreadbinarystack(p_openpath, p_name, stream, nullptr,

t_stack, t_result) != IO_NORMAL)

{

/* UNCHECKED */ MCresult -> setvalueref(MCSTR(t_result));

return IO_ERROR;

}

// If there was no IO error but it wasn't a binary stack then try as script-only

if (t_stack == nullptr)

{

// Reset to position 0.

MCS_seek_set(stream, 0);

if (trytoreadscriptonlystack(p_openpath, stream, nullptr,

t_stack, t_result) != IO_NORMAL)

{

/* UNCHECKED */ MCresult -> setvalueref(MCSTR(t_result));

return IO_ERROR;

}

}

// MW-2014-09-30: [[ ScriptOnlyStack ]] If we managed to load a stack as either binary

// or script, then do the normal processing.

if (t_stack != nullptr)

{

processstack(p_openpath, t_stack);

r_stack = t_stack;

return IO_NORMAL;

}

// MW-2014-09-30: [[ ScriptOnlyStack ]] Finally attempt to load the script in legacy

// modes - either as a single script, or as a HyperCard conversion.

MCS_seek_set(stream, 0);

if (stacks == NULL)

{

MCnoui = True;

MCscreen = new MCUIDC;

/* UNCHECKED */ MCStackSecurityCreateStack(stacks);

MCdefaultstackptr = MCstaticdefaultstackptr = stacks;

stacks->setparent(this);

stacks->setname_cstring("revScript");

uint4 size = (uint4)MCS_fsize(stream);

MCAutoPointer<char> script;

script = new char[size + 2];

(*script)[size] = '\n';

(*script)[size + 1] = '\0';

if (IO_read(*script, size, stream) != IO_NORMAL)

return IO_ERROR;

MCAutoStringRef t_script_str;

/* UNCHECKED */ MCStringCreateWithCString(*script, &t_script_str);

if (!stacks -> setscript_from_commandline(*t_script_str))

return IO_ERROR;

}

else

{

// MW-2008-06-12: [[ Bug 6476 ]] Media won't open HC stacks

if (!MCdispatcher->cut(True) || hc_import(p_name, stream, t_stack) != IO_NORMAL)

{

MCresult->sets("file is not a stack");

return IO_ERROR;

}

r_stack = t_stack;

}

return IO_NORMAL;

}

IO_stat MCDispatch::loadfile(MCStringRef p_name, MCStack *&sptr)

{

IO_handle stream;

MCAutoStringRef t_open_path;

bool t_found;

t_found = false;

if (!t_found)

{

if ((stream = MCS_open(p_name, kMCOpenFileModeRead, True, False, 0)) != NULL)

{

// SN-20015-06-01: [[ Bug 15432 ]] We want to use MCS_resolvepath to

// keep consistency and let '~' be resolved as it is in MCS_open

// MCS_resolve_path leaves a backslash-delimited path on Windows,

// and MCS_get_canonical_path is made to cope with this.

// In 7.0, MCS_resolvepath does not return a native path.

t_found = MCS_resolvepath(p_name, &t_open_path);

}

}