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

//#include "execpt.h"

#include "handler.h"

#include "scriptpt.h"

#include "newobj.h"

#include "chunk.h"

#include "param.h"

#include "mcerror.h"

#include "property.h"

#include "object.h"

#include "button.h"

#include "field.h"

#include "image.h"

#include "card.h"

#include "eps.h"

#include "graphic.h"

#include "group.h"

#include "scrolbar.h"

#include "player.h"

#include "aclip.h"

#include "vclip.h"

#include "stack.h"

#include "dispatch.h"

#include "stacklst.h"

#include "sellst.h"

#include "undolst.h"

#include "util.h"

#include "date.h"

#include "printer.h"

#include "debug.h"

#include "cmds.h"

#include "mode.h"

#include "osspec.h"

#include "hndlrlst.h"

#include "securemode.h"

#include "syntax.h"

#include "stacksecurity.h"

#include "license.h"

#ifdef _SERVER

#include "srvscript.h"

#endif

#include "exec.h"

MCChoose::~MCChoose()

{

delete etool;

}

Parse_stat MCChoose::parse(MCScriptPoint &sp)

{

Symbol_type type;

const LT *te;

initpoint(sp);

sp.skip_token(SP_FACTOR, TT_THE);

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

{

MCperror->add(PE_CHOOSE_NOTOKEN, sp);

return PS_ERROR;

}

if (sp.lookup(SP_TOOL, te) != PS_NORMAL)

{

sp.backup();

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

{

MCperror->add(PE_CHOOSE_BADEXP, sp);

return PS_ERROR;

}

sp.skip_token(SP_TOOL, TT_END);

return PS_NORMAL;

}

else

{

littool = (Tool)te->which;

while (sp.skip_token(SP_TOOL, TT_TOOL) == PS_NORMAL)

;

sp.skip_token(SP_TOOL, TT_END);

}

return PS_NORMAL;

}

void MCChoose::exec_ctxt(MCExecContext &ctxt)

{

#ifdef /* MCChoose */ LEGACY_EXEC

if (etool != NULL)

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

{

MCeerror->add

(EE_CHOOSE_BADEXP, line, pos);

return ES_ERROR;

}

return MCU_choose_tool(ep, littool, line, pos);

#endif /* MCChoose */

MCAutoStringRef t_string;

if (!ctxt . EvalOptionalExprAsStringRef(etool, kMCEmptyString, EE_CHOOSE_BADEXP, &t_string))

return;

MCInterfaceExecChooseTool(ctxt, *t_string, littool);

}

void MCChoose::compile(MCSyntaxFactoryRef ctxt)

{

MCSyntaxFactoryBeginStatement(ctxt, line, pos);

if (etool != nil)

etool -> compile(ctxt);

else

MCSyntaxFactoryEvalConstantNil(ctxt);

MCSyntaxFactoryEvalConstantInt(ctxt, littool);

MCSyntaxFactoryExecMethodWithArgs(ctxt, kMCInterfaceExecChooseToolMethodInfo, 1);

MCSyntaxFactoryEndStatement(ctxt);

}

MCConvert::~MCConvert()

{

delete container;

delete source;

}

Parse_stat MCConvert::parse(MCScriptPoint &sp)

{

initpoint(sp);

MCerrorlock++;

container = new MCChunk(True);

MCScriptPoint tsp(sp);

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

{

sp = tsp;

MCerrorlock--;

delete container;

container = NULL;

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

{

MCperror->add

(PE_CONVERT_NOCONTAINER, sp);

return PS_ERROR;

}

}

else

MCerrorlock--;

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

{

if (parsedtformat(sp, fform, fsform) != PS_NORMAL)

return PS_ERROR;

}

if (sp.skip_token(SP_FACTOR, TT_TO) != PS_NORMAL)

{

MCperror->add

(PE_CONVERT_NOTO, sp);

return PS_ERROR;

}

if (parsedtformat(sp, pform, sform) != PS_NORMAL)

return PS_ERROR;

return PS_NORMAL;

}

Parse_stat MCConvert::parsedtformat(MCScriptPoint &sp, Convert_form &firstform,

Convert_form &secondform)

{

const LT *te;

Symbol_type type;

Boolean needformat = True;

Convert_form localeform = CF_UNDEFINED;

while (True)

{

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

{

if (needformat)

{

MCperror->add

(PE_CONVERT_NOFORMAT, sp);

return PS_ERROR;

}

else

return PS_NORMAL;

}

if (sp.lookup(SP_CONVERT, te) != PS_NORMAL)

{

if (needformat)

{

MCperror->add

(PE_CONVERT_NOTFORMAT, sp);

return PS_ERROR;

}

else

{

sp.backup();

break;

}

}

switch (te->which)

{

case CF_ABBREVIATED:

case CF_SHORT:

case CF_LONG:

case CF_INTERNET:

if (firstform == CF_UNDEFINED)

firstform = (Convert_form)te->which;

else

secondform = (Convert_form)te->which;

break;

case CF_SYSTEM:

case CF_ENGLISH:

localeform = (Convert_form)te->which;

break;

case CF_DATE:

case CF_TIME:

if (firstform == CF_UNDEFINED)

firstform = (Convert_form)(te->which + 1 + localeform);

else

if (firstform > CF_INTERNET)

{

if (secondform == CF_UNDEFINED)

secondform = (Convert_form)(te->which + 1 + localeform);

else

{

uint2 dummy = secondform;

dummy += te->which + localeform;

secondform = (Convert_form)dummy;

}

}

else

{

uint2 dummy = firstform;

dummy += te->which + localeform;

firstform = (Convert_form)dummy;

}

needformat = False;

break;

default:

firstform = (Convert_form)te->which;

return PS_NORMAL;

}

if (sp.skip_token(SP_FACTOR, TT_BINOP, O_AND) == PS_NORMAL)

{

if (needformat)

{

MCperror->add

(PE_CONVERT_BADAND, sp);

return PS_ERROR;

}

else

needformat = True;

}

else

if (!needformat)

break;

}

return PS_NORMAL;

}

void MCConvert::exec_ctxt(MCExecContext& ctxt)

{

#ifdef /* MCConvert */ LEGACY_EXEC

MCresult->clear(False);

if (container != NULL)

{

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

{

MCeerror->add

(EE_CONVERT_CANTGET, line, pos);

return ES_ERROR;

}

}

else

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

{

MCeerror->add

(EE_CONVERT_CANTGET, line, pos);

return ES_ERROR;

}

if (!MCD_convert(ep, fform, fsform, pform, sform))

{

MCresult->sets("invalid date");

return ES_NORMAL;

}

Exec_stat stat;

if (container == NULL)

stat = ep . getit() -> set(ep);

else

stat = container->set(ep, PT_INTO);

if (stat != ES_NORMAL)

{

MCeerror->add

(EE_CONVERT_CANTSET, line, pos, ep.getsvalue());

return ES_ERROR;

}

return ES_NORMAL;

#endif /* MCConvert */

MCAutoStringRef t_input;

MCAutoStringRef t_output;

if (container != NULL)

{

if (!ctxt . EvalExprAsStringRef(container, EE_CONVERT_CANTGET, &t_input))

return;

}

else

{

if (!ctxt . EvalExprAsStringRef(source, EE_CONVERT_CANTGET, &t_input))

return;

}

if (container == NULL)

MCDateTimeExecConvertIntoIt(ctxt, *t_input, fform, fsform, pform, sform);

else

{

MCDateTimeExecConvert(ctxt, *t_input, fform, fsform, pform, sform, &t_output);

container -> set(ctxt, PT_INTO, *t_output);

if (ctxt . HasError())

ctxt . LegacyThrow(EE_CONVERT_CANTSET, *t_output);

}

}

void MCConvert::compile(MCSyntaxFactoryRef ctxt)

{

MCSyntaxFactoryBeginStatement(ctxt, line, pos);

if (container == nil)

source -> compile(ctxt);

else

container -> compile_inout(ctxt);

MCSyntaxFactoryEvalConstantInt(ctxt, fform);

MCSyntaxFactoryEvalConstantInt(ctxt, fsform);

MCSyntaxFactoryEvalConstantInt(ctxt, pform);

MCSyntaxFactoryEvalConstantInt(ctxt, sform);

if (container == nil)

MCSyntaxFactoryExecMethod(ctxt, kMCDateTimeExecConvertIntoItMethodInfo);

else

MCSyntaxFactoryExecMethodWithArgs(ctxt, kMCDateTimeExecConvertMethodInfo, 0, 1, 2, 3, 4, 0);

MCSyntaxFactoryEndStatement(ctxt);

}

MCDo::~MCDo()

{

delete source;

delete alternatelang;

}

Parse_stat MCDo::parse(MCScriptPoint &sp)

{

initpoint(sp);

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

{

MCperror->add(PE_DO_BADEXP, sp);

return PS_ERROR;

}

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

{

if (sp.skip_token(SP_SUGAR, TT_UNDEFINED, SG_BROWSER) == PS_NORMAL)

browser = True;

else if (sp.skip_token(SP_SUGAR, TT_UNDEFINED, SG_CALLER) == PS_NORMAL)

caller = true;

else

{

MCperror->add(PE_DO_BADENV, sp);

return PS_ERROR;

}

return PS_NORMAL;

}

if (sp.skip_token(SP_FACTOR, TT_PREP, PT_AS) == PS_NORMAL)

{

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

{

MCperror->add(PE_DO_BADLANG, sp);

return PS_ERROR;

}

}

return PS_NORMAL;

}

void MCDo::exec_ctxt(MCExecContext& ctxt)

{

#ifdef /* MCDo */ LEGACY_EXEC

MCExecPoint *epptr;

if (browser)

{

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

{

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

return ES_ERROR;

}

return MCModeExecuteScriptInBrowser(ep . getsvalue());

}

if (alternatelang != NULL)

{

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

{

MCeerror->add

(EE_DO_BADLANG, line, pos);

return ES_ERROR;

}

char *langname = ep.getsvalue().clone();

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

{

MCeerror->add

(EE_DO_BADEXP, line, pos);

return ES_ERROR;

}

if (!MCSecureModeCheckDoAlternate(line, pos))

return ES_ERROR;

MCString s = ep.getsvalue();

MCS_doalternatelanguage(s, langname);

delete langname;

return ES_NORMAL;

}

Boolean added = False;

if (MCnexecutioncontexts < MAX_CONTEXTS)

{

ep.setline(line);

MCexecutioncontexts[MCnexecutioncontexts++] = &ep;

added = True;

}

if (debug)

{

if (MCdebugcontext >= MCnexecutioncontexts)

MCdebugcontext = MCnexecutioncontexts - 1;

epptr = MCexecutioncontexts[MCdebugcontext];

}

else

{

if (caller)

{

if (MCnexecutioncontexts < 2)

{

if (added)

MCnexecutioncontexts--;

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

return ES_ERROR;

}

epptr = MCexecutioncontexts[MCnexecutioncontexts - 2];

}

else

epptr = &ep;

}

if (source->eval(*epptr) != ES_NORMAL)

{

if (added)

MCnexecutioncontexts--;

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

return ES_ERROR;

}

// MW-2013-11-15: [[ Bug 11277 ]] If no handler, then evaluate in context of the

// server script object.

Exec_stat stat;

stat = ep.doscript(*epptr, line, pos);

if (added)

MCnexecutioncontexts--;

return stat;

#endif /* MCDo */

MCAutoStringRef t_script;

if (!ctxt . EvalExprAsStringRef(source, EE_DO_BADEXP, &t_script))

return;

if (browser)

{

MCLegacyExecDoInBrowser(ctxt, *t_script);

return;

}

if (alternatelang != NULL)

{

MCAutoStringRef t_language;

if (!ctxt . EvalExprAsStringRef(alternatelang, EE_DO_BADLANG, &t_language))

return;

MCScriptingExecDoAsAlternateLanguage(ctxt, *t_script, *t_language);

return;

}

if (debug)

{

MCDebuggingExecDebugDo(ctxt, *t_script, line, pos);

return;

}

// AL-2014-11-17: [[ Bug 14044 ]] Do in caller not implemented

if (caller)

{

MCEngineExecDoInCaller(ctxt, *t_script, line, pos);

return;

}

MCEngineExecDo(ctxt, *t_script, line, pos);

}

void MCDo::compile(MCSyntaxFactoryRef ctxt)

{

MCSyntaxFactoryBeginStatement(ctxt, line, pos);

source -> compile(ctxt);

if (browser)

MCSyntaxFactoryExecMethod(ctxt, kMCLegacyExecDoInBrowserMethodInfo);

else if (alternatelang != nil)

{

alternatelang -> compile(ctxt);

MCSyntaxFactoryExecMethod(ctxt, kMCScriptingExecDoAsAlternateLanguageMethodInfo);

}

else

{

MCSyntaxFactoryEvalConstantInt(ctxt, line);

MCSyntaxFactoryEvalConstantInt(ctxt, pos);

if (debug)

MCSyntaxFactoryExecMethod(ctxt, kMCDebuggingExecDebugDoMethodInfo);

else

MCSyntaxFactoryExecMethod(ctxt, kMCEngineExecDoMethodInfo);

}

MCSyntaxFactoryEndStatement(ctxt);

}

typedef struct

{

const char *token;

const char *command;

}

DT;

static DT domenu_table[] = {

{"new stack...", "create stack\n\

set the mainStack of the topStack to \"Home\"\n\

modal \"Stack Properties\""},

{"open stack...", "answer file \"Choose a stack to open...\"\n\

if it is not empty then\n\

set the cursor to watch\n\

topLevel it\n\

end if"},

{"close stack", "close this stack"},

{"compact stack", "compact stack"},

{"print card", "print this card"},

{"print stack...", "print this stack"},

{"quit hypercard", "quit"},

{"quit", "quit"},

{"undo", "undo"},

{"cut", "cut"},

{"copy", "copy"},

{"paste", "paste"},

{"new card", "create card"},

{"delete card", "delete this card"},

{"cut card", "cut this card"},

{"copy card", "copy this card"},

{"background", "edit background"},

{"back", "go back"},

{"home", "go home"},

{"help", "help"},

{"recent", "go recent"},

{"first", "go to first card"},

{"prev", "go to prev card"},

{"next", "go to next card"},

{"last", "go to last card"},

{"find...", "modeless \"Find\""},

{"message", "modeless \"Message Box\""},

{"bring closer", "set the layer of the selobj to the layer of the selobj+1"},

{"send farther", "set the layer of the selobj to the layer of the selobj-1"},

{"new button", "create button"},

{"new field", "create field"},

{"new background", "create background"},

};

/* doMenu items

About Hypercard..., New Stack..., Open Stack..., Close Stack, Save A

Copy..., Compact Stack, Protect Stack..., Delete Stack..., Page

Setup..., Print Field..., Print Card, Print Stack..., Print Report...,

Quit Hypercard, Undo, Cut, Copy, Paste, New Card, Delete Card, Cut

Card, Copy Card, Text Style..., Background, Icon..., Back, Home, Help,

recent, First, Prev, Next, Last, Find..., Message, Scroll, Next

Window, Button Info..., Field Info..., Card Info..., Bkgnd Info...,

Stack Info..., Bring Closer, Send Farther, New Button, New Field, New

Background, Plain, Bold, Italic, Underline, Outline, Shadow, Condense,

Extend, Group, Other..., Select, Select All, Fill, Invert, Pickup,

Darken, Lighten, Trace Edges, Rotate Left, Rotate Right, Flip

Vertical, Flip Horizontal, Opaque, Transparent, Keep, Revert, grid,

Fatbits, Power Keys, Line Size..., brush Shape..., Edit pattern...,

Polygon Sides..., Draw filled, Draw centered, Draw multiple, Rotate,

Slant, distort, Perspective, Import Paint..., Export Paint..., New

Icon, Close Icon Editor, Duplicate Icon, Cut Icon, Copy Icon, Erase,

Frame, Gray, Mirror Horizontal, Mirror Vertical, Rotate 90, Shadow,

Delete Report, Cut Report, Copy Report, Report Items..., Report

Name..., New Report, New Item, Item Info..., Close Script, Save

Script, Revert To Saved, Print Script, Find Again, Find Selection,

Scroll To Selection, Replace..., Replace Again, Comment, Uncomment,

Set Checkpoint, Step, Step Into, Trace, Go, Trace Delay..., Abort,

Variable Watcher, Message Watcher

*/

const char *MCDoMenu::lookup(MCStringRef s)

{

uint2 size = ELEMENTS(domenu_table);

while(size--)

if (MCStringIsEqualToCString(s, domenu_table[size].token, kMCCompareCaseless))

return domenu_table[size].command;

return NULL;

}

MCDoMenu::~MCDoMenu()

{

delete source;

}

Parse_stat MCDoMenu::parse(MCScriptPoint &sp)

{

initpoint(sp);

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

{

MCperror->add

(PE_DOMENU_BADEXP, sp);

return PS_ERROR;

}

return PS_NORMAL;

}

void MCDoMenu::exec_ctxt(MCExecContext& ctxt)

{

#ifdef /* MCDoMenu */ LEGACY_EXEC

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

{

MCeerror->add

(EE_DOMENU_BADEXP, line, pos);

return ES_ERROR;

}

const char *dstring = lookup(ep.getsvalue());

if (dstring == NULL)

{

char *tptr = ep.getsvalue().clone();

ep.setstringf("doMenu \"%s\" not implemented", tptr);

delete tptr;

MCresult->sets(ep.getsvalue());

}

else

{

ep.getobj()->domess(dstring);

}

return ES_NORMAL;

#endif /* MCDoMenu */

MCAutoStringRef t_option;

if (!ctxt . EvalExprAsStringRef(source, EE_DOMENU_BADEXP, &t_option))

return;

MCLegacyExecDoMenu(ctxt, *t_option);

}

void MCDoMenu::compile(MCSyntaxFactoryRef ctxt)

{

MCSyntaxFactoryBeginStatement(ctxt, line, pos);

source-> compile(ctxt);

MCSyntaxFactoryExecMethod(ctxt, kMCLegacyExecDoMenuMethodInfo);

MCSyntaxFactoryEndStatement(ctxt);

}

MCEdit::~MCEdit()

{

delete target;

delete m_at;

}

Parse_stat MCEdit::parse(MCScriptPoint &sp)

{

initpoint(sp);

sp.skip_token(SP_FACTOR, TT_THE);

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

{

MCperror->add(PE_EDIT_NOSCRIPT, sp);

return PS_ERROR;

}

if (sp.skip_token(SP_FACTOR, TT_OF) != PS_NORMAL)

{

MCperror->add(PE_EDIT_NOOF, sp);

return PS_ERROR;

}

target = new MCChunk(False);

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

{

MCperror->add(PE_EDIT_NOTARGET, sp);

return PS_ERROR;

}

// MERG 2013-9-13: [[ EditScriptChunk ]] Added line and column

if (sp.skip_token(SP_FACTOR, TT_PREP, PT_AT) == PS_NORMAL)

{

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

{

MCperror->add(PE_EDIT_NOAT, sp);

return PS_ERROR;

}

}

return PS_NORMAL;

}

void MCEdit::exec_ctxt(MCExecContext& ctxt)

{

#ifdef /* MCEdit */ LEGACY_EXEC

MCObject *optr;

uint4 parid;

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

{

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

return ES_ERROR;

}

// MERG 2013-9-13: [[ EditScriptChunk ]] Added at expression that's passed through as a second parameter to editScript

MCString t_at;

t_at = NULL;

if (m_at != NULL)

{

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

{

MCeerror->add

(EE_EDIT_BADAT, line, pos);

return ES_ERROR;

}

t_at = ep.getsvalue();

}

// MW-2010-10-13: [[ Bug 7476 ]] Make sure we temporarily turn off lock messages

// before invoking the method - since it requires message sending to work!

Boolean t_old_lock;

t_old_lock = MClockmessages;

MClockmessages = False;

optr->editscript(t_at);

MClockmessages = t_old_lock;

return ES_NORMAL;

#endif /* MCEdit */

MCObject *optr;

uint4 parid;

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

{

ctxt . LegacyThrow(EE_EDIT_BADTARGET);

return;

}

// MERG 2013-9-13: [[ EditScriptChunk ]] Added at expression that's passed through as a second parameter to editScript

MCAutoStringRef t_at;

if (!ctxt . EvalOptionalExprAsNullableStringRef(m_at, EE_EDIT_BADAT, &t_at))

return;

MCIdeExecEditScriptOfObject(ctxt, optr, *t_at);

}

void MCEdit::compile(MCSyntaxFactoryRef ctxt)

{

MCSyntaxFactoryBeginStatement(ctxt, line, pos);

target -> compile_object_ptr(ctxt);

MCSyntaxFactoryExecMethod(ctxt, kMCIdeExecEditScriptOfObjectMethodInfo);

MCSyntaxFactoryEndStatement(ctxt);

}

MCFind::~MCFind()

{

delete tofind;

delete field;

}

Parse_stat MCFind::parse(MCScriptPoint &sp)

{

Symbol_type type;

const LT *te;

initpoint(sp);

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

{

MCperror->add

(PE_FIND_NOSTRING, sp);

return PS_ERROR;

}

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

mode = (Find_mode)te->which;

else

sp.backup();

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

{

MCperror->add

(PE_FIND_BADSTRING, sp);

return PS_ERROR;

}

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

{

field = new MCChunk(False);

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

{

MCperror->add

(PE_FIND_BADFIELD, sp);

return PS_ERROR;

}

}

return PS_NORMAL;

}

void MCFind::exec_ctxt(MCExecContext& ctxt)

{

#ifdef /* MCFind */ LEGACY_EXEC

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

{

MCeerror->add

(EE_FIND_BADSTRING, line, pos);

return ES_ERROR;

}

if (ep.getsvalue().getlength() == 0)

{

if (MCfoundfield != NULL)

MCfoundfield->clearfound();

MCresult->sets(MCnotfoundstring);

return ES_NORMAL;

}

MCdefaultstackptr->find(ep, mode, ep.getsvalue(), field);

return ES_NORMAL;

#endif /* MCFind */

MCAutoStringRef t_needle;

if (!ctxt . EvalExprAsStringRef(tofind, EE_FIND_BADSTRING, &t_needle))

return;

MCInterfaceExecFind(ctxt, mode, *t_needle, field);

// SN-2014-03-21: [[ Bug 11949 ]] 'find' shouldn't throw an error on a failure

// but MCInterfaceExecFind would cause the context to be set on error if finding fails

ctxt . IgnoreLastError();

}

void MCFind::compile(MCSyntaxFactoryRef ctxt)

{

MCSyntaxFactoryBeginStatement(ctxt, line, pos);

MCSyntaxFactoryEvalConstantInt(ctxt, mode);

tofind -> compile(ctxt);

field -> compile(ctxt);

MCSyntaxFactoryExecMethod(ctxt, kMCInterfaceExecFindMethodInfo);

MCSyntaxFactoryEndStatement(ctxt);

}

MCGet::~MCGet()

{

delete value;

}

Parse_stat MCGet::parse(MCScriptPoint &sp)

{

initpoint(sp);

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

{

MCperror->add

(PE_GET_BADEXP, sp);

return PS_ERROR;

}

return PS_NORMAL;

}

void MCGet::exec_ctxt(MCExecContext& ctxt)

{

#ifdef /* MCGet */ LEGACY_EXEC

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

{

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

return ES_ERROR;

}

if (ep.getit()->set(ep) != ES_NORMAL)

{

MCeerror->add(EE_GET_CANTSET, line, pos, ep.getsvalue());

return ES_ERROR;

}

return ES_NORMAL;

#endif /* MCGet */

MCExecValue t_value;

if (!ctxt . EvaluateExpression(value, EE_GET_BADEXP, t_value))

return;

MCEngineExecGet(ctxt, t_value);

}

void MCGet::compile(MCSyntaxFactoryRef ctxt)

{

MCSyntaxFactoryBeginStatement(ctxt, line, pos);

value -> compile(ctxt);

MCSyntaxFactoryExecMethod(ctxt, kMCEngineExecGetMethodInfo);

MCSyntaxFactoryEndStatement(ctxt);

}

MCMarking::~MCMarking()

{

delete where;

delete tofind;

delete field;

delete card;

}

Parse_stat MCMarking::parse(MCScriptPoint &sp)

{

Symbol_type type;

const LT *te;

initpoint(sp);

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

{

MCperror->add

(PE_MARK_NOCARDS, sp);

return PS_ERROR;

}

if (sp.lookup(SP_MARK, te) != PS_NORMAL)

{

sp.backup();

card = new MCChunk(False);

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

{

MCperror->add

(PE_MARK_NOTCARDS, sp);

return PS_ERROR;

}

return PS_NORMAL;

}

if (te->which == MC_ALL)

{

if (sp.skip_token(SP_MARK, TT_UNDEFINED, MC_CARDS) != PS_NORMAL)

{

MCperror->add

(PE_MARK_NOCARDS, sp);

return PS_ERROR;

}

return PS_NORMAL;

}

if (te->which != MC_CARDS)

{

MCperror->add

(PE_MARK_NOCARDS, sp);

return PS_ERROR;

}

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

{

MCperror->add

(PE_MARK_NOBYORWHERE, sp);

return PS_ERROR;

}

if (sp.lookup(SP_MARK,te) != PS_NORMAL

|| te->which != MC_BY && te->which != MC_WHERE)

{

MCperror->add

(PE_MARK_NOTBYORWHERE, sp);