/* 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 "parentscript.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::visit_self(MCObjectVisitor* p_visitor)

{

return p_visitor -> OnObject(this);

}

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)

{

/* Make sure no messages are sent when destroying the given stack as this

* destruction method is only ever used for stacks which are not-yet-alive

* (e.g. failed to deserialize) or in restricted contexts (e.g. licensing

* dialog on startup). */

Boolean oldstate = MClockmessages;

MClockmessages = True;

if (needremove)

{

MCStack *t_substacks = sptr -> getsubstacks();

while(t_substacks != nullptr)

{

/* The MCStack::dodel() method removes the stack from its mainstack

* so we must explicitly delete it explicitly. Note that there is

* no need to scheduledelete() in this case as destroystack() is

* only called when it is known that no script is running from the

* stack. */

t_substacks -> dodel();

delete t_substacks;

/* Refetch the substacks list - the substack we just processed will

* have been removed from it. */

t_substacks = sptr -> getsubstacks();

}

/* Release any references to the mainstack */

sptr -> dodel();

}

if (sptr == MCstaticdefaultstackptr)

MCstaticdefaultstackptr = stacks;

if (sptr == MCdefaultstackptr)

MCdefaultstackptr = MCstaticdefaultstackptr;

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

MCacptr->setmessagestack(NULL);

/* Delete the stack explicitly. Note that there is no need to use

* scheduledelete here as destroystack() is only called when it is known

* that no script is running from the stack. */

delete sptr;

/* Restore the previous message lock state. */

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;

// 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);

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;

// 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);

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;

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

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

|| IO_discard_cstring_legacy(x_stream, 2) != IO_NORMAL)

{

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

return checkloadstat(IO_ERROR);

}

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.

if (IO_discard_cstring_legacy(x_stream, 2) != IO_NORMAL

|| IO_discard_cstring_legacy(x_stream, 2) != IO_NORMAL)

{

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

return checkloadstat(IO_ERROR);

}

}

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;

MCStringLineEndingStyle t_line_encoding_style;

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

&t_raw_script_string) ||

!MCStringNormalizeLineEndings(*t_raw_script_string,

kMCStringLineEndingStyleLF,

kMCStringLineEndingOptionNormalizePSToLineEnding |

kMCStringLineEndingOptionNormalizeLSToVT,

&t_lc_script_string,

&t_line_encoding_style))

{

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 = sp.gettoken_nameref();

// If 'with' is next then parse the behavior reference.

MCNewAutoNameRef t_behavior_name;

if (sp.skip_token(SP_REPEAT, TT_UNDEFINED, RF_WITH) == PS_NORMAL)

{

// Ensure 'behavior' is next

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

{

return nullptr;

}

// Read the behavior name

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

{

return nullptr;

}

t_behavior_name = sp.gettoken_nameref();

}

// 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);

// Save line endings from raw script string to restore when saving file.

t_stack -> setlineencodingstyle(t_line_encoding_style);

// If we parsed a behavior reference, then set it.

if (*t_behavior_name != nullptr)

{

t_stack->setparentscript_onload(0, *t_behavior_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()))

{

MCNewAutoNameRef t_stack_name = 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 (MCNameIsEqualToCaseless(*t_stack_name, tstk->getname()))

{

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();

x_stack -> setextendedstate(True, ECS_USES_PARENTSCRIPTS);

}

}

// 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)

{