/* 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/>. */

#ifndef COMMANDS_H

#define COMMANDS_H

#include "statemnt.h"

#include "objdefs.h"

#include "regex.h"

#include "util.h"

#include "uidc.h"

// general commands in cmds.cc

// MW-2013-11-14: [[ AssertCmd ]] 'assert' command definition.

class MCAssertCmd: public MCStatement

{

Assert_type m_type;

MCExpression *m_expr;

public:

MCAssertCmd(void)

{

m_type = TYPE_NONE;

m_expr = nil;

}

virtual ~MCAssertCmd(void);

virtual Parse_stat parse(MCScriptPoint& sp);

virtual void exec_ctxt(MCExecContext& ctxt);

virtual void compile(MCSyntaxFactoryRef);

};

class MCChoose : public MCStatement

{

Tool littool;

MCExpression *etool;

public:

MCChoose()

{

littool = T_UNDEFINED;

etool = NULL;

}

virtual ~MCChoose();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext& ctxt);

virtual void compile(MCSyntaxFactoryRef);

};

class MCConvert : public MCStatement

{

MCChunk *container;

MCExpression *source;

Convert_form fform;

Convert_form fsform;

Convert_form pform;

Convert_form sform;

public:

MCConvert()

{

container = NULL;

source = NULL;

fform = CF_UNDEFINED;

fsform = CF_UNDEFINED;

pform = CF_UNDEFINED;

sform = CF_UNDEFINED;

}

virtual ~MCConvert();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &);

virtual void compile(MCSyntaxFactoryRef);

Parse_stat parsedtformat(MCScriptPoint &sp, Convert_form &firstform,

Convert_form &secondform);

};

class MCDo : public MCStatement

{

MCExpression *source;

MCExpression *alternatelang;

protected:

bool browser : 1;

Boolean debug : 1;

bool caller : 1;

public:

MCDo()

{

source = NULL;

alternatelang = NULL;

browser = false;

debug = False;

caller = false;

}

virtual ~MCDo();

virtual Parse_stat parse(MCScriptPoint &);

void deletestatements(MCStatement *statements);

virtual void exec_ctxt(MCExecContext& ctxt);

virtual void compile(MCSyntaxFactoryRef);

};

class MCDebugDo : public MCDo

{

public:

MCDebugDo()

{

debug = True;

}

};

class MCRegularDo : public MCDo

{

public:

MCRegularDo()

{

debug = False;

}

};

class MCDoMenu : public MCStatement

{

MCExpression *source;

public:

MCDoMenu()

{

source = NULL;

}

const char *lookup(MCStringRef s);

virtual ~MCDoMenu();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext& ctxt);

virtual void compile(MCSyntaxFactoryRef);

};

class MCEdit : public MCStatement

{

MCChunk *target;

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

MCExpression *m_at;

public:

MCEdit()

{

target = NULL;

m_at = NULL;

}

virtual ~MCEdit();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &);

virtual void compile(MCSyntaxFactoryRef);

};

class MCFind : public MCStatement

{

Find_mode mode;

MCExpression *tofind;

MCChunk *field;

public:

MCFind()

{

mode = FM_NORMAL;

tofind = NULL;

field = NULL;

}

virtual ~MCFind();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &);

virtual void compile(MCSyntaxFactoryRef);

};

class MCGet : public MCStatement

{

MCExpression *value;

public:

MCGet()

{

value = NULL;

}

virtual ~MCGet();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext&);

virtual void compile(MCSyntaxFactoryRef);

};

class MCMarking : public MCStatement

{

MCExpression *where;

MCExpression *tofind;

MCChunk *field;

MCChunk *card;

Find_mode mode;

protected:

Boolean mark;

public:

MCMarking()

{

where = tofind = NULL;

mode = FM_NORMAL;

field = card = NULL;

}

virtual ~MCMarking();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &ctxt);

};

class MCMarkCommand : public MCMarking

{

public:

MCMarkCommand()

{

mark = True;

}

};

class MCUnmark : public MCMarking

{

public:

MCUnmark()

{

mark = False;

}

};

class MCPost : public MCStatement

{

MCExpression *source;

MCExpression *dest;

public:

MCPost()

{

source = dest = NULL;

}

virtual ~MCPost();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &);

virtual void compile(MCSyntaxFactoryRef);

};

class MCPut : public MCStatement

{

MCExpression *source;

MCChunk *dest;

Preposition_type prep : 8;

// MW-2012-02-23: [[ UnicodePut ]] Indicates if the 'unicode' adjective

// was present.

bool is_unicode : 1;

bool overlap : 1;

//cookie

MCExpression *name;

MCExpression *path;

MCExpression *domain;

MCExpression *expires;

bool is_secure;

bool is_httponly;

public:

MCPut()

{

source = NULL;

// MW-2011-06-22: [[ SERVER ]] Make a distinction between 'put' and 'put .. into msg'

prep = PT_UNDEFINED;

dest = NULL;

overlap = false;

// cookie

name = NULL;

path = NULL;

domain = NULL;

expires = NULL;

is_secure = false;

is_httponly = false;

// MW-2012-02-23: [[ UnicodePut ]] Assume non-unicode to begin with.

is_unicode = false;

}

virtual ~MCPut();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &);

virtual void compile(MCSyntaxFactoryRef);

#ifdef LEGACY_EXEC

Exec_stat exec_cookie(MCExecPoint &);

#endif

};

class MCQuit : public MCStatement

{

MCExpression *retcode;

public:

MCQuit()

{

retcode = NULL;

}

virtual ~MCQuit();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext&);

virtual void compile(MCSyntaxFactoryRef);

};

class MCReset : public MCStatement

{

Reset_type which;

public:

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &);

virtual void compile(MCSyntaxFactoryRef);

};

class MCReturn : public MCStatement

{

MCExpression *source;

MCExpression *url;

MCVarref *var;

public:

MCReturn()

{

source = url = NULL;

var = NULL;

}

virtual ~MCReturn();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &ctxt);

virtual uint4 linecount();

virtual void compile(MCSyntaxFactoryRef);

};

// relayer <control> ( before | after ) layer <expr>

// relayer <control> ( before | after ) <control>

// relayer <control> ( before | after ) owner

// relayer <control> to ( front | back ) of layer <expr>

// relayer <control> to ( front | back ) of <control>

// relayer <control> to ( front | back ) of owner

enum MCRelayerForm

{

kMCRelayerFormNone,

kMCRelayerFormRelativeToLayer,

kMCRelayerFormRelativeToControl,

kMCRelayerFormRelativeToOwner,

};

class MCRelayer : public MCStatement

{

MCRelayerForm form : 3;

Relayer_relation relation : 4;

MCChunk *control;

union

{

MCExpression *layer;

MCChunk *target;

};

public:

MCRelayer(void);

virtual ~MCRelayer(void);

virtual Parse_stat parse(MCScriptPoint& sp);

virtual void exec_ctxt(MCExecContext &ctxt);

};

class MCScriptError : public MCStatement

{

public:

virtual Parse_stat parse(MCScriptPoint &);

};

class MCSet : public MCStatement

{

MCProperty *target;

MCExpression *value;

public:

MCSet()

{

target = NULL;

value = NULL;

}

virtual ~MCSet();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &);

};

class MCSort : public MCStatement

{

MCChunk *of;

Chunk_term chunktype;

Sort_type direction;

Sort_type format;

MCExpression *by;

public:

MCSort()

{

of = NULL;

chunktype = CT_FIELD;

direction = ST_ASCENDING;

format = ST_TEXT;

by = NULL;

}

virtual ~MCSort();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &);

//static void additem(MCExecContext &ctxt, MCSortnode *items, uint4 &nitems, Sort_type form, MCValueRef p_value, MCExpression *by);

virtual void compile(MCSyntaxFactoryRef);

};

class MCWait : public MCStatement

{

Repeat_form condition;

MCExpression *duration;

Functions units;

Boolean messages;

public:

MCWait()

{

duration = NULL;

messages = False;

}

virtual ~MCWait();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &);

virtual void compile(MCSyntaxFactoryRef);

};

// creation related commands in cmdsc.cc

class MCClone : public MCStatement

{

MCChunk *source;

MCExpression *newname;

Boolean visible;

public:

MCClone()

{

source = NULL;

newname = NULL;

visible = True;

}

virtual ~MCClone();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &);

virtual void compile(MCSyntaxFactoryRef);

};

class MCClipboardCmd: public MCStatement

{

MCChunk *targets;

MCChunk *dest;

public:

MCClipboardCmd(void)

{

targets = NULL;

dest = NULL;

}

virtual ~MCClipboardCmd(void);

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &);

virtual void compile(MCSyntaxFactoryRef);

protected:

virtual bool iscut(void) const = 0;

private:

#ifdef LEGACY_EXEC

Exec_errors processtocontainer(MCExecPoint& ep, MCObjectRef *p_objects, uint4 p_object_count, MCObject *p_dst);

Exec_errors processtoclipboard(MCExecPoint& ep, MCObjectRef *p_objects, uint4 p_object_count);

#endif

};

class MCCopyCmd: public MCClipboardCmd

{

protected:

virtual bool iscut(void) const;

};

class MCCutCmd: public MCClipboardCmd

{

protected:

virtual bool iscut(void) const;

};

// MW-2004-11-26: Initialise otype (VG)

class MCCreate : public MCStatement

{

Chunk_term otype;

MCExpression *newname;

MCExpression *file;

MCExpression *kind;

MCChunk *container;

Boolean directory: 1;

Boolean visible: 1;

Boolean alias: 1;

// MW-2014-09-30: [[ ScriptOnlyStack ]] For 'create script only stack ...' form.

Boolean script_only_stack : 1;

public:

MCCreate()

{

otype = CT_UNDEFINED;

newname = NULL;

file = NULL;

kind = NULL;

container = NULL;

directory = False;

alias = False;

visible = True;

// MW-2014-09-30: [[ ScriptOnlyStack ]] Initial value.

script_only_stack = False;

}

virtual ~MCCreate();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &);

MCControl *getobject(MCObject *&parent);

virtual void compile(MCSyntaxFactoryRef);

};

class MCCustomProp : public MCStatement

{

MCExpression *prop;

MCChunk *target;

protected:

Boolean define;

public:

MCCustomProp()

{

prop = NULL;

target = NULL;

}

virtual ~MCCustomProp();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &);

};

class MCDefine : public MCCustomProp

{

public:

MCDefine()

{

define = True;

}

};

class MCUndefine : public MCCustomProp

{

public:

MCUndefine()

{

define = False;

}

};

class MCDelete : public MCStatement

{

MCExpression *file;

MCChunk *targets;

Boolean directory;

Boolean url;

MCVarref *var;

bool session;

public:

MCDelete()

{

file = NULL;

targets = NULL;

directory = url = False;

var = NULL;

session = false;

}

virtual ~MCDelete();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &);

virtual void compile(MCSyntaxFactoryRef);

};

class MCChangeProp : public MCStatement

{

protected:

MCChunk *targets;

Properties prop;

Boolean value;

public:

MCChangeProp()

{

targets = NULL;

}

virtual ~MCChangeProp();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &ctxt);

virtual void compile(MCSyntaxFactoryRef);

};

class MCDisable : public MCChangeProp

{

public:

MCDisable()

{

prop = P_DISABLED;

value = True;

}

};

class MCEnable : public MCChangeProp

{

public:

MCEnable()

{

prop = P_DISABLED;

value = False;

}

};

class MCHilite : public MCChangeProp

{

public:

MCHilite()

{

prop = P_HILITE;

value = True;

}

};

class MCUnhilite : public MCChangeProp

{

public:

MCUnhilite()

{

prop = P_HILITE;

value = False;

}

};

class MCCrop : public MCStatement

{

MCExpression *newrect;

MCChunk *image;

public:

MCCrop()

{

image = NULL;

newrect = NULL;

}

virtual ~MCCrop();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &);

virtual void compile(MCSyntaxFactoryRef);

};

class MCFlip : public MCStatement

{

Flip_dir direction;

MCChunk *image;

public:

MCFlip()

{

direction = FL_UNDEFINED;

image = NULL;

}

virtual ~MCFlip();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &);

virtual void compile(MCSyntaxFactoryRef);

};

class MCGrab : public MCStatement

{

MCChunk *control;

public:

MCGrab()

{

control = NULL;

}

virtual ~MCGrab();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &);

virtual void compile(MCSyntaxFactoryRef);

};

class MCLaunch : public MCStatement

{

MCExpression *doc;

MCExpression *app;

bool as_url;

public:

MCLaunch()

{

doc = app = NULL;

as_url = false;

}

virtual ~MCLaunch();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &);

virtual void compile(MCSyntaxFactoryRef);

};

class MCLoad : public MCStatement

{

MCExpression *url;

MCExpression *message;

bool is_extension : 1;

bool has_resource_path : 1;

bool from_data : 1;

public:

MCLoad()

{

url = message = NULL;

is_extension = false;

has_resource_path = false;

from_data = false;

}

virtual ~MCLoad();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &);

virtual void compile(MCSyntaxFactoryRef);

};

class MCUnload : public MCStatement

{

MCExpression *url;

bool is_extension : 1;

public:

MCUnload()

{

url = NULL;

is_extension = false;

}

virtual ~MCUnload();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &);

virtual void compile(MCSyntaxFactoryRef);

};

class MCMakeGroup : public MCStatement

{

MCChunk *targets;

public:

MCMakeGroup()

{

targets = NULL;

}

virtual ~MCMakeGroup();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &);

virtual void compile(MCSyntaxFactoryRef);

};

class MCPasteCmd : public MCStatement

{

public:

MCPasteCmd()

{

}

virtual ~MCPasteCmd();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &);

virtual void compile(MCSyntaxFactoryRef);

};

class MCPlace : public MCStatement

{

MCChunk *group;

MCChunk *card;

public:

MCPlace()

{

group = NULL;

card = NULL;

}

virtual ~MCPlace();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &);

virtual void compile(MCSyntaxFactoryRef);

};

class MCRecord : public MCStatement

{

MCExpression *file;

Boolean pause;

public:

MCRecord()

{

file = NULL;

pause = False;

}

virtual ~MCRecord();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &);

virtual void compile(MCSyntaxFactoryRef);

};

class MCRedo : public MCStatement

{

public:

virtual void exec_ctxt(MCExecContext &);

};

class MCRemove : public MCStatement

{

MCChunk *target;

MCChunk *card;

Boolean script;

Boolean all;

Insert_point where;

public:

MCRemove()

{

target = NULL;

card = NULL;

script = all = False;

}

virtual ~MCRemove();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &);

virtual void compile(MCSyntaxFactoryRef);

};

class MCRename : public MCStatement

{

MCExpression *source;

MCExpression *dest;

public:

MCRename()

{

source = dest = NULL;

}

virtual ~MCRename();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &);

virtual void compile(MCSyntaxFactoryRef);

};

class MCReplace : public MCStatement

{

MCExpression *pattern;

MCExpression *replacement;

MCChunk *container;

public:

MCReplace()

{

pattern = replacement = NULL;

container = NULL;

}

virtual ~MCReplace();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &);

virtual void compile(MCSyntaxFactoryRef);

};

class MCRevert : public MCStatement

{

public:

virtual void exec_ctxt(MCExecContext &);

virtual void compile(MCSyntaxFactoryRef);

};

class MCRotate : public MCStatement

{

MCExpression *angle;

MCChunk *image;

public:

MCRotate()

{

image = NULL;

angle = NULL;

}

virtual ~MCRotate();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &);

virtual void compile(MCSyntaxFactoryRef);

};

class MCSelect : public MCStatement

{

Preposition_type where;

Boolean text;

MCChunk *targets;

public:

MCSelect()

{

where = PT_AT;

text = False;

targets = NULL;

}

virtual ~MCSelect();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &);

virtual void compile(MCSyntaxFactoryRef);

};

class MCUngroup : public MCStatement

{

MCChunk *group;

public:

MCUngroup()

{

group = NULL;

}

virtual ~MCUngroup();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &);

virtual void compile(MCSyntaxFactoryRef);

};

class MCUndoCmd : public MCStatement

{

public:

virtual void exec_ctxt(MCExecContext &);

virtual void compile(MCSyntaxFactoryRef);

};

// event related comands in cmdse.cc

class MCAccept : public MCStatement

{

MCExpression *port;

MCExpression *message;

Boolean datagram;

Boolean secure;

Boolean secureverify;

MCExpression *certificate;

public:

MCAccept()

{

port = message = NULL;

datagram = False;

secure = False;

certificate = NULL;

secureverify = False;

}

virtual ~MCAccept();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &);

virtual void compile(MCSyntaxFactoryRef);

};

class MCBeep : public MCStatement

{

MCExpression *times;

public:

MCBeep()

{

times = NULL;

}

virtual ~MCBeep();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext& ctxt);

virtual void compile(MCSyntaxFactoryRef);

};

class MCBreakPoint : public MCStatement

{

public:

virtual void exec_ctxt(MCExecContext &);

virtual void compile(MCSyntaxFactoryRef);

};

class MCCancel : public MCStatement

{

MCExpression *m_id;

public:

MCCancel()

{

m_id = NULL;

}

virtual ~MCCancel();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &);

virtual void compile(MCSyntaxFactoryRef);

};

class MCClickCmd : public MCStatement

{

MCExpression *button;

MCExpression *location;

uint2 mstate;

uint2 which;

public:

MCClickCmd()

{

button = location = NULL;

which = 1;

mstate = 0;

}

virtual ~MCClickCmd();

virtual Parse_stat parse(MCScriptPoint &);

virtual void exec_ctxt(MCExecContext &);

virtual void compile(MCSyntaxFactoryRef);

};

class MCDrag : public MCStatement