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

{

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

{

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;

delete widget;

}

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

{

widget = new (nothrow) MCChunk(False);

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

{

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)

{

MCAutoStringRef t_script;

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

return;

if (widget)

{

MCObject *t_object;

uint32_t t_parid;

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

{

ctxt.LegacyThrow(EE_DO_BADWIDGETEXP);

return;

}

MCInterfaceExecDoInWidget(ctxt, *t_script, (MCWidget*)t_object);

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 (widget != nil)

{

widget->compile(ctxt);

MCSyntaxFactoryExecMethod(ctxt, kMCInterfaceExecDoInWidgetMethodInfo);

}

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

}

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)

{

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

{

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

{

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)

{

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

return PS_ERROR;

}

if (te->which == MC_WHERE)

{

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

{

MCperror->add

(PE_MARK_BADWHEREEXP, sp);

return PS_ERROR;

}

return PS_NORMAL;

}

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

{

MCperror->add

(PE_MARK_NOFINDING, sp);

return PS_ERROR;

}

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

{

MCperror->add

(PE_MARK_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_MARK_BADSTRING, sp);

return PS_ERROR;

}

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

{

field = new (nothrow) MCChunk(False);

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

{

MCperror->add

(PE_MARK_BADFIELD, sp);

return PS_ERROR;

}

}

return PS_NORMAL;

}

void MCMarking::exec_ctxt(MCExecContext &ctxt)

{

if (card != NULL)

{

MCObjectPtr t_object;

if (!card->getobj(ctxt, t_object, True)

|| t_object . object -> gettype() != CT_CARD)

{

ctxt . LegacyThrow(EE_MARK_BADCARD);

return;

}

if (mark)

MCInterfaceExecMarkCard(ctxt, t_object);

else

MCInterfaceExecUnmarkCard(ctxt, t_object);

}

// SN-2014-03-21 [[ Bug 11950 ]]: 'mark' shouldn't throw an error when failing to mark when card is nil

// Any error set is discarded in the end of this block - unless is was triggered by a bad string.

else

{

if (tofind == nil)

{

if (mark)

{

if (where != nil)

MCInterfaceExecMarkCardsConditional(ctxt, where);

else

MCInterfaceExecMarkAllCards(ctxt);

}

else

{

if (where != nil)

MCInterfaceExecUnmarkCardsConditional(ctxt, where);

else

MCInterfaceExecUnmarkAllCards(ctxt);

}

}

else

{

MCAutoStringRef t_needle;

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

return;

if (mark)

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

else

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

}

ctxt . IgnoreLastError();

}

}

MCPut::~MCPut()

{

delete source;

delete dest;

// cookie

delete name;

delete domain;

delete path;

delete expires;

}

// put [ unicode | binary ] <expr>

// put [ unicode ] ( content | markup ) <expr>

// put [ new ] header <expr>

// put [ secure ] [ httponly ] cookie <name> [ for <path> ] [ on <domain> ] to <value> [ until <expiry> ]

// put <expr> ( into | after | before ) message [ box ]

// put <expr> ( into | after | before ) <chunk>

//

Parse_stat MCPut::parse(MCScriptPoint &sp)

{

Symbol_type type;

const LT *te;

initpoint(sp);

// IM-2011-08-22: [[ SERVER ]] Add support for new put variant.

// Parse: put [ secure ] [ httponly ] cookie <name> [ for path ] [ on domain ] with <value> [ until expires ]

if (sp . skip_token(SP_SERVER, TT_SERVER, SK_SECURE) == PS_NORMAL)

is_secure = true;

if (sp . skip_token(SP_SERVER, TT_SERVER, SK_HTTPONLY) == PS_NORMAL)

is_httponly = true;

if (sp . skip_token(SP_SERVER, TT_PREP, PT_COOKIE) == PS_NORMAL)

{

prep = PT_COOKIE;

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

{

MCperror->add(PE_PUT_BADEXP, sp);

return PS_ERROR;

}

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

{

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

{

MCperror->add(PE_PUT_BADEXP, sp);

return PS_ERROR;

}

}

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

{

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

{

MCperror->add(PE_PUT_BADEXP, sp);

return PS_ERROR;

}

}

sp . skip_token(SP_REPEAT, TT_UNDEFINED, RF_WITH);

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

{

MCperror->add(PE_PUT_BADEXP, sp);

return PS_ERROR;

}

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

{

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

{

MCperror->add(PE_PUT_BADEXP, sp);

return PS_ERROR;

}

}

return PS_NORMAL;

}

if (is_secure || is_httponly)

{

MCperror->add(PE_PUT_BADPREP, sp);

return PS_ERROR;

}

// MW-2011-06-22: [[ SERVER ]] Add support for new put variant.

// Parse: put new header <expr>

if (sp.skip_token(SP_SERVER, TT_SERVER, SK_NEW) == PS_NORMAL)

{

if (sp.skip_token(SP_SERVER, TT_PREP, PT_HEADER) == PS_NORMAL)

{

prep = PT_NEW_HEADER;

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

{

MCperror->add(PE_PUT_BADEXP, sp);

return PS_ERROR;

}

return PS_NORMAL;

}

else

sp.backup();

}

// MW-2012-02-23: [[ UnicodePut ]] Store whether 'unicode' was present

// in the ast.

if (sp . skip_token(SP_SERVER, TT_SERVER, SK_UNICODE) == PS_NORMAL)

is_unicode = true;

// MW-2011-06-22: [[ SERVER ]] Add support for new put variant.

// Parse: put [ unicode ] ( header | content | markup ) <expr>

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

{

if (type == ST_ID && sp.lookup(SP_SERVER, te) == PS_NORMAL && te -> type == TT_PREP)

{

prep = (Preposition_type)te -> which;

if (is_unicode && (prep == PT_HEADER || prep == PT_BINARY))

{

MCperror->add(PE_PUT_BADPREP, sp);

return PS_ERROR;

}

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

{

MCperror->add(PE_PUT_BADEXP, sp);

return PS_ERROR;

}

return PS_NORMAL;

}

else

sp.backup();

}

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

{

MCperror->add(PE_PUT_BADEXP, sp);

return PS_ERROR;

}

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

return PS_NORMAL;

if (sp.lookup(SP_FACTOR, te) != PS_NORMAL || te->type != TT_PREP)

{

sp.backup();

return PS_NORMAL;

}

prep = (Preposition_type)te->which;

if (prep != PT_BEFORE && prep != PT_INTO && prep != PT_AFTER)

{

MCperror->add(PE_PUT_BADPREP, sp);

return PS_ERROR;

}

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

{

sp.skip_token(SP_SHOW, TT_UNDEFINED, SO_MESSAGE); // "box"

return PS_NORMAL;

}

dest = new (nothrow) MCChunk(True);

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

{

MCperror->add(PE_PUT_BADCHUNK, sp);

return PS_ERROR;

}

return PS_NORMAL;

}

void MCPut::exec_ctxt(MCExecContext& ctxt)

{

MCExecValue t_value;

if (!ctxt . EvaluateExpression(source, EE_PUT_BADEXP, t_value))

return;

if (dest != nil)

{

// MCAutoValueRef t_valueref;

// MCExecTypeConvertAndReleaseAlways(ctxt, t_value . type, &t_value, kMCExecValueTypeValueRef, &(&t_valueref));

// dest -> set(ctxt, prep, *t_valueref, is_unicode);

dest -> set(ctxt, prep, t_value, is_unicode);