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

#include "mcssl.h"

#include "iquantization.h"

#include "core.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;

}

Exec_stat MCClose::exec(MCExecPoint &ep)

{

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;

}

MCEncryptionOp::~MCEncryptionOp()

{

delete ciphername;

delete source;

delete keystr;

delete keylen;

delete it;

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;

}

}

}

getit(sp, it);

return PS_NORMAL;

}

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 = it -> 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;

}

Exec_stat MCEncryptionOp::exec(MCExecPoint &ep)

{

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 = it -> 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;

}

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;

}

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;

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)

{

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;

}

}

}

}

}

}

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)

{

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

{

MCperror->add(PE_EXPORT_BADPALETTE, sp);

return PS_ERROR;

}

palette_type = kMCImagePaletteTypeCustom;

// palette specified. if raw format then export as indexed data

if (format == EX_RAW)

format = EX_RAW_INDEXED;

}

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

{

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

{

MCperror->add(PE_EXPORT_BADPALETTE, sp);

return PS_ERROR;

}

palette_type = kMCImagePaletteTypeWebSafe;

}

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

{

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

{

MCperror->add(PE_EXPORT_BADPALETTE, sp);

return PS_ERROR;

}

palette_type = kMCImagePaletteTypeOptimal;

}

else if (sp.parseexp(False, True, &palette_color_count) == PS_NORMAL)

{

if (sp.skip_token(SP_VALIDATION, TT_UNDEFINED, IV_COLOR) != PS_NORMAL)

{

MCperror->add(PE_EXPORT_BADPALETTE, sp);

return PS_ERROR;

}

sp.skip_token(SP_SUGAR, TT_UNDEFINED, SG_OPTIMIZED);

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

{

MCperror->add(PE_EXPORT_BADPALETTE, sp);

return PS_ERROR;

}

palette_type = kMCImagePaletteTypeOptimal;

}

else

{

MCperror->add(PE_EXPORT_BADPALETTE, sp);

return PS_ERROR;

}

}

if (format == EX_RAW)

format = EX_RAW_ARGB;

}

}

return PS_NORMAL;

}

Exec_stat MCExport::exec(MCExecPoint &ep)

{

MCBitmap *t_img = nil;

MCObject *optr = NULL;

Exec_stat t_status = ES_NORMAL;

bool t_delete_file_on_error = false;

if (image != NULL)

{

//get image from chunk

uint4 parid;

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

{

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

return ES_ERROR;

}

}

if (sformat == EX_SNAPSHOT)

{

char *srect = NULL;

if (exsrect != NULL)

{

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

{

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

return ES_ERROR;

}

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

}

char *sstack = NULL;

if (exsstack != NULL)

{

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

{

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

delete srect;

return ES_ERROR;

}

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

}

char *sdisp = NULL;

if (exsdisplay != NULL)

{

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

{

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

return ES_ERROR;

}

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

}

MCPoint t_wanted_size;

if (size != NULL)

{

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

{

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

return ES_ERROR;

}

if (!MCU_stoi2x2(ep . getsvalue(), t_wanted_size . x, t_wanted_size . y))

{

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

return ES_ERROR;

}

}

MCRectangle r;

r.x = r.y = -32768;

r.width = r.height = 0;

if (srect != NULL)

{

int2 i1, i2, i3, i4;

if (!MCU_stoi2x4(srect, i1, i2, i3, i4))

{

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

delete srect;

delete sdisp;

delete sstack;

return ES_ERROR;

}

r.x = i1;

r.y = i2;

r.width = MCU_max(i3 - i1, 0);

r.height = MCU_max(i4 - i2, 0);

}

delete srect;

uint4 w = 0;

if (sstack != NULL)

{

if (!MCU_stoui4(sstack, w))

{

delete sstack;

delete sdisp;

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

return ES_ERROR;

}

}

delete sstack;

if (optr != NULL)

{

/* UNCHECKED */ t_img = optr -> snapshot(exsrect == NULL ? nil : &r, size == NULL ? nil : &t_wanted_size, with_effects);

// OK-2007-04-24: Bug found in ticket 2006072410002591, when exporting a snapshot of an object

// while the object is being moved in the IDE, it is possible for the snapshot rect not to intersect with

// the rect of the object, causing optr -> snapshot() to return NULL, and a crash.

if (t_img == nil)

{

delete sdisp;

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

return ES_ERROR;

}

}

else

{

t_img = MCscreen->snapshot(r, w, sdisp);

if (t_img == nil)

{

delete sdisp;

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

return ES_ERROR;

}

}

delete sdisp;

}

else if (optr == NULL)

{

optr = MCselected->getfirst();

if (optr == NULL)

{

MCCard *cardptr = MCdefaultstackptr->getchild(CT_THIS, MCnullmcstring, CT_CARD);

optr = cardptr->getchild(CT_LAST, MCnullmcstring, CT_IMAGE, CT_UNDEFINED);

}

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

{

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

return ES_ERROR;

}

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

{

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

return ES_ERROR;

}

}

IO_handle stream = NULL;

char *name = NULL;

if (fname != NULL)

{

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

{

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

return ES_ERROR;

}

if (MCsecuremode & MC_SECUREMODE_DISK)

{

MCeerror->add(EE_DISK_NOPERM, line, pos, name);

return ES_ERROR;

}

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

if ((stream = MCS_open(name, IO_WRITE_MODE, False, False, 0)) == NULL)

{

MCeerror->add(EE_EXPORT_CANTOPEN, line, pos, name);

delete name;

return ES_ERROR;

}

}

IO_handle mstream = NULL;

if (mname != NULL)

{

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

{

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

return ES_ERROR;

}

if (MCsecuremode & MC_SECUREMODE_DISK)

{

MCeerror->add(EE_DISK_NOPERM, line, pos, name);

return ES_ERROR;

}

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

if ((mstream = MCS_open(mfile, IO_WRITE_MODE, False, False, 0)) == NULL)

{

MCeerror->add(EE_EXPORT_CANTOPEN, line, pos, mfile);

delete mfile;

return ES_ERROR;

}

delete mfile;

}