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

#include "dispatch.h"

#include "handler.h"

#include "scriptpt.h"

#include "cmds.h"

#include "chunk.h"

#include "mcerror.h"

#include "object.h"

#include "mccontrol.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 "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 (nothrow) 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)

{

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;

}

}

}

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;

}

void MCEncryptionOp::exec_ctxt(MCExecContext &ctxt)

{

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

}

}

}

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

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

const LT *t_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(t_type) == PS_NORMAL && sp.lookup(SP_FACTOR, t_te) == PS_NORMAL && t_te -> type == TT_CHUNK && Chunk_term(t_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 (t_te == NULL || t_te -> type != TT_TO)

{

sp . backup();

image = new (nothrow) 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

bool t_is_image;

t_is_image = false;

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;

}

t_is_image = true;

}

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

{

MCperror->add(PE_EXPORT_NOTO, sp);

return PS_ERROR;

}

if (!t_is_image &&

sp.skip_token(SP_VALIDATION, TT_UNDEFINED, IV_ARRAY) == PS_NORMAL)

{

dest = new (nothrow) MCChunk(True);

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

{

MCperror->add(PE_EXPORT_NOARRAY, sp);

return PS_ERROR;

}

sformat = EX_OBJECT;

}

else

{

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

}

void MCExport::exec_ctxt(MCExecContext &ctxt)

{

if (sformat == EX_OBJECT)

{

if (image == nil)

{

ctxt . LegacyThrow(EE_EXPORT_NOTANIMAGE);

return;

}

MCObject *optr = NULL;

//get image from chunk

uint4 parid;

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

{

ctxt . LegacyThrow(EE_EXPORT_NOSELECTED);

return;

}

MCAutoArrayRef t_array;

MCInterfaceExecExportObjectToArray(ctxt, optr, &t_array);

if (ctxt . HasError())

return;

dest->set(ctxt, PT_INTO, *t_array);

if (ctxt . HasError())

{

ctxt . LegacyThrow(EE_EXPORT_CANTWRITE);

return;

}

return;

}

MCAutoDataRef t_return_data;

MCAutoStringRef t_filename;

if (!ctxt . EvalOptionalExprAsNullableStringRef(fname, EE_EXPORT_BADNAME, &t_filename))

return;

MCAutoStringRef t_mask_filename;

if (!ctxt . EvalOptionalExprAsNullableStringRef(mname, EE_EXPORT_BADNAME, &t_mask_filename))

return;

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

MCAutoArrayRef t_metadata_array;

MCImageMetadata t_metadata;

if (!ctxt . EvalOptionalExprAsArrayRef(metadata, kMCEmptyArray , EE_EXPORT_NOSELECTED, &t_metadata_array))

return;

MCImageParseMetadata(ctxt, *t_metadata_array, t_metadata);

MCObject *optr = NULL;

if (image != NULL)

{

//get image from chunk

uint4 parid;

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

{

ctxt . LegacyThrow(EE_EXPORT_NOSELECTED);

return;

}

}

MCInterfaceImagePaletteSettings t_settings;

MCInterfaceImagePaletteSettings *t_settings_ptr = nil;

switch (palette_type)

{

case kMCImagePaletteTypeCustom:

{

MCColor *t_colors;

uindex_t t_count;

MCAutoStringRef t_input;

if (!ctxt . EvalExprAsStringRef(palette_color_list, EE_EXPORT_BADPALETTE, &t_input))

return;

if (MCStringIsEmpty(*t_input)

|| !MCImageParseColourList(*t_input, t_count, t_colors))

{

ctxt . LegacyThrow(EE_EXPORT_BADPALETTE);

return;

}

MCInterfaceMakeCustomImagePaletteSettings(ctxt, t_colors, t_count, t_settings);

t_settings_ptr = &t_settings;

}

break;

case kMCImagePaletteTypeOptimal:

{

integer_t *t_count_ptr = nil;

integer_t t_count;

if (!ctxt . EvalOptionalExprAsInt(palette_color_count, 0, EE_EXPORT_BADPALETTESIZE, t_count))

return;

if (t_count != 0)

t_count_ptr = &t_count;

MCInterfaceMakeOptimalImagePaletteSettings(ctxt, t_count_ptr, t_settings);

t_settings_ptr = &t_settings;

}

break;

case kMCImagePaletteTypeWebSafe:

MCInterfaceMakeWebSafeImagePaletteSettings(ctxt, t_settings);

t_settings_ptr = &t_settings;

break;

case kMCImagePaletteTypeEmpty:

t_settings . type = kMCImagePaletteTypeEmpty;

break;

}

// AL-2014-10-27: [[ Bug 13804 ]] Make sure execution stops here if there was an error creating palette settings

if (ctxt . HasError())

return;

bool t_success;

t_success = true;

if (sformat == EX_SNAPSHOT)

{

MCRectangle *t_rect_ptr;

MCRectangle t_rect;

t_rect_ptr = &t_rect;

t_success = ctxt . EvalOptionalExprAsRectangle(exsrect, nil, EE_IMPORT_BADNAME, t_rect_ptr);

MCPoint t_size;

MCPoint *t_size_ptr = nil;

t_size_ptr = &t_size;

if (t_success)

t_success = ctxt . EvalOptionalExprAsPoint(size, nil, EE_EXPORT_NOSELECTED, t_size_ptr);

if (t_success)

{

if (exsstack != NULL)

{

MCAutoStringRef t_stack_name, t_display;

t_success = ctxt . EvalExprAsStringRef(exsstack, EE_EXPORT_NOSELECTED, &t_stack_name);

if (t_success)

t_success = ctxt . EvalOptionalExprAsNullableStringRef(exsdisplay, EE_EXPORT_NOSELECTED, &t_display);

if (t_success)

{

if (*t_filename == nil)

MCInterfaceExecExportSnapshotOfStack(ctxt, *t_stack_name, *t_display, t_rect_ptr, t_size_ptr, format, t_settings_ptr, &t_metadata, &t_return_data);

else

MCInterfaceExecExportSnapshotOfStackToFile(ctxt, *t_stack_name, *t_display, t_rect_ptr, t_size_ptr, format, t_settings_ptr, &t_metadata, *t_filename, *t_mask_filename);

}

}

else if (optr != NULL)

{

if (*t_filename == nil)

MCInterfaceExecExportSnapshotOfObject(ctxt, optr, t_rect_ptr, with_effects, t_size_ptr, format, t_settings_ptr, &t_metadata, &t_return_data);

else

MCInterfaceExecExportSnapshotOfObjectToFile(ctxt, optr, t_rect_ptr, with_effects, t_size_ptr, format, t_settings_ptr, &t_metadata, *t_filename, *t_mask_filename);

}

else

{

if (*t_filename == nil)

MCInterfaceExecExportSnapshotOfScreen(ctxt, t_rect_ptr, t_size_ptr, format, t_settings_ptr, &t_metadata, &t_return_data);

else

MCInterfaceExecExportSnapshotOfScreenToFile(ctxt, t_rect_ptr, t_size_ptr, format, t_settings_ptr, &t_metadata, *t_filename, *t_mask_filename);

}

}

}

else

{

if (*t_filename == nil)

MCInterfaceExecExportImage(ctxt, (MCImage *)optr, format, t_settings_ptr, &t_metadata, &t_return_data);

else

MCInterfaceExecExportImageToFile(ctxt, (MCImage *)optr, format, t_settings_ptr, &t_metadata, *t_filename, *t_mask_filename);

}

MCInterfaceImagePaletteSettingsFree(ctxt, t_settings);

if (*t_return_data != nil)

{

dest->set(ctxt, PT_INTO, *t_return_data);

if (ctxt . HasError())

{

ctxt . LegacyThrow(EE_EXPORT_CANTWRITE);

return;

}

}

}

////////////////////////////////////////////////////////////////////////////////

MCFilter::~MCFilter()

{

delete container;

delete target;

delete source;

delete pattern;

}

// JS-2013-07-01: [[ EnhancedFilter ]] Rewritten to support new filter syntax.

Parse_stat MCFilter::parse(MCScriptPoint &sp)

{

// Syntax :

// filter [ { lines | items | keys | elements } of ] <container_or_exp>

// { with | without | [ not ] matching }

// [ { wildcard | regex } [ pattern ] ] <pattern>

// [ into <container> ]

//

Parse_errors t_error;

t_error = PE_UNDEFINED;

initpoint(sp);

// Parse the chunk type (if present)

if (t_error == PE_UNDEFINED)

{

// First check for 'lines' or 'items'.

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

chunktype = CT_LINE;

else if (sp.skip_token(SP_FACTOR, TT_CLASS, CT_ITEM) == PS_NORMAL)

chunktype = CT_ITEM;

else if (sp.skip_token(SP_FACTOR, TT_FUNCTION, F_KEYS) == PS_NORMAL)

chunktype = CT_KEY;

else if (sp.skip_token(SP_FACTOR, TT_CLASS, CT_ELEMENT) == PS_NORMAL)

chunktype = CT_ELEMENT;

// If we parsed a chunk then ensure there's an 'of'

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

t_error = PE_FILTER_BADDEST;

}

// If there was no error and no chunk type then default to line

if (t_error == PE_UNDEFINED && chunktype == CT_UNDEFINED)

chunktype = CT_LINE;

// Next parse the source container or expression

if (t_error == PE_UNDEFINED)

{

MCerrorlock++;

MCScriptPoint tsp(sp);

container = new (nothrow) MCChunk(True);

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

{

sp = tsp;

MCerrorlock--;

delete container;

container = NULL;

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

{

t_error = PE_FILTER_BADDEST;

}

}

else

MCerrorlock--;

}

// Now look for the filter mode

if (t_error == PE_UNDEFINED)

{

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

discardmatches = False;

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

discardmatches = True;

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

discardmatches = False;

else if (sp.skip_token(SP_FACTOR, TT_UNOP, O_NOT) == PS_NORMAL

&& sp.skip_token(SP_SUGAR, TT_UNDEFINED, SG_MATCHING) == PS_NORMAL)

discardmatches = True;

else

t_error = PE_FILTER_NOWITH;

}

// Now look for the optional pattern match mode

if (t_error == PE_UNDEFINED)

{

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

matchmode = MA_REGEX;

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

matchmode = MA_WILDCARD;

// Skip the optional pattern keyword

sp.skip_token(SP_SUGAR, TT_UNDEFINED, SG_PATTERN);

}

// Now parse the pattern expression

if (t_error == PE_UNDEFINED && sp.parseexp(False, True, &pattern) != PS_NORMAL)

t_error = PE_FILTER_BADEXP;

// Finally check for the (optional) 'into' clause

if (t_error == PE_UNDEFINED)

{

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

{

target = new (nothrow) MCChunk(True);

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

t_error = PE_FILTER_BADDEST;

}

}

// If we encountered an error, add it to the parse error stack and fail.

if (t_error != PE_UNDEFINED)

{

MCperror->add(t_error, sp);

return PS_ERROR;

}

// Success!

return PS_NORMAL;

}

// JS-2013-07-01: [[ EnhancedFilter ]] Rewritten to support new syntax.

void MCFilter::exec_ctxt(MCExecContext &ctxt)

{

MCValueRef t_source;

MCAutoStringRef t_pattern;

if (container != NULL)

{

if (!ctxt . EvalExprAsValueRef(container, EE_FILTER_CANTGET, t_source))