/* Copyright (C) 2003-2013 Runtime Revolution 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 "exec.h"

#include "dispatch.h"

#include "handler.h"

#include "scriptpt.h"

//#include "execpt.h"

#include "cmds.h"

#include "chunk.h"

#include "mcerror.h"

#include "object.h"

#include "control.h"

#include "aclip.h"

#include "vclip.h"

#include "eps.h"

#include "image.h"

#include "stack.h"

#include "card.h"

#include "stacklst.h"

#include "sellst.h"

#include "util.h"

#include "printer.h"

#include "hc.h"

#include "globals.h"

#include "securemode.h"

#include "mode.h"

#include "context.h"

#include "osspec.h"

#include "regex.h"

#include "socket.h"

#include "mcssl.h"

#include "iquantization.h"

#include "syntax.h"

#include "variable.h"

#include "exec-interface.h"

#include "resolution.h"

#include "regex.h"

MCClose::~MCClose()

{

delete fname;

delete stack;

}

Parse_stat MCClose::parse(MCScriptPoint &sp)

{

Symbol_type type;

const LT *te;

initpoint(sp);

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

{

MCperror->add

(PE_CLOSE_NOTYPE, sp);

return PS_ERROR;

}

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

{

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

{

sp.skip_token(SP_SHOW, TT_UNDEFINED, SO_WINDOW);

return PS_NORMAL;

}

else

{

sp.backup();

stack = new MCChunk(False);

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

{

MCperror->add

(PE_CLOSE_BADEXP, sp);

return PS_ERROR;

}

}

}

else

{

arg = (Open_argument)te->which;

if (arg != OA_PRINTING)

{

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

{

MCperror->add

(PE_CLOSE_BADNAME, sp);

return PS_ERROR;

}

}

}

return PS_NORMAL;

}

void MCClose::exec_ctxt(MCExecContext &ctxt)

{

#ifdef /* MCClose */ LEGACY_EXEC

char *name;

uint2 index;

switch (arg)

{

case OA_PRINTING:

MCprinter -> Close();

if (MCsystemprinter != MCprinter)

{

delete MCprinter;

MCprinter = MCsystemprinter;

}

break;

case OA_DRIVER:

case OA_FILE:

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

{

MCeerror->add

(EE_CLOSE_BADNAME, line, pos);

return ES_ERROR;

}

name = ep.getsvalue().clone();

if (IO_closefile(name))

MCresult->clear(False);

else

MCresult->sets("file is not open");

delete name;

break;

case OA_PROCESS:

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

{

MCeerror->add

(EE_CLOSE_BADNAME, line, pos);

return ES_ERROR;

}

name = ep.getsvalue().clone();

if (IO_findprocess(name, index))

MCS_closeprocess(index);

else

MCresult->sets("process is not open");

delete name;

break;

case OA_SOCKET:

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

{

MCeerror->add

(EE_CLOSE_BADNAME, line, pos);

return ES_ERROR;

}

name = ep.getsvalue().clone();

if (IO_findsocket(name, index))

{

MCS_close_socket(MCsockets[index]);

MCresult->clear(False);

}

else

MCresult->sets("socket is not open");

delete name;

break;

default:

MCStack *sptr;

if (stack == NULL)

sptr = MCdefaultstackptr;

else

{

MCObject *optr;

uint4 parid;

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

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

{

MCeerror->add

(EE_CLOSE_NOOBJ, line, pos);

return ES_ERROR;

}

sptr = (MCStack *)optr;

}

sptr->close();

sptr->checkdestroy();

}

return ES_NORMAL;

#endif /* MCClose */

if (arg == OA_OBJECT)

{

if (stack == NULL)

MCInterfaceExecCloseDefaultStack(ctxt);

else

{

MCObject *optr;

uint4 parid;

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

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

{

ctxt . LegacyThrow(EE_CLOSE_NOOBJ);

return;

}

MCInterfaceExecCloseStack(ctxt, (MCStack *)optr);

}

}

else if (arg == OA_PRINTING)

MCPrintingExecClosePrinting(ctxt);

else

{

MCNewAutoNameRef t_name;

if (!ctxt . EvalExprAsNameRef(fname, EE_CLOSE_BADNAME, &t_name))

return;

switch (arg)

{

case OA_DRIVER:

MCFilesExecCloseDriver(ctxt, *t_name);

break;

case OA_FILE:

MCFilesExecCloseFile(ctxt, *t_name);

break;

case OA_PROCESS:

MCFilesExecCloseProcess(ctxt, *t_name);

break;

case OA_SOCKET:

MCNetworkExecCloseSocket(ctxt, *t_name);

break;

default:

break;

}

}

}

void MCClose::compile(MCSyntaxFactoryRef ctxt)

{

MCSyntaxFactoryBeginStatement(ctxt, line, pos);

if (arg == OA_OBJECT)

{

if (stack == nil)

MCSyntaxFactoryExecMethod(ctxt, kMCInterfaceExecCloseDefaultStackMethodInfo);

else

{

stack -> compile_object_ptr(ctxt);

MCSyntaxFactoryExecMethod(ctxt, kMCInterfaceExecCloseStackMethodInfo);

}

}

else if (arg == OA_PRINTING)

MCSyntaxFactoryExecMethod(ctxt, kMCPrintingExecClosePrintingMethodInfo);

else

{

fname -> compile(ctxt);

switch (arg)

{

case OA_DRIVER:

MCSyntaxFactoryExecMethod(ctxt, kMCFilesExecCloseDriverMethodInfo);

break;

case OA_FILE:

MCSyntaxFactoryExecMethod(ctxt, kMCFilesExecCloseFileMethodInfo);

break;

case OA_PROCESS:

MCSyntaxFactoryExecMethod(ctxt, kMCFilesExecCloseProcessMethodInfo);

break;

case OA_SOCKET:

MCSyntaxFactoryExecMethod(ctxt, kMCNetworkExecCloseSocketMethodInfo);

break;

default:

break;

}

}

MCSyntaxFactoryEndStatement(ctxt);

}

MCEncryptionOp::~MCEncryptionOp()

{

delete ciphername;

delete source;

delete keystr;

delete keylen;

delete salt;

delete iv;

delete rsa_key;

delete rsa_passphrase;

}

Parse_stat MCEncryptionOp::parse(MCScriptPoint &sp)

{

//ENCRYPT|DECRYPT <SOURCE> USING <CIPHER> WITH [KEY] <PASSWORD|KEY> [AND SALT SALTVALUE] [AND IV IVVALUE] [AT BIT BIT]

initpoint(sp);

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

{

MCperror->add(PE_ENCRYPTION_BADSOURCE, sp);

return PS_ERROR;

}

if (sp.skip_token(SP_ENCRYPTION, TT_UNDEFINED, ENCRT_USING) != PS_NORMAL)

{

MCperror->add(PE_ENCRYPTION_NOCIPHER, sp);

return PS_ERROR;

}

if (sp.skip_token(SP_ENCRYPTION, TT_UNDEFINED, ENCRT_RSA) == PS_NORMAL)

{

is_rsa = true;

}

else

{

is_rsa = false;

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

{

MCperror->add(PE_ENCRYPTION_BADCIPHER, sp);

return PS_ERROR;

}

}

if (sp.skip_token(SP_REPEAT, TT_UNDEFINED, RF_WITH) != PS_NORMAL)

{

MCperror->add(PE_ENCRYPTION_NOKEY, sp);

return PS_ERROR;

}

if (is_rsa)

{

if (sp.skip_token(SP_ENCRYPTION, TT_UNDEFINED, ENCRT_PUBLIC) == PS_NORMAL)

rsa_keytype = RSAKEY_PUBKEY;

else if (sp.skip_token(SP_ENCRYPTION, TT_UNDEFINED, ENCRT_PRIVATE) == PS_NORMAL)

rsa_keytype = RSAKEY_PRIVKEY;

else

{

MCperror->add(PE_ENCRYPTION_BADPARAM, sp);

return PS_ERROR;

}

if (sp.skip_token(SP_ENCRYPTION, TT_UNDEFINED, ENCRT_KEY) != PS_NORMAL)

{

MCperror->add(PE_ENCRYPTION_BADPARAM, sp);

return PS_ERROR;

}

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

{

MCperror->add(PE_ENCRYPTION_BADKEY, sp);

return PS_ERROR;

}

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

{

if (sp.skip_token(SP_ENCRYPTION, TT_UNDEFINED, ENCRT_PASSPHRASE) != PS_NORMAL)

{

MCperror->add(PE_ENCRYPTION_BADPARAM, sp);

return PS_ERROR;

}

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

{

MCperror->add(PE_ENCRYPTION_BADKEY, sp);

return PS_ERROR;

}

}

}

else

{

if (sp.skip_token(SP_ENCRYPTION, TT_UNDEFINED, ENCRT_KEY) == PS_NORMAL)

ispassword = False;

else

{

ispassword = True;

sp.skip_token(SP_ENCRYPTION, TT_UNDEFINED, ENCRT_PASSWORD);

}

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

{

MCperror->add(PE_ENCRYPTION_BADKEY, sp);

return PS_ERROR;

}

// MW-2004-12-01: Bug 2406 - parsing error when attempting to compile 'IV'

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

{

Bool expect_iv; // True if we should check for 'IV' clause

if (sp.skip_token(SP_ENCRYPTION, TT_UNDEFINED, ENCRT_SALT) == PS_NORMAL)

{

if (ispassword)

{

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

{

MCperror->add(PE_ENCRYPTION_BADSALT, sp);

return PS_ERROR;

}

}

else

{

MCperror->add(PE_ENCRYPTION_BADPARAM, sp);

return PS_ERROR;

}

expect_iv = sp.skip_token(SP_FACTOR, TT_BINOP, O_AND) == PS_NORMAL;

}

else

expect_iv = True;

// MW-2004-12-29: Relax syntax slightly to allow specifying an IV as well as password and salt

if (expect_iv)

{

if (sp.skip_token(SP_ENCRYPTION, TT_UNDEFINED, ENCRT_IV) == PS_NORMAL)

{

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

{

MCperror->add(PE_ENCRYPTION_BADIV, sp);

return PS_ERROR;

}

}

else

{

MCperror->add(PE_ENCRYPTION_BADPARAM, sp);

return PS_ERROR;

}

}

}

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

{

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

{

MCperror->add(PE_ENCRYPTION_BADBIT, sp);

return PS_ERROR;

}

if (sp.skip_token(SP_ENCRYPTION, TT_UNDEFINED, ENCRT_BIT) != PS_NORMAL)

{

MCperror->add(PE_ENCRYPTION_NOBIT, sp);

return PS_ERROR;

}

}

}

return PS_NORMAL;

}

#ifdef /* MCEncryptionOp::exec_rsa */ LEGACY_EXEC

Exec_stat MCEncryptionOp::exec_rsa(MCExecPoint &ep)

{

Exec_stat t_status = ES_NORMAL;

char *t_rsa_key = nil;

uint32_t t_rsa_keylength;

char *t_rsa_passphrase = nil;

char *t_rsa_out = nil;

uint32_t t_rsa_out_length;

char *t_result = nil;

uint32_t t_error = EE_UNDEFINED;

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

{

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

t_status = ES_ERROR;

}

if (t_status == ES_NORMAL)

{

const MCString &t_str = ep.getsvalue();

t_rsa_keylength = t_str.getlength();

if (!MCCStringCloneSubstring(t_str.getstring(), t_rsa_keylength, t_rsa_key))

{

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

t_status = ES_ERROR;

}

}

if (t_status == ES_NORMAL && rsa_passphrase != nil)

{

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

{

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

t_status = ES_ERROR;

}

if (t_status == ES_NORMAL)

{

const MCString &t_str = ep.getsvalue();

if (!MCCStringCloneSubstring(t_str.getstring(), t_str.getlength(), t_rsa_passphrase))

{

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

t_status = ES_ERROR;

}

}

}

if (t_status == ES_NORMAL)

{

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

{

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

t_status = ES_ERROR;

}

}

if (t_status == ES_NORMAL)

{

const MCString &t_string = ep.getsvalue();

if (MCCrypt_rsa_op(!isdecrypt, rsa_keytype, t_string.getstring(), t_string.getlength(),

t_rsa_key, t_rsa_keylength, t_rsa_passphrase, t_rsa_out, t_rsa_out_length, t_result, t_error))

{

MCVariable *t_var;

t_var = ep.getit() -> evalvar(ep);

if (t_var != NULL)

t_var -> grab(t_rsa_out, t_rsa_out_length);

else

free(t_rsa_out);

MCresult->clear();

}

else

{

if (t_result != nil)

MCresult->grab(t_result, MCCStringLength(t_result));

else

{

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

t_status = ES_ERROR;

}

}

}

MCCStringFree(t_rsa_key);

MCCStringFree(t_rsa_passphrase);

return t_status;

}

#endif /* MCEncryptionOp::exec_rsa */

void MCEncryptionOp::exec_ctxt(MCExecContext &ctxt)

{

#ifdef /* MCEncryptionOp */ LEGACY_EXEC

MCresult->clear(False);

if (is_rsa)

return exec_rsa(ep);

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

{

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

return ES_ERROR;

}

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

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

{

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

return ES_ERROR;

}

uint4 keystringlength = ep.getsvalue().getlength();

char *keystring = new char[keystringlength+1];

memcpy(keystring,ep.getsvalue().getstring(),keystringlength);

uint2 keybits = 0;

if (keylen)

{

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

{

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

return ES_ERROR;

}

keybits = ep.getuint2();

}

char *ivstr,*saltstr;

ivstr = saltstr = NULL;

uint2 saltlen,ivlen;

saltlen = ivlen = 0;

if (salt)

{

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

{

delete cipherstring;

delete keystring;

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

return ES_ERROR;

}

saltstr = ep.getsvalue().clone();

saltlen = ep.getsvalue().getlength();

}

if (iv)

{

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

{

delete cipherstring;

delete keystring;

delete saltstr;

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

return ES_ERROR;

}

ivstr = ep.getsvalue().clone();

ivlen = ep.getsvalue().getlength();

}

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

{

delete cipherstring;

delete keystring;

delete saltstr;

delete ivstr;

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

return ES_ERROR;

}

uint4 outlen;

char *outstr = SSL_encode(isdecrypt, cipherstring,

ep.getsvalue().getstring(), ep.getsvalue().getlength(), outlen,

keystring, keystringlength, ispassword, keybits,saltstr,saltlen,ivstr,ivlen);

if (!outstr)

{

char sslerrbuf[256];

if (outlen == 789)

strcpy(sslerrbuf,"invalid cipher name");

else if (outlen == 790)

strcpy(sslerrbuf,"invalid keystring for specified keysize");

else if (outlen == 791)

{

delete cipherstring;

delete keystring;

delete saltstr;

delete ivstr;

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

return ES_ERROR;

}

else

SSLError(sslerrbuf);

MCresult->copysvalue(sslerrbuf);

}

else

{

MCVariable *t_var;

t_var = ep.getit() -> evalvar(ep);

if (t_var != NULL)

t_var -> grab(outstr, outlen);

else

free(outstr);

MCresult->clear(False);

}

delete cipherstring;

delete keystring;

delete saltstr;

delete ivstr;

return ES_NORMAL;

#endif /* MCEncryptionOp */

ctxt . SetTheResultToEmpty();

if (is_rsa)

{

MCAutoStringRef t_key;

if (!ctxt . EvalExprAsStringRef(rsa_key, EE_OPEN_BADNAME, &t_key))

return;

MCAutoStringRef t_passphrase;

if (!ctxt . EvalOptionalExprAsStringRef(rsa_passphrase, kMCEmptyString, EE_OPEN_BADNAME, &t_passphrase))

return;

MCAutoStringRef t_data;

if (!ctxt . EvalExprAsStringRef(source, EE_OPEN_BADNAME, &t_data))

return;

if (isdecrypt)

MCSecurityExecRsaDecrypt(ctxt, *t_data, rsa_keytype != RSAKEY_PRIVKEY, *t_key, *t_passphrase);

else

MCSecurityExecRsaEncrypt(ctxt, *t_data, rsa_keytype != RSAKEY_PRIVKEY, *t_key, *t_passphrase);

}

else

{

MCNewAutoNameRef t_cipher;

if (!ctxt . EvalExprAsNameRef(ciphername, EE_OPEN_BADNAME, &t_cipher))

return;

MCAutoStringRef t_key;

if (!ctxt . EvalExprAsStringRef(keystr, EE_OPEN_BADNAME, &t_key))

return;

uinteger_t keybits;

if (!ctxt . EvalOptionalExprAsUInt(keylen, 0, EE_OPEN_BADNAME, keybits)

|| keybits > 65535) // Ensure that keybits is an uint2

return;

MCAutoStringRef t_iv;

MCAutoStringRef t_salt;

if (salt != nil && !ctxt . EvalExprAsStringRef(salt, EE_OPEN_BADNAME, &t_salt))

return;

if (iv != nil && !ctxt . EvalExprAsStringRef(iv, EE_OPEN_BADNAME, &t_iv))

return;

MCAutoStringRef t_data;

if (!ctxt . EvalExprAsStringRef(source, EE_READ_BADAT, &t_data))

return;

if (ispassword)

{

if (isdecrypt)

MCSecurityExecBlockDecryptWithPassword(ctxt, *t_data, *t_cipher, *t_key, *t_salt, *t_iv, keybits);

else

MCSecurityExecBlockEncryptWithPassword(ctxt, *t_data, *t_cipher, *t_key, *t_salt, *t_iv, keybits);

}

else

{

if (isdecrypt)

MCSecurityExecBlockDecryptWithKey(ctxt, *t_data, *t_cipher, *t_key, *t_iv, keybits);

else

MCSecurityExecBlockEncryptWithKey(ctxt, *t_data, *t_cipher, *t_key, *t_iv, keybits);

}

}

}

void MCEncryptionOp::compile(MCSyntaxFactoryRef ctxt)

{

MCSyntaxFactoryBeginStatement(ctxt, line, pos);

source -> compile(ctxt);

if (is_rsa)

{

MCSyntaxFactoryEvalConstantBool(ctxt, rsa_keytype != RSAKEY_PRIVKEY);

rsa_key -> compile(ctxt);

if (rsa_passphrase != nil)

rsa_passphrase -> compile(ctxt);

else

MCSyntaxFactoryEvalConstantNil(ctxt);

if (isdecrypt)

MCSyntaxFactoryExecMethod(ctxt, kMCSecurityExecRsaDecryptMethodInfo);

else

MCSyntaxFactoryExecMethod(ctxt, kMCSecurityExecRsaEncryptMethodInfo);

}

else

{

ciphername -> compile(ctxt);

keystr -> compile(ctxt);

if (ispassword)

{

if (salt)

salt -> compile(ctxt);

else

MCSyntaxFactoryEvalConstantNil(ctxt);

}

if (iv)

iv -> compile(ctxt);

else

MCSyntaxFactoryEvalConstantNil(ctxt);

if (keylen)

keylen -> compile(ctxt);

else

MCSyntaxFactoryEvalConstantUInt(ctxt, 0);

if (ispassword)

{

if (isdecrypt)

MCSyntaxFactoryExecMethod(ctxt, kMCSecurityExecBlockDecryptWithPasswordMethodInfo);

else

MCSyntaxFactoryExecMethod(ctxt, kMCSecurityExecBlockEncryptWithPasswordMethodInfo);

}

else

{

if (isdecrypt)

MCSyntaxFactoryExecMethod(ctxt, kMCSecurityExecBlockDecryptWithKeyMethodInfo);

else

MCSyntaxFactoryExecMethod(ctxt, kMCSecurityExecBlockEncryptWithKeyMethodInfo);

}

}

MCSyntaxFactoryEndStatement(ctxt);

}

MCExport::~MCExport()

{

delete fname;

delete exsdisplay;

delete exsstack;

delete exsrect;

delete mname;

delete image;

delete dest;

delete palette_color_count;

delete palette_color_list;

delete size;

// MERG-2014-07-11: metadata array

delete metadata;

}

Parse_stat MCExport::parse(MCScriptPoint &sp)

{

Symbol_type type;

const LT *te;

initpoint(sp);

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

{

MCperror->add(PE_EXPORT_NOTYPE, sp);

return PS_ERROR;

}

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

{

sformat = (Export_format)te->which;

// MERG-2014-07-17: Bugfix because export JPEG etc was failing to set the format

format = sformat;

}

else

{

sp.backup();

image = new MCChunk(False);

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

{

MCperror->add(PE_EXPORT_BADTYPE, sp);

return PS_ERROR;

}

}

if (sformat == EX_SNAPSHOT)

{

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

{

bool t_has_rectangle;

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

{

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

{

MCperror->add(PE_EXPORT_BADTYPE, sp);

return PS_ERROR;

}

t_has_rectangle = true;

}

else

t_has_rectangle = false;

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

{

Symbol_type type;

const LT *te = NULL;

// MW-2006-05-04: Bug 3506 - crash in specific case due to not checking result of sp.lookup

// MW-2007-09-11: [[ Bug 5242 ]] - the alternate of this if used to fail if te == NULL, this

// can happen though if we are looking at a variable chunk.

if (sp.next(type) == PS_NORMAL && sp.lookup(SP_FACTOR, te) == PS_NORMAL && te -> type == TT_CHUNK && te -> which == CT_STACK)

{

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

{

MCperror->add(PE_IMPORT_BADFILENAME, sp);

return PS_ERROR;

}

sp.skip_token(SP_FACTOR, TT_OF);

if (sp.skip_token(SP_EXPORT, TT_UNDEFINED, EX_DISPLAY) == PS_NORMAL)

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

{

MCperror->add(PE_EXPORT_BADTYPE, sp);

return PS_ERROR;

}

}

else if (te == NULL || te -> type != TT_TO)

{

sp . backup();

image = new MCChunk(False);

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

{

MCperror -> add(PE_IMPORT_BADFILENAME, sp);

return PS_ERROR;

}

bool t_need_effects;

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

t_need_effects = true, with_effects = true;

else if (sp . skip_token(SP_SUGAR, TT_PREP, PT_WITHOUT) == PS_NORMAL)

t_need_effects = true, with_effects = false;

else

t_need_effects = false;

if (t_need_effects &&

sp . skip_token(SP_SUGAR, TT_UNDEFINED, SG_EFFECTS) != PS_NORMAL)

{

// MERG-2014-07-11: [[ ImageMetadata ]] Allow metadata without having to specify effects

if (with_effects && sp . skip_token(SP_FACTOR, TT_PROPERTY, P_METADATA) == PS_NORMAL)

{

sp . backup();

sp . backup();

}

else

{

MCperror -> add(PE_IMPORT_BADFILENAME, sp);

return PS_ERROR;

}

}

}

}

}

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

{

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

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

{

MCperror -> add(PE_IMPORT_BADFILENAME, sp);

return PS_ERROR;

}

}

}

// MERG-2014-07-11: [[ ImageMetadata ]] metadata array

if (sp . skip_token(SP_REPEAT, TT_UNDEFINED, RF_WITH) == PS_NORMAL || sp . skip_token(SP_FACTOR, TT_BINOP, O_AND) == PS_NORMAL )

{

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

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

{

MCperror -> add(PE_IMPORT_BADFILENAME, sp);

return PS_ERROR;

}

}

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

{

MCperror->add(PE_EXPORT_NOTO, sp);

return PS_ERROR;

}

if (sp.skip_token(SP_OPEN, TT_UNDEFINED) == PS_NORMAL)

{

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

{

MCperror->add(PE_EXPORT_BADFILENAME, sp);

return PS_ERROR;

}

}

else

{

dest = new MCChunk(True);

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

{

MCperror->add(PE_EXPORT_NOFILE, sp);

return PS_ERROR;

}

}

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

{

if (sp.skip_token(SP_EXPORT, TT_UNDEFINED) != PS_NORMAL)

{

MCperror->add(PE_EXPORT_NOMASK, sp);

return PS_ERROR;

}

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

{

MCperror->add(PE_EXPORT_BADMASKNAME, sp);

return PS_ERROR;

}

}

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

{

if (sp.next(type) != PS_NORMAL || sp.lookup(SP_EXPORT, te) != PS_NORMAL)

{

MCperror->add(PE_EXPORT_BADTYPE, sp);

return PS_ERROR;

}

format = (Export_format)te->which;

if (format == EX_RAW)

{

Export_format t_format_list[] = {EX_RAW_ARGB, EX_RAW_ABGR, EX_RAW_RGBA, EX_RAW_BGRA};

Export_format t_format = EX_RAW;

for (uint32_t i=0; i<(sizeof(t_format_list) / sizeof(t_format_list[0])); i++)

{

if (sp.skip_token(SP_EXPORT, TT_UNDEFINED, t_format_list[i]) == PS_NORMAL)

{

t_format = t_format_list[i];

break;

}

}

format = t_format;

}

if (format == EX_GIF || format == EX_PNG || MCU_israwimageformat(format))

{

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

{

if (sp.skip_token(SP_COMMAND, TT_STATEMENT, S_PALETTE) == PS_NORMAL)