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

#include "parsedef.h"

#include "filedefs.h"

#include "mcio.h"

#include "scriptpt.h"

//#include "execpt.h"

#include "handler.h"

#include "cmds.h"

#include "visual.h"

#include "chunk.h"

#include "mcerror.h"

#include "object.h"

#include "dispatch.h"

#include "stack.h"

#include "card.h"

#include "group.h"

#include "button.h"

#include "player.h"

#include "stacklst.h"

#include "cardlst.h"

#include "util.h"

#include "ans.h"

#include "debug.h"

#include "globals.h"

#include "securemode.h"

#include "redraw.h"

#include "exec.h"

#include "syntax.h"

#include "variable.h"

MCCompact::~MCCompact()

{

delete target;

}

Parse_stat MCCompact::parse(MCScriptPoint &sp)

{

initpoint(sp);

target = new MCChunk(False);

if (target->parse(sp, False) != PS_NORMAL)

{

MCperror->add

(PE_COMPACT_BADPARAM, sp);

return PS_ERROR;

}

return PS_NORMAL;

}

void MCCompact::exec_ctxt(MCExecContext &ctxt)

{

#ifdef /* MCCompact */ LEGACY_EXEC

MCObject *optr;

uint4 parid;

if (target->getobj(ep, optr, parid, True) != ES_NORMAL)

{

MCeerror->add

(EE_COMPACT_NOTARGET, line, pos);

return ES_ERROR;

}

if (optr->gettype() != CT_STACK)

{

MCeerror->add

(EE_COMPACT_NOTASTACK, line, pos);

return ES_ERROR;

}

MCStack *sptr = (MCStack *)optr;

sptr->compact();

return ES_NORMAL;

#endif /* MCCompact */

MCObject *optr;

uint4 parid;

if (!target->getobj(ctxt, optr, parid, True))

{

ctxt . LegacyThrow(EE_COMPACT_NOTARGET);

return;

}

if (optr->gettype() != CT_STACK)

{

ctxt . LegacyThrow(EE_COMPACT_NOTASTACK);

return;

}

MCStack *sptr = (MCStack *)optr;

MCLegacyExecCompactStack(ctxt, sptr);

}

void MCCompact::compile(MCSyntaxFactoryRef ctxt)

{

MCSyntaxFactoryBeginStatement(ctxt, line, pos);

target -> compile_object_ptr(ctxt);

MCSyntaxFactoryExecMethod(ctxt, kMCLegacyExecCompactStackMethodInfo);

MCSyntaxFactoryEndStatement(ctxt);

}

MCGo::~MCGo()

{

while (stack != NULL)

{

MCCRef *tptr = stack;

stack = stack->next;

delete tptr;

}

delete stack;

delete background;

delete card;

delete window;

delete widget;

}

Parse_stat MCGo::parse(MCScriptPoint &sp)

{

Symbol_type type;

Boolean need_target = True;

const LT *te;

MCCRef *curref = NULL;

Chunk_term oterm = CT_UNDEFINED;

Chunk_term nterm = CT_UNDEFINED;

Chunk_term lterm = CT_UNDEFINED;

initpoint(sp);

if (sp.skip_token(SP_FACTOR, TT_PROPERTY, P_INVISIBLE) == PS_NORMAL)

visible = False;

while (True)

{

if (sp.next(type) != PS_NORMAL)

{

if (need_target)

{

if (ct_class(oterm) == CT_ORDINAL)

{

card = new MCCRef;

card->otype = CT_CARD;

card->etype = oterm;

return PS_NORMAL;

}

else

{

MCperror->add

(PE_GO_NOID, sp);

return PS_ERROR;

}

}

else

break;

}

if (type == ST_ID && (sp.lookup(SP_FACTOR, te) == PS_NORMAL

|| sp.lookup(SP_GO, te) == PS_NORMAL))

{

switch (te->type)

{

case TT_PREP:

if (need_target)

{

MCperror->add

(PE_GO_BADPREP, sp);

return PS_ERROR;

}

if (te->which == PT_AS)

{

if (sp.next(type) != PS_NORMAL

|| type != ST_ID

|| sp.lookup(SP_COMMAND, te) != PS_NORMAL

|| te->type != TT_STATEMENT)

{

MCAutoNumberRef t_mode;

if (!MCNumberParse(sp.gettoken_stringref(), &t_mode)

|| MCNumberFetchAsInteger(*t_mode) < 1 || MCNumberFetchAsInteger(*t_mode) >= WM_LAST)

{

MCperror->add

(PE_GO_NOMODE, sp);

return PS_ERROR;

}

mode = (Window_mode)MCNumberFetchAsUnsignedInteger(*t_mode);

return PS_NORMAL;

}

switch (te->which)

{

case S_TOP_LEVEL:

mode = WM_TOP_LEVEL;

break;

case S_MODELESS:

mode = WM_MODELESS;

break;

case S_PALETTE:

mode = WM_PALETTE;

break;

case S_MODAL:

mode = WM_MODAL;

break;

case S_SHEET:

mode = WM_SHEET;

break;

case S_DRAWER:

mode = WM_DRAWER;

break;

case S_PULLDOWN:

mode = WM_PULLDOWN;

break;

case S_POPUP:

mode = WM_POPUP;

break;

case S_OPTION:

mode = WM_OPTION;

break;

default:

MCperror->add

(PE_GO_NOMODE, sp);

return PS_ERROR;

}

}

else

{

sp.backup();

sp.skip_token(SP_SUGAR, TT_PREP, PT_WITHOUT);

sp.skip_token(SP_LOCK, TT_UNDEFINED, LC_ERRORS);

}

return PS_NORMAL;

case TT_TO:

case TT_THE:

break;

case TT_IN:

sp.skip_token(SP_FACTOR, TT_THE);

if (sp.skip_token(SP_FACTOR, TT_CHUNK, CT_STACK) == PS_NORMAL)

{

sp.skip_token(SP_FACTOR, TT_OF);

if (sp.skip_token(SP_FACTOR, TT_CHUNK, CT_THIS) == PS_NORMAL)

{

sp.skip_token(SP_FACTOR, TT_CHUNK, CT_STACK);

thisstack = True;

return PS_NORMAL;

}

sp.skip_token(SP_FACTOR, TT_CHUNK, CT_STACK);

if (sp.parseexp(False, True, &window) != PS_NORMAL)

{

MCperror->add

(PE_GO_BADWINDOW, sp);

return PS_ERROR;

}

return PS_NORMAL;

}

sp.skip_token(SP_VALIDATION, TT_UNDEFINED, IV_UNDEFINED); // a

sp.skip_token(SP_SUGAR, TT_CHUNK, CT_UNDEFINED); // new

sp.skip_token(SP_FACTOR, TT_CHUNK, CT_STACK); // window

sp.skip_token(SP_SUGAR, TT_PREP, PT_WITHOUT); // without

sp.skip_token(SP_LOCK, TT_UNDEFINED, LC_ERRORS); // dialog

return PS_NORMAL;

case TT_OF:

need_target = True;

break;

case TT_CLASS:

if (te->which != CT_MARKED)

{

MCperror->add

(PE_GO_NODEST, sp);

return PS_ERROR;

}

marked = True;

break;

case TT_CHUNK:

nterm = (Chunk_term)te->which;

switch (ct_class(nterm))

{

case CT_DIRECT:

switch (nterm)

{

case CT_BACKWARD:

case CT_FORWARD:

{

if (sp.skip_token(SP_FACTOR, TT_IN) == PS_NORMAL)

{

widget = new MCChunk(False);

if (widget->parse(sp, False) != PS_NORMAL)

{

MCperror->add(PE_GO_BADWIDGETEXP, sp);

return PS_ERROR;

}

direction = nterm;

break;

}

card = new MCCRef;

card->etype = nterm;

MCScriptPoint oldsp(sp);

MCerrorlock++;

if (sp.parseexp(False, True, &card->startpos) != PS_NORMAL)

{

sp = oldsp;

delete card->startpos;

card->startpos = NULL;

}

MCerrorlock--;

}

break;

case CT_START:

case CT_FINISH:

card = new MCCRef;

card->etype = nterm;

sp.skip_token(SP_FACTOR, TT_CHUNK, CT_CARD);

break;

case CT_HOME:

case CT_HELP:

stack = new MCCRef;

stack->etype = nterm;

break;

default:

MCperror->add

(PE_GO_BADDIRECT, sp);

return PS_ERROR;

}

return PS_NORMAL;

case CT_ORDINAL:

oterm = nterm;

break;

case CT_TYPES:

if (lterm != CT_UNDEFINED && nterm > lterm)

{

MCperror->add

(PE_GO_BADCHUNKORDER, sp);

return PS_ERROR;

}

curref = new MCCRef;

if (oterm == CT_UNDEFINED)

{

if (nterm >= CT_FIRST_TEXT_CHUNK || nterm == CT_URL)

{

sp.backup();

nterm = CT_CARD;

curref->etype = CT_EXPRESSION;

}

else

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

curref->etype = CT_ID;

else

curref->etype = CT_EXPRESSION;

if (sp.parseexp(False, True, &curref->startpos) != PS_NORMAL)

{

delete curref;

MCperror->add

(PE_GO_BADCHUNKEXP, sp);

return PS_ERROR;

}

}

else

{

curref->etype = oterm;

oterm = CT_UNDEFINED;

}

curref->otype = nterm;

switch (nterm)

{

case CT_STACK:

if (oterm > CT_STACK)

{

MCperror->add

(PE_GO_DUPCHUNK, sp);

delete curref;

return PS_ERROR;

}

curref->next = stack;

stack = curref;

break;

case CT_BACKGROUND:

background = curref;

break;

case CT_CARD:

card = curref;

break;

default: /* chunk type */

MCperror->add

(PE_GO_BADCHUNKDEST, sp);

delete curref;

return PS_ERROR;

}

lterm = nterm;

need_target = False;

break;

default: /* chunk class */

MCperror->add

(PE_GO_BADCHUNKTYPE, sp);

return PS_ERROR;

}

break;

default: /* factor */

if (need_target)

{

if (stack != NULL || card != NULL || background != NULL)

{

MCperror->add

(PE_GO_NODEST, sp);

return PS_ERROR;

}

sp.backup();

card = new MCCRef;

card->otype = CT_CARD;

card->etype = CT_EXPRESSION;

if (sp.parseexp(False, True, &card->startpos) != PS_NORMAL)

{

MCperror->add

(PE_GO_BADCHUNKEXP, sp);

return PS_ERROR;

}

}

else

sp.backup();

return PS_NORMAL;

}

}

else

{ /* not id token type */

if (need_target)

{

if (stack != NULL || card != NULL || background != NULL)

{

MCperror->add

(PE_GO_NODEST, sp);

return PS_ERROR;

}

sp.backup();

stack = new MCCRef;

stack->otype = CT_STACK;

stack->etype = CT_EXPRESSION;

if (sp.parseexp(False, True, &stack->startpos) != PS_NORMAL)

{

MCperror->add

(PE_GO_BADCHUNKEXP, sp);

return PS_ERROR;

}

need_target = False;

}

else

{

sp.backup();

break;

}

}

}

return PS_NORMAL;

}

#ifdef /* MCGo::findstack */ LEGACY_EXEC

MCStack *MCGo::findstack(MCExecPoint &ep, Chunk_term etype, MCCard *&cptr)

{

MCStack *sptr = NULL;

MCresult->clear(False);

uint4 offset;

if (MCU_offset(SIGNATURE, ep.getsvalue(), offset) || (ep . getsvalue() . getlength() > 8 && strncmp(ep . getsvalue() . getstring(), "REVO", 4) == 0))

{

IO_handle stream = MCS_fakeopen(ep.getsvalue());

if (MCdispatcher->readfile(NULL, NULL, stream, sptr) != IO_NORMAL)

{

MCS_close(stream);

if (MCresult->isclear())

MCresult->sets("can't build stack from string");

return NULL;

}

MCS_close(stream);

return sptr;

}

if (etype == CT_STACK)

return NULL;

if (etype == CT_ID)

sptr = MCdefaultstackptr->findstackid(ep.getuint4());

else

sptr = MCdefaultstackptr->findstackname(ep.getsvalue());

if (sptr != NULL)

return sptr;

MCObject *objptr;

MCChunk *tchunk = new MCChunk(False);

MCerrorlock++;

MCScriptPoint sp(ep);

Parse_stat stat = tchunk->parse(sp, False);

if (stat == PS_NORMAL)

{

uint4 parid;

if (tchunk->getobj(ep, objptr, parid, True) == ES_NORMAL)

stat = PS_NORMAL;

else

stat = PS_ERROR;

}

MCerrorlock--;

delete tchunk;

if (stat == PS_NORMAL)

{

switch (objptr->gettype())

{

case CT_STACK:

sptr = (MCStack *)objptr;

break;

case CT_CARD:

cptr = (MCCard *)objptr;

sptr = cptr->getstack();

break;

default:

break;

}

}

else

if (MCresult->isclear())

MCresult->sets("no such card");

return sptr;

}

#endif /* MCGo::findstack */

MCStack *MCGo::findstack(MCExecContext &ctxt, MCStringRef p_value, Chunk_term etype, MCCard *&cptr)

{

MCStack *sptr = NULL;

uint4 offset;

if (MCStringFirstIndexOf(p_value, MCSTR(SIGNATURE), 0, kMCCompareExact, offset)

|| (MCStringGetLength(p_value) > 8 && MCStringBeginsWithCString(p_value, (char_t*)"REVO", kMCCompareExact)))

{

char_t* t_cstring_value;

uindex_t t_length;

/* UNCHECKED */ MCStringConvertToNative(p_value, t_cstring_value, t_length);

IO_handle stream = MCS_fakeopen(t_cstring_value, t_length);

if (MCdispatcher->readfile(NULL, NULL, stream, sptr) != IO_NORMAL)

{

MCS_close(stream);

if (MCresult->isclear())

ctxt . SetTheResultToCString("can't build stack from string");

return nil;

}

MCS_close(stream);

return sptr;

}

if (etype == CT_STACK)

return NULL;

else

sptr = MCdefaultstackptr->findstackname_string(p_value);

if (sptr != NULL)

return sptr;

MCObject *objptr;

MCChunk *tchunk = new MCChunk(False);

MCerrorlock++;

// AL-2014-11-10: [[ Bug 13972 ]] Parsing the chunk without passing through the context results

// in a parse error for unquoted stack and card names, since there is then no handler in which to

// create a new unquoted literal variable.

MCScriptPoint sp(ctxt, p_value);

Parse_stat stat = tchunk->parse(sp, False);

if (stat == PS_NORMAL)

{

uint4 parid;

if (tchunk->getobj(ctxt, objptr, parid, True))

stat = PS_NORMAL;

else

stat = PS_ERROR;

}

MCerrorlock--;

delete tchunk;

if (stat == PS_NORMAL)

{

switch (objptr->gettype())

{

case CT_STACK:

sptr = (MCStack *)objptr;

break;

case CT_CARD:

cptr = (MCCard *)objptr;

sptr = cptr->getstack();

break;

default:

break;

}

}

else

if (MCresult->isclear())

ctxt . SetTheResultToCString("no such card");

return sptr;

}

void MCGo::exec_ctxt(MCExecContext &ctxt)

{

#ifdef /* MCGo */ LEGACY_EXEC

MCStack *sptr = MCdefaultstackptr;

MCControl *bptr = NULL;

MCCard *cptr = NULL;

MCRectangle rel;

MCStack *parentptr;

// MW-2011-02-27: [[ Bug ]] Make sure that if we open as a sheet, we have a parent pointer!

if (ep.getobj()->getstack()->getopened() || MCtopstackptr == NULL)

parentptr = ep.getobj() -> getstack();

else

parentptr = MCtopstackptr;

rel = parentptr -> getrect();

MCresult->clear(False);

MCString nc = "No such card";

if (stack == NULL && background == NULL && card == NULL)

{

MCeerror->add(EE_GO_NODEST, line, pos);

return ES_ERROR;

}

if (stack != NULL)

{

switch (stack->etype)

{

case CT_HELP:

sptr = MCdefaultstackptr->findstackname(MChelpnamestring);

if (sptr == NULL)

{

if (MCresult->isclear())

MCresult->sets(nc);

return ES_NORMAL;

}

break;

case CT_HOME:

sptr = MCdispatcher->gethome();

if (sptr != MCdefaultstackptr)

{

MCdefaultstackptr->close();

MCdefaultstackptr->checkdestroy();

}

break;

case CT_THIS:

case CT_EXPRESSION:

case CT_ID:

if (stack->etype == CT_THIS)

sptr = MCdefaultstackptr;

else

{

if (stack->startpos->eval(ep) != ES_NORMAL)

{

MCeerror->add(EE_GO_BADSTACKEXP, line, pos);

return ES_ERROR;

}

sptr = findstack(ep, stack->etype, cptr);

}

if (sptr != NULL && stack->next != NULL)

{

switch (stack->next->etype)

{

case CT_ID:

case CT_EXPRESSION:

if (stack->next->startpos->eval(ep) != ES_NORMAL)

{

MCeerror->add(EE_CHUNK_BADSTACKEXP, line, pos);

return ES_ERROR;

}

if (stack->next->etype == CT_ID)

sptr = sptr->findsubstackid(ep.getuint4());

else

sptr = sptr->findsubstackname(ep.getsvalue());

break;

default:

MCeerror->add(EE_CHUNK_BADSTACKEXP, line, pos);

return ES_ERROR;

}

}

if (sptr == NULL)

{

if (MCresult->isclear())

MCresult->sets(nc);

return ES_NORMAL;

}

break;

default:

return ES_ERROR;

}

if (mode == WM_PULLDOWN || mode == WM_POPUP || mode == WM_OPTION)

{

MCButton *bptr = (MCButton *)ep.getobj();

if (ep.getobj()->gettype() == CT_BUTTON && bptr->attachmenu(sptr))

rel = MCU_recttoroot(bptr->getstack(), bptr->getrect());

else

{

MCeerror->add(EE_GO_CANTATTACH, line, pos);

return ES_ERROR;

}

}

}

sptr->stopedit();

if (background != NULL)

{

switch (ct_class(background->etype))

{

case CT_ORDINAL:

bptr = sptr->getbackground(background->etype, MCnullmcstring, CT_GROUP);

break;

case CT_ID:

case CT_EXPRESSION:

if (background->startpos->eval(ep) != ES_NORMAL)

{

MCeerror->add(EE_GO_BADBACKGROUNDEXP, line, pos);

return ES_ERROR;

}

bptr = sptr->getbackground(background->etype, ep.getsvalue(), CT_GROUP);

break;

default:

break;

}

if (bptr == NULL)

{

if (MCresult->isclear())

MCresult->sets(nc);

return ES_NORMAL;

}

sptr->setbackground(bptr);

}

int2 i;

if (card != NULL)

switch (ct_class(card->etype))

{

case CT_DIRECT:

sptr->clearbackground();

switch (card->etype)

{

case CT_BACKWARD:

case CT_FORWARD:

real8 n;

if (card->startpos != NULL)

{

if (card->startpos->eval(ep) != ES_NORMAL || ep.ton() != ES_NORMAL)

{

sptr->clearbackground();

if (MCresult->isclear())

MCresult->sets(nc);

return ES_NORMAL;

}

n = ep.getnvalue();

}

else

n = 1.0;

i = (int2)(card->etype == CT_FORWARD ? n : -n);

MCrecent->gorel(i);

break;

case CT_START:

case CT_FINISH:

MCrecent->godirect(card->etype == CT_START);

break;

default:

return ES_ERROR;

}

return ES_NORMAL;

case CT_ORDINAL:

if (card->etype == CT_RECENT)

{

MCrecent->gorel(-1);

return ES_NORMAL;

}

else

{

if (marked)

sptr->setmark();

cptr = sptr->getchild(card->etype, MCnullmcstring, card->otype);

}

break;

case CT_ID:

case CT_EXPRESSION:

if (card->startpos->eval(ep) != ES_NORMAL)

{

sptr->clearbackground();

if (MCresult->isclear())

MCresult->sets(nc);

return ES_NORMAL;

}

if (marked)

sptr->setmark();

cptr = sptr->getchild(card->etype, ep.getsvalue(), card->otype);

if (cptr == NULL)

{

sptr = findstack(ep, CT_STACK, cptr);

if (sptr == NULL)

{

if (MCresult->isclear())

MCresult->sets(nc);

return ES_NORMAL;

}

cptr = (MCCard *)sptr->getchild(CT_THIS, MCnullmcstring, CT_CARD);

}

break;

default:

sptr->clearbackground();

fprintf(stderr, "Go: ERROR no card type %d\n", card->etype);

return ES_ERROR;

}

else

if (cptr == NULL)

cptr = (MCCard *)sptr->getchild(CT_THIS, MCnullmcstring, CT_CARD);

Window_mode wm = mode;

if (wm == WM_LAST && sptr->userlevel() != 0 && window == NULL && !thisstack)

wm = (Window_mode)(sptr->userlevel() + WM_TOP_LEVEL_LOCKED);

sptr->clearmark();

sptr->clearbackground();

uint2 oldw = sptr->getrect().width;

uint2 oldh = sptr->getrect().height;

if (cptr == NULL)

{

if (MCresult->isclear())

MCresult->sets(nc);

return ES_NORMAL;

}

// Here 'oldstack' is the pointer to the stack's window we are taking over.

// If it turns out NULL then we aren't subverting another stacks' window to

// our cause :o)

MCStack *oldstack = NULL;

if (window != NULL || thisstack)

{

Window w = NULL;

if (thisstack)

{

oldstack = MCdefaultstackptr;

w = oldstack->getwindow();

}

else

{

if (window->eval(ep) != ES_NORMAL)

{

MCeerror->add(EE_GO_BADWINDOWEXP, line, pos);

return ES_ERROR;

}

if (ep.ton() == ES_NORMAL && MCscreen->uinttowindow(ep.getuint4(), w))

oldstack = MCdispatcher->findstackd(w);

else

oldstack = ep.getobj()->getstack()->findstackname(ep.getsvalue());

}

if (oldstack == NULL || !oldstack->getopened())

{

MCeerror->add(EE_GO_BADWINDOWEXP, line, pos);

return ES_ERROR;

}

if (oldstack == sptr)

oldstack = NULL;

else

{

// MW-2011-10-01: [[ Effects ]] Snapshot the old stack window.

if (!MCRedrawIsScreenLocked() && MCcur_effects != NULL)

oldstack -> snapshotwindow(oldstack -> getcurcard() -> getrect());

// MW-2011-10-01: [[ Redraw ]] Lock the screen until we are done.

MCRedrawLockScreen();

// MW-2012-09-19: [[ Bug 10383 ]] Use the 'real' mode - otherwise we get one

// modified for ICONIC or CLOSED states which screw things up a bit!

wm = oldstack->getrealmode();

if (wm == WM_MODAL || wm == WM_SHEET)

{

MCRedrawUnlockScreen();

MCeerror->add(EE_GO_BADWINDOWEXP, line, pos);

return ES_ERROR;

}

oldstack->kunfocus();

sptr->close();

MCPlayer *tptr = MCplayers;

while (tptr != NULL)

{

MCPlayer *oldptr = tptr;

tptr = tptr->getnextplayer();

if (oldptr->getstack() == oldstack)

oldptr->close();

}

if (!sptr->takewindow(oldstack))

{

MCRedrawUnlockScreen();

MCeerror->add(EE_GO_BADWINDOWEXP, line, pos);

return ES_ERROR;

}

}

}

else if (mode != WM_LAST && wm >= WM_MODELESS)

{

// MW-2011-08-18: [[ Redraw ]] Move to use redraw lock/unlock.

MCRedrawForceUnlockScreen();

}

Boolean oldtrace = MCtrace;

MCtrace = False;

// MW-2007-02-11: [[ Bug 4029 ]] - 'go invisible' fails to close stack window if window already open

if (!visible && sptr -> getflag(F_VISIBLE))

{

if (sptr -> getwindow() != NULL)

MCscreen -> closewindow(sptr -> getwindow());

sptr->setflag(False, F_VISIBLE);

}

// MW-2011-02-27: [[ Bug ]] Make sure that if we open as a sheet, we have a parent pointer!

if (wm != WM_SHEET && wm != WM_DRAWER)

parentptr = nil;

Exec_stat stat = ES_NORMAL;

Boolean added = False;

if (MCnexecutioncontexts < MAX_CONTEXTS)

{

ep.setline(line);

MCexecutioncontexts[MCnexecutioncontexts++] = &ep;

added = True;

}

#ifdef _MOBILE

// MW-2011-01-30: [[ Effects ]] On Mobile, we must twiddle with snapshots to

// ensure go stack with visual effect works.

if (oldstack == nil && MCcur_effects != nil && MCdefaultstackptr != sptr)

{

MCdefaultstackptr -> snapshotwindow(MCdefaultstackptr -> getcurcard() -> getrect());

sptr -> takewindowsnapshot(MCdefaultstackptr);

MCRedrawLockScreen();

}

#endif

if (sptr->setcard(cptr, True, True) == ES_ERROR

|| sptr->openrect(rel, wm, parentptr, WP_DEFAULT, OP_NONE) == ES_ERROR)

{

MCtrace = oldtrace;

stat = ES_ERROR;

}

if (oldstack != NULL)

{

MCRectangle trect = sptr->getcurcard()->getrect();

sptr->getcurcard()->message_with_args(MCM_resize_stack, trect.width, trect.height, oldw, oldh);

MCRedrawUnlockScreen();

if (MCcur_effects != nil)

{

Boolean t_abort;

sptr -> effectrect(sptr -> getcurcard() -> getrect(), t_abort);

}

Boolean oldlock = MClockmessages;

MClockmessages = True;

oldstack->close();

MClockmessages = oldlock;

sptr->kfocus();

}

#ifdef _MOBILE

// MW-2011-01-30: [[ Effects ]] Apply any stack level visual efect.

if (oldstack == nil && MCcur_effects != nil && MCdefaultstackptr != sptr)

{

MCRedrawUnlockScreen();

// MW-2011-10-17: [[ Bug 9811 ]] Make sure we configure the new card now.

MCRedrawDisableScreenUpdates();

sptr -> view_configure(True);

MCRedrawEnableScreenUpdates();

Boolean t_abort;

sptr -> effectrect(sptr -> getcurcard() -> getrect(), t_abort);

}

#endif

if (added)

MCnexecutioncontexts--;

MCtrace = oldtrace;

if (sptr->getmode() == WM_TOP_LEVEL || sptr->getmode() == WM_TOP_LEVEL_LOCKED)

MCdefaultstackptr = sptr;

if (MCmousestackptr != NULL)

MCmousestackptr->resetcursor(True);

if (MCabortscript)

return ES_ERROR;

return stat;

#endif /* MCGo */

MCStack *sptr = MCdefaultstackptr;

MCControl *bptr = NULL;