{

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

{

switch (which)

{

#ifdef /* MCDispatch::getprop */ LEGACY_EXEC

case P_BACK_PIXEL:

//ep.setint(MCscreen->background_pixel.pixel & 0xFFFFFF);

return ES_NOT_HANDLED;

case P_TOP_PIXEL:

//ep.setint(MCscreen->white_pixel.pixel & 0xFFFFFF);

return ES_NOT_HANDLED;

case P_HILITE_PIXEL:

case P_FORE_PIXEL:

case P_BORDER_PIXEL:

case P_BOTTOM_PIXEL:

case P_SHADOW_PIXEL:

case P_FOCUS_PIXEL:

//ep.setint(MCscreen->black_pixel.pixel & 0xFFFFFF);

return ES_NOT_HANDLED;

case P_BACK_COLOR:

case P_HILITE_COLOR:

//ep.setstaticcstring("white");

return ES_NOT_HANDLED;

case P_FORE_COLOR:

case P_BORDER_COLOR:

case P_TOP_COLOR:

case P_BOTTOM_COLOR:

case P_SHADOW_COLOR:

case P_FOCUS_COLOR:

//ep.setstaticcstring("black");

return ES_NOT_HANDLED;

case P_FORE_PATTERN:

case P_BACK_PATTERN:

case P_HILITE_PATTERN:

case P_BORDER_PATTERN:

case P_TOP_PATTERN:

case P_BOTTOM_PATTERN:

case P_SHADOW_PATTERN:

case P_FOCUS_PATTERN:

ep.clear();

return ES_NORMAL;

case P_TEXT_ALIGN:

ep.setstaticcstring(MCleftstring);

return ES_NORMAL;

case P_TEXT_FONT:

//ep.setstaticcstring(DEFAULT_TEXT_FONT);

return ES_NOT_HANDLED;

case P_TEXT_HEIGHT:

//ep.setint(heightfromsize(DEFAULT_TEXT_SIZE));

return ES_NOT_HANDLED;

case P_TEXT_SIZE:

//ep.setint(DEFAULT_TEXT_SIZE);

return ES_NOT_HANDLED;

case P_TEXT_STYLE:

ep.setstaticcstring(MCplainstring);

return ES_NORMAL;

#endif /* MCDispatch::getprop */

default:

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

return ES_ERROR;

}

{

#ifdef /* MCDispatch::setprop */ LEGACY_EXEC

return ES_NORMAL;

#endif /* MCDispatch::setprop */

return ES_NORMAL;

{

if (home)

return True;

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

{

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)

{

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_NOT_HANDLED || stat == ES_PASS))

{

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

stat = MCEngineHandleLibraryMessage(mess, params);

}

if (MCmessagemessages && stat != ES_PASS)

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

if (t_has_passed)

return ES_PASS;

return stat;

{

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

{

sptr->appendto(stacks);

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

MCmainstackschanged = True;

{

sptr->remove(stacks);

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

MCmainstackschanged = True;

{

if (needremove)

removestack(sptr);

if (sptr == MCstaticdefaultstackptr)

MCstaticdefaultstackptr = stacks;

if (sptr == MCdefaultstackptr)

MCdefaultstackptr = MCstaticdefaultstackptr;

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

MCacptr->setmessagestack(NULL);

Boolean oldstate = MClockmessages;

MClockmessages = True;

delete sptr;

MClockmessages = oldstate;

{

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;

{

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;

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;

{

char tnewheader[NEWHEADERSIZE];

if (IO_read(tnewheader, NEWHEADERSIZE, stream) == IO_NORMAL)

{

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

if (strncmp(tnewheader, "REVO", HEADERPREFIXSIZE) == 0)

{

// The header version can now consist of any alphanumeric characters

// They map to numbers as follows:

// 0-9 -> 0-9

// A-Z -> 10-35

// a-z -> 36-61

uint1 versionnum[4];

for (uint1 i = 0; i < 4; i++)

{

char t_char = tnewheader[i + 4];

if ('0' <= t_char && t_char <= '9')

versionnum[i] = (uint1)(t_char - '0');

else if ('A' <= t_char && t_char <= 'Z')

versionnum[i] = (uint1)(t_char - 'A' + 10);

else if ('a' <= t_char && t_char <= 'z')

versionnum[i] = (uint1)(t_char - 'a' + 36);

else

return IO_ERROR;

}

// Future file format versions will always still compare greater than MAX_STACKFILE_VERSION,

// so it is ok that r_version does not accurately reflect future version values.

// TODO: change this, and comparisons for version >= 7000 / 5500, etc

r_version = versionnum[0] * 1000;

r_version += versionnum[1] * 100;

r_version += versionnum[2] * 10;

r_version += versionnum[3];

}

else

{

char theader[HEADERSIZE + 1];

theader[HEADERSIZE] = '\0';

uint4 offset;

strncpy(theader, tnewheader, NEWHEADERSIZE);

if (IO_read(theader + NEWHEADERSIZE, HEADERSIZE - NEWHEADERSIZE, stream) == IO_NORMAL

&& MCU_offset(SIGNATURE, 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 + VERSION_OFFSET] - '0') * 1000;

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

}

else

return IO_ERROR;

}

}

else

{

// Could not read header

return IO_ERROR;

}

return IO_NORMAL;

{

uint32_t version;

uint1 charset, type;

char *newsf;

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

if (readheader(stream, version) != IO_NORMAL

|| IO_read_uint1(&charset, stream) != IO_NORMAL

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

|| IO_read_cstring_legacy(newsf, stream, 2) != IO_NORMAL)

return 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;

MCtranslatechars = charset != CHARSET;

delete newsf; // stackfiles is obsolete

MCStack *t_stack = nil;

/* UNCHECKED */ MCStackSecurityCreateStack(t_stack);

t_stack -> setparent(this);

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

MCAutoStringRef t_filename;

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

t_stack -> setfilename(*t_filename);

#else

t_stack -> setfilename(MCcmd);

#endif

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

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

|| t_stack->load(stream, version, type) != IO_NORMAL)

{

delete t_stack;

return IO_ERROR;

}

if (t_stack->load_substacks(stream, version) != IO_NORMAL

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

|| type != OT_END)

{

delete t_stack;

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;

#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

return IO_NORMAL;

{

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

{

uint32_t version;

sptr = NULL;

// MW-2014-09-30: [[ ScriptOnlyStack ]] First see if it is a binary stack.

if (readheader(stream, version) == IO_NORMAL)

{

if (version > MAX_STACKFILE_VERSION)

{

MCresult->sets("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 *newsf;

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

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

|| IO_read_cstring_legacy(newsf, stream, 2) != IO_NORMAL)

{

MCresult->sets("stack is corrupted, check for ~ backup file");

return checkloadstat(IO_ERROR);

}

delete newsf; // stackfiles is obsolete

MCtranslatechars = charset != CHARSET;

sptr = nil;

/* UNCHECKED */ MCStackSecurityCreateStack(sptr);

if (stacks == NULL)

sptr->setparent(this);

else

sptr->setparent(stacks);

sptr->setfilename(p_openpath);

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

{

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

// legacy.

char *lstring = NULL;

char *cstring = NULL;

IO_read_cstring_legacy(lstring, stream, 2);

IO_read_cstring_legacy(cstring, stream, 2);

delete lstring;

delete cstring;

}

MCresult -> clear();

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

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

|| sptr->load(stream, version, type) != IO_NORMAL)

{

if (MCresult -> isclear())

MCresult->sets("stack is corrupted, check for ~ backup file");

destroystack(sptr, False);

sptr = NULL;

return checkloadstat(IO_ERROR);

}

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

// appropriately.

sptr -> checksharedgroups();

if (sptr->load_substacks(stream, version) != IO_NORMAL

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

|| type != OT_END)

{

if (MCresult -> isclear())

MCresult->sets("stack is corrupted, check for ~ backup file");

destroystack(sptr, False);

sptr = NULL;

return checkloadstat(IO_ERROR);

}

}

// MW-2014-09-30: [[ ScriptOnlyStack ]] If we failed to load a stack from that step

// then check to see if it is a script file stack.

if (sptr == NULL)

{

// Clear the error return.

MCresult -> clear();

// Reset to position 0.

MCS_seek_set(stream, 0);

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

// line endings.

int64_t t_size;

t_size = MCS_fsize(stream);

uint8_t *t_script;

/* UNCHECKED */ MCMemoryAllocate(t_size, t_script);

if (IO_read(t_script, t_size, stream) == IO_ERROR)

{

MCresult -> sets("unable to read file");

return checkloadstat(IO_ERROR);

}

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

MCFileEncodingType t_file_encoding = MCS_resolve_BOM(stream);

MCStringEncoding t_string_encoding;

MCAutoStringRef t_raw_script_string, t_LC_script_string;

uint32_t t_BOM_offset;

switch (t_file_encoding)

{

case kMCFileEncodingUTF8:

t_BOM_offset = 3;

t_string_encoding = kMCStringEncodingUTF8;

break;

case kMCFileEncodingUTF16:

t_string_encoding = kMCStringEncodingUTF16;

t_BOM_offset = 2;

break;

case kMCFileEncodingUTF16BE:

t_string_encoding = kMCStringEncodingUTF16BE;

t_BOM_offset = 2;

break;

case kMCFileEncodingUTF16LE:

t_string_encoding = kMCStringEncodingUTF16LE;

t_BOM_offset = 2;

break;

default:

// Assume native

t_string_encoding = kMCStringEncodingNative;

t_BOM_offset = 0;

break;

}

/* UNCHECKED */ MCStringCreateWithBytes(t_script + t_BOM_offset, t_size - t_BOM_offset, t_string_encoding, false, &t_raw_script_string);

/* UNCHECKED */ MCStringConvertLineEndingsToLiveCode(*t_raw_script_string, &t_LC_script_string);

MCMemoryDeallocate(t_script);

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

{

// Parse <string> token.

Symbol_type t_type;

if (sp . next(t_type) == PS_NORMAL &&

t_type == ST_LIT)

{

MCNewAutoNameRef t_script_name;

MCNameClone(sp . gettoken_nameref(), &t_script_name);

// Parse end of line.

Parse_stat t_stat;

t_stat = sp . next(t_type);

if (t_stat == PS_EOL || t_stat == PS_EOF)

{

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

MCStringCopySubstring(*t_LC_script_string, MCRangeMake(t_index, MCStringGetLength(*t_LC_script_string) - t_index), &t_LC_script_body);

// Create a stack.

/* UNCHECKED */ MCStackSecurityCreateStack(sptr);

// Set its parent.

if (stacks == NULL)

sptr->setparent(this);

else

sptr->setparent(stacks);

// Set its filename.

sptr->setfilename(p_openpath);

// Set its name.

sptr -> setname(*t_script_name);

// Make it invisible

sptr -> setflag(False, F_VISIBLE);

// Set it up as script only.

sptr -> setasscriptonly(*t_LC_script_body);

}

}

}

}

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

// or script, then do the normal processing.

if (sptr != NULL)

{

if (stacks != NULL)

{

MCStack *tstk = stacks;

do

{

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

{

MCAutoNameRef t_stack_name;

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

delete sptr;

sptr = NULL;

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

sptr = 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))

{

sptr = tstk;

break;

}

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

}

while (tstk != stacks);

}

return IO_NORMAL;

}

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

}

while (tstk != stacks);

}

appendstack(sptr);

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

sptr -> resolveparentscripts();

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, sptr) != IO_NORMAL)

{

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

return IO_ERROR;

}

}

return IO_NORMAL;

{

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

}

}

if (!t_found)

{

// SN-2014-11-18: [[ Bug 14043 ]] If p_path is was not correct, we then use the leaf, and append it to different locations

// in all the next steps.

MCAutoStringRef t_leaf_name;

uindex_t t_leaf_index;

if (MCStringLastIndexOfChar(p_name, PATH_SEPARATOR, UINDEX_MAX, kMCStringOptionCompareExact, t_leaf_index))

/* UNCHECKED */ MCStringCopySubstring(p_name, MCRangeMake(t_leaf_index + 1, MCStringGetLength(p_name) - (t_leaf_index + 1)), &t_leaf_name);

else

t_leaf_name = p_name;

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

{