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

#include "stackfileformat.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)

{

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;

}

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

{

MCStack *sptr = NULL;

uint4 offset;

if (MCStringFirstIndexOf(p_value, MCSTR(kMCStackFileMetaCardSignature), 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)

{

MCStack *sptr = MCdefaultstackptr;

MCControl *bptr = NULL;

MCCard *cptr = NULL;

ctxt . SetTheResultToEmpty();

// go ( forward | backward ) in widget ...

if (widget != nil)

{

MCObject *t_object;

uint32_t t_parid;

if (!widget->getobj(ctxt, t_object, t_parid, True) || t_object->gettype() != CT_WIDGET)

{

ctxt.LegacyThrow(EE_GO_BADWIDGETEXP);

return;

}

if (direction == CT_BACKWARD)

MCInterfaceExecGoBackInWidget(ctxt, (MCWidget*)t_object);

else

MCInterfaceExecGoForwardInWidget(ctxt, (MCWidget*)t_object);

return;

}

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

{

ctxt . LegacyThrow(EE_GO_NODEST);

return;

}

bool t_is_home;

t_is_home = false;

if (stack != NULL)

{

switch (stack->etype)

{

case CT_HELP:

sptr = MCdefaultstackptr->findstackname(MCNAME("help"));

break;

case CT_HOME:

t_is_home = true;

sptr = MCdispatcher->gethome();

break;

case CT_THIS:

case CT_EXPRESSION:

case CT_ID:

if (stack->etype == CT_THIS)

sptr = MCdefaultstackptr;

else if (stack -> etype == CT_ID)

{

uinteger_t t_stack_id;

if (!ctxt . EvalExprAsStrictUInt(stack -> startpos, EE_GO_BADSTACKEXP, t_stack_id))

return;

sptr = MCdefaultstackptr->findstackid(t_stack_id);

}

else

{

MCAutoStringRef t_value;

if (!ctxt . EvalExprAsStringRef(stack -> startpos, EE_GO_BADSTACKEXP, &t_value))

return;

sptr = findstack(ctxt, *t_value, stack->etype, cptr);

}

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

{

switch (stack->next->etype)

{

case CT_ID:

{

uinteger_t t_stack_id;

if (!ctxt . EvalExprAsStrictUInt(stack -> next -> startpos, EE_CHUNK_BADSTACKEXP, t_stack_id))

return;

sptr = sptr -> findsubstackid(t_stack_id);

}

break;

case CT_EXPRESSION:

{

MCNewAutoNameRef t_name;

if (!ctxt . EvalExprAsNameRef(stack -> next -> startpos, EE_CHUNK_BADSTACKEXP, &t_name))

return;

sptr = sptr -> findsubstackname(*t_name);

}

break;

default:

ctxt . LegacyThrow(EE_CHUNK_BADSTACKEXP);

return;

}

}

break;

default:

ctxt . Throw();

return;

}

}

// SN-2014-05-13 [[ Bug 12423 ]]

// Temporary fix: stopedit put back where it was before refactoring

if (sptr != nil)

sptr -> stopedit();

if (background != NULL && sptr != nil)

{

switch (ct_class(background->etype))

{

case CT_ORDINAL:

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

break;

case CT_ID:

case CT_EXPRESSION:

{

MCAutoStringRef t_string;

if (!ctxt . EvalExprAsStringRef(background -> startpos, EE_GO_BADBACKGROUNDEXP, &t_string))

return;

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

}

break;

default:

break;

}

}

if (bptr != nil)

sptr -> setbackground(bptr);

real8 n;

bool t_is_recent;

t_is_recent = false;

if (card != NULL && sptr != nil)

{

switch (ct_class(card->etype))

{

case CT_DIRECT:

sptr -> clearbackground();

t_is_recent = true;

switch (card->etype)

{

case CT_BACKWARD:

case CT_FORWARD:

if (!ctxt . EvalOptionalExprAsDouble(card -> startpos, 1.0, EE_GO_BADCARDEXP, n))

return;

break;

case CT_START:

case CT_FINISH:

break;

default:

ctxt . Throw();

return;

}

break;

case CT_ORDINAL:

if (card->etype == CT_RECENT)

t_is_recent = true;

// AL-2014-09-10: [[ Bug 13394 ]] Go marked card missing in refactor

else if (marked)

sptr -> setmark();

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

break;

case CT_ID:

case CT_EXPRESSION:

{

MCAutoStringRef t_exp;

if (!ctxt . EvalExprAsStringRef(card -> startpos, EE_GO_BADCARDEXP, &t_exp))

{

sptr -> clearbackground();

return;

}

// AL-2014-09-10: [[ Bug 13394 ]] Go marked card missing in refactor

if (marked)

sptr -> setmark();

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

// SN-2014-06-03 [[ Bug 12552]] go to url "internet stack path" does not work

// If getchild() failed, we try to find a stack from the expression

if (cptr == NULL)

{

sptr = findstack(ctxt, *t_exp, CT_STACK, cptr);

if (sptr == NULL)

{

if (MCresult->isclear())

MCresult->setvalueref(MCSTR("No such a card"));

return;

}

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

}

}

break;

default:

sptr -> clearbackground();

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

ctxt . Throw();

return;

}

sptr -> clearbackground();

sptr -> clearmark();

}

else

if (cptr == nil && sptr != nil)

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

MCAutoStringRef t_window;

if (!thisstack)

{

if (!ctxt . EvalOptionalExprAsNullableStringRef(window, EE_GO_BADWINDOWEXP, &t_window))

return;

}

ctxt . SetLineAndPos(line, pos);

if (t_is_home)

MCInterfaceExecGoHome(ctxt, cptr);

else if (t_is_recent)

{

switch (ct_class(card->etype))

{

case CT_DIRECT:

switch (card->etype)

{

case CT_BACKWARD:

case CT_FORWARD:

MCInterfaceExecGoCardRelative(ctxt, card->etype == CT_FORWARD, n);

break;

case CT_START:

case CT_FINISH:

MCInterfaceExecGoCardEnd(ctxt, card->etype == CT_START);

break;

default:

break;

}

break;

case CT_ORDINAL:

MCInterfaceExecGoRecentCard(ctxt);

break;

default:

break;

}

}

else if (window != nil)

MCInterfaceExecGoCardInWindow(ctxt, cptr, *t_window, visible == True, thisstack == True);

else

MCInterfaceExecGoCardAsMode(ctxt, cptr, mode, visible == True, thisstack == True);

}

void MCGo::compile(MCSyntaxFactoryRef ctxt)

{

if (widget != nil)

{

MCSyntaxFactoryBeginStatement(ctxt, line, pos);

widget->compile(ctxt);

MCSyntaxFactoryExecMethod(ctxt, direction == CT_BACKWARD ? kMCInterfaceExecGoBackInWidgetMethodInfo : kMCInterfaceExecGoForwardInWidgetMethodInfo);

MCSyntaxFactoryEndStatement(ctxt);

return;

}

MCSyntaxFactoryBeginStatement(ctxt, line, pos);

bool t_is_home, t_is_relative;

t_is_home = false;

t_is_relative = false;

if (stack != nil)

{

switch (stack->etype)

{

case CT_HELP:

MCSyntaxFactoryEvalMethod(ctxt, kMCInterfaceEvalHelpStackAsOptionalObjectMethodInfo);

case CT_HOME:

t_is_home = true;

MCSyntaxFactoryEvalMethod(ctxt, kMCInterfaceEvalHomeStackAsOptionalObjectMethodInfo);

case CT_THIS:

case CT_ID:

case CT_EXPRESSION:

if (stack -> etype == CT_THIS)

MCSyntaxFactoryEvalMethod(ctxt, kMCInterfaceEvalDefaultStackAsOptionalObjectMethodInfo);

else

{

stack -> startpos -> compile(ctxt);

MCSyntaxFactoryEvalMethod(ctxt, kMCInterfaceEvalStackByValueMethodInfo);

}

if (stack -> next != nil)

{

switch (stack->next->etype)

{

case CT_ID:

stack -> next -> startpos -> compile(ctxt);

MCSyntaxFactoryEvalMethod(ctxt, kMCInterfaceEvalSubstackOfOptionalStackByIdMethodInfo);

break;

case CT_EXPRESSION:

stack -> next -> startpos -> compile(ctxt);

MCSyntaxFactoryEvalMethod(ctxt, kMCInterfaceEvalSubstackOfOptionalStackByNameMethodInfo);

break;

default:

// ERROR

break;

}

}

default:

MCSyntaxFactoryEvalMethod(ctxt, kMCInterfaceEvalDefaultStackAsOptionalObjectMethodInfo);

}

}

else

MCSyntaxFactoryEvalMethod(ctxt, kMCInterfaceEvalDefaultStackAsOptionalObjectMethodInfo);

if (background != nil)

{

switch(ct_class(background -> etype))

{

case CT_ORDINAL:

MCSyntaxFactoryEvalConstantUInt(ctxt, background -> etype);

MCSyntaxFactoryEvalMethod(ctxt, kMCInterfaceEvalOptionalStackWithBackgroundByOrdinalMethodInfo);

break;

case CT_ID:

background -> startpos -> compile(ctxt);

MCSyntaxFactoryEvalMethod(ctxt, kMCInterfaceEvalOptionalStackWithBackgroundByIdMethodInfo);

break;

case CT_EXPRESSION:

background -> startpos -> compile(ctxt);

MCSyntaxFactoryEvalMethod(ctxt, kMCInterfaceEvalOptionalStackWithBackgroundByNameMethodInfo);

break;

default:

// ERROR

break;

}

}

if (card != nil)

{

switch(ct_class(card -> etype))

{

case CT_DIRECT:

t_is_relative = true;

switch (card->etype)

{

case CT_BACKWARD:

case CT_FORWARD:

MCSyntaxFactoryEvalConstantBool(ctxt, card->etype == CT_FORWARD);

if (card -> startpos != nil)

card -> startpos -> compile(ctxt);

else

MCSyntaxFactoryEvalConstantInt(ctxt, 1);

return;

case CT_START:

case CT_FINISH:

MCSyntaxFactoryEvalConstantBool(ctxt, card->etype == CT_START);

break;

default:

// ERROR

break;

}

break;

case CT_ORDINAL:

if (card -> etype == CT_RECENT)

t_is_relative = true;

MCSyntaxFactoryEvalConstantBool(ctxt, marked);

MCSyntaxFactoryEvalConstantUInt(ctxt, card -> etype);

MCSyntaxFactoryEvalMethod(ctxt, kMCInterfaceEvalCardOfOptionalStackByOrdinalMethodInfo);

break;

case CT_ID:

MCSyntaxFactoryEvalConstantBool(ctxt, marked);

card -> startpos -> compile(ctxt);

MCSyntaxFactoryEvalMethod(ctxt, kMCInterfaceEvalCardOfOptionalStackByIdMethodInfo);

break;

case CT_EXPRESSION:

MCSyntaxFactoryEvalConstantBool(ctxt, marked);

card -> startpos -> compile(ctxt);

MCSyntaxFactoryEvalMethod(ctxt, kMCInterfaceEvalCardOfOptionalStackByNameMethodInfo);

break;

default:

// ERROR

break;

}

}

else

MCSyntaxFactoryEvalMethod(ctxt, kMCInterfaceEvalThisCardOfOptionalStackMethodInfo);

if (stack != nil && t_is_home)

MCSyntaxFactoryExecMethod(ctxt, kMCInterfaceExecGoHomeMethodInfo); // skip background parameter

else if (card != nil && t_is_relative)

{

switch (ct_class(card->etype))

{

case CT_DIRECT:

switch (card->etype)

{

case CT_BACKWARD:

case CT_FORWARD:

MCSyntaxFactoryExecMethod(ctxt, kMCInterfaceExecGoCardRelativeMethodInfo);

break;

case CT_START:

case CT_FINISH:

MCSyntaxFactoryExecMethod(ctxt, kMCInterfaceExecGoCardEndMethodInfo);

break;

default:

break;

}

break;

case CT_ORDINAL:

MCSyntaxFactoryExecMethod(ctxt, kMCInterfaceExecGoRecentCardMethodInfo);

break;

default:

break;

}

}

else

{

if (window != nil)

{

if (!thisstack)

window -> compile(ctxt);

else

MCSyntaxFactoryEvalConstantNil(ctxt);

}

else

MCSyntaxFactoryEvalConstantUInt(ctxt, mode);

MCSyntaxFactoryEvalConstantBool(ctxt, thisstack == True);

MCSyntaxFactoryEvalConstantBool(ctxt, visible == True);

if (window != nil)

MCSyntaxFactoryExecMethod(ctxt, kMCInterfaceExecGoCardInWindowMethodInfo);

else

MCSyntaxFactoryExecMethod(ctxt, kMCInterfaceExecGoCardAsModeMethodInfo);

}

MCSyntaxFactoryEndStatement(ctxt);

}

MCHide::~MCHide()

{

delete object;

delete effect;

}

Parse_stat MCHide::parse(MCScriptPoint &sp)

{

initpoint(sp);

Symbol_type type;

const LT *te;

initpoint(sp);

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

if (sp.lookup(SP_SHOW, te) == PS_NORMAL)

{

if (te->which == SO_CARD || te->which == SO_BACKGROUND)

{

MCScriptPoint oldsp(sp);

if (sp.skip_token(SP_FACTOR, TT_CLASS, CT_CARD) == PS_NORMAL)

{

card = (Show_object)te->which == SO_CARD;

which = SO_PICTURE;

return PS_NORMAL;

}

if (sp.skip_token(SP_SHOW, TT_UNDEFINED, SO_WINDOW) == PS_NORMAL)

{

which = SO_PALETTE;

return PS_NORMAL;

}

sp = oldsp;

sp.backup();

}

else

{

which = (Show_object)te->which;

if (which == SO_GROUPS)

return PS_NORMAL;

if (which == SO_WINDOW)

{

sp.backup();

which = SO_OBJECT;

}