summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/map/script.c2222
-rw-r--r--src/map/script.h426
2 files changed, 1407 insertions, 1241 deletions
diff --git a/src/map/script.c b/src/map/script.c
index 59af8d2b7..875ecd841 100644
--- a/src/map/script.c
+++ b/src/map/script.c
@@ -2,12 +2,6 @@
// See the LICENSE file
// Portions Copyright (c) Athena Dev Teams
-//#define DEBUG_DISP
-//#define DEBUG_DISASM
-//#define DEBUG_RUN
-//#define DEBUG_HASH
-//#define DEBUG_DUMP_STACK
-
#include "../common/cbasetypes.h"
#include "../common/malloc.h"
#include "../common/md5calc.h"
@@ -60,165 +54,18 @@
#include <sys/time.h>
#endif
#include <time.h>
-#include <setjmp.h>
-#include <errno.h>
-
-
-#define FETCH(n, t) \
- if( script_hasdata(st,n) ) \
- (t)=script_getnum(st,n);
-
-/// Maximum amount of elements in script arrays
-#define SCRIPT_MAX_ARRAYSIZE 128
-#define SCRIPT_BLOCK_SIZE 512
-enum { LABEL_NEXTLINE=1,LABEL_START };
-
-/// temporary buffer for passing around compiled bytecode
-/// @see add_scriptb, set_label, parse_script
-static unsigned char* script_buf = NULL;
-static int script_pos = 0, script_size = 0;
-
-static inline int GETVALUE(const unsigned char* buf, int i)
-{
+static inline int GETVALUE(const unsigned char* buf, int i) {
return (int)MakeDWord(MakeWord(buf[i], buf[i+1]), MakeWord(buf[i+2], 0));
}
-static inline void SETVALUE(unsigned char* buf, int i, int n)
-{
+static inline void SETVALUE(unsigned char* buf, int i, int n) {
buf[i] = GetByte(n, 0);
buf[i+1] = GetByte(n, 1);
buf[i+2] = GetByte(n, 2);
}
-// Using a prime number for SCRIPT_HASH_SIZE should give better distributions
-#define SCRIPT_HASH_SIZE 1021
-int str_hash[SCRIPT_HASH_SIZE];
-// Specifies which string hashing method to use
-//#define SCRIPT_HASH_DJB2
-//#define SCRIPT_HASH_SDBM
-#define SCRIPT_HASH_ELF
-
-static int parse_options=0;
-
-// important buildin function references for usage in scripts
-static int buildin_set_ref = 0;
-static int buildin_callsub_ref = 0;
-static int buildin_callfunc_ref = 0;
-static int buildin_getelementofarray_ref = 0;
-
-static jmp_buf error_jump;
-static char* error_msg;
-static const char* error_pos;
-static int error_report; // if the error should produce output
-// Used by disp_warning_message
-static const char* parser_current_src;
-static const char* parser_current_file;
-static int parser_current_line;
-
-// for advanced scripting support ( nested if, switch, while, for, do-while, function, etc )
-// [Eoe / jA 1080, 1081, 1094, 1164]
-enum curly_type {
- TYPE_NULL = 0,
- TYPE_IF,
- TYPE_SWITCH,
- TYPE_WHILE,
- TYPE_FOR,
- TYPE_DO,
- TYPE_USERFUNC,
- TYPE_ARGLIST // function argument list
-};
-
-enum e_arglist
-{
- ARGLIST_UNDEFINED = 0,
- ARGLIST_NO_PAREN = 1,
- ARGLIST_PAREN = 2,
-};
-
-static struct {
- struct {
- enum curly_type type;
- int index;
- int count;
- int flag;
- struct linkdb_node *case_label;
- } curly[256]; // Information right parenthesis
- int curly_count; // The number of right brackets
- int index; // Number of the syntax used in the script
-} syntax;
-
-const char* parse_curly_close(const char* p);
-const char* parse_syntax_close(const char* p);
-const char* parse_syntax_close_sub(const char* p,int* flag);
-const char* parse_syntax(const char* p);
-static int parse_syntax_for_flag = 0;
-
-extern int status_current_equip_item_index; //for New CARDS Scripts. It contains Inventory Index of the EQUIP_SCRIPT caller item. [Lupus]
-
struct script_interface script_s;
-c_op get_com(unsigned char *scriptbuf,int *pos);
-int get_num(unsigned char *scriptbuf,int *pos);
-
-/*==========================================
- * (Only those needed) local declaration prototype
- *------------------------------------------*/
-
-enum {
- MF_NOMEMO, //0
- MF_NOTELEPORT,
- MF_NOSAVE,
- MF_NOBRANCH,
- MF_NOPENALTY,
- MF_NOZENYPENALTY,
- MF_PVP,
- MF_PVP_NOPARTY,
- MF_PVP_NOGUILD,
- MF_GVG,
- MF_GVG_NOPARTY, //10
- MF_NOTRADE,
- MF_NOSKILL,
- MF_NOWARP,
- MF_PARTYLOCK,
- MF_NOICEWALL,
- MF_SNOW,
- MF_FOG,
- MF_SAKURA,
- MF_LEAVES,
- /* 21 - 22 free */
- MF_CLOUDS = 23,
- MF_CLOUDS2,
- MF_FIREWORKS,
- MF_GVG_CASTLE,
- MF_GVG_DUNGEON,
- MF_NIGHTENABLED,
- MF_NOBASEEXP,
- MF_NOJOBEXP, //30
- MF_NOMOBLOOT,
- MF_NOMVPLOOT,
- MF_NORETURN,
- MF_NOWARPTO,
- MF_NIGHTMAREDROP,
- MF_ZONE,
- MF_NOCOMMAND,
- MF_NODROP,
- MF_JEXP,
- MF_BEXP, //40
- MF_NOVENDING,
- MF_LOADEVENT,
- MF_NOCHAT,
- MF_NOEXPPENALTY,
- MF_GUILDLOCK,
- MF_TOWN,
- MF_AUTOTRADE,
- MF_ALLOWKS,
- MF_MONSTER_NOTELEPORT,
- MF_PVP_NOCALCRANK, //50
- MF_BATTLEGROUND,
- MF_RESET,
- MF_NOTOMB
-};
-
const char* script_op2name(int op)
{
#define RETURN_OP_NAME(type) case type: return #type
@@ -269,7 +116,7 @@ const char* script_op2name(int op)
#undef RETURN_OP_NAME
}
-#ifdef DEBUG_DUMP_STACK
+#ifdef SCRIPT_DEBUG_DUMP_STACK
static void script_dump_stack(struct script_state* st)
{
int i;
@@ -312,7 +159,7 @@ static void script_dump_stack(struct script_state* st)
#endif
/// Reports on the console the src of a script error.
-static void script_reportsrc(struct script_state *st) {
+void script_reportsrc(struct script_state *st) {
struct block_list* bl;
if( st->oid == 0 )
@@ -339,7 +186,7 @@ static void script_reportsrc(struct script_state *st) {
}
/// Reports on the console information about the script data.
-static void script_reportdata(struct script_data* data)
+void script_reportdata(struct script_data* data)
{
if( data == NULL )
return;
@@ -370,22 +217,22 @@ static void script_reportdata(struct script_data* data)
} else if( reference_toparam(data) ) {// param
ShowDebug("Data: param name='%s' type=%d\n", reference_getname(data), reference_getparamtype(data));
} else {// ???
- ShowDebug("Data: reference name='%s' type=%s\n", reference_getname(data), script_op2name(data->type));
- ShowDebug("Please report this!!! - script->str_data.type=%s\n", script_op2name(script->str_data[reference_getid(data)].type));
+ ShowDebug("Data: reference name='%s' type=%s\n", reference_getname(data), script->op2name(data->type));
+ ShowDebug("Please report this!!! - script->str_data.type=%s\n", script->op2name(script->str_data[reference_getid(data)].type));
}
break;
case C_POS:// label
ShowDebug("Data: label pos=%d\n", data->u.num);
break;
default:
- ShowDebug("Data: %s\n", script_op2name(data->type));
+ ShowDebug("Data: %s\n", script->op2name(data->type));
break;
}
}
/// Reports on the console information about the current built-in function.
-static void script_reportfunc(struct script_state* st)
+void script_reportfunc(struct script_state* st)
{
int i, params, id;
struct script_data* data;
@@ -411,7 +258,7 @@ static void script_reportfunc(struct script_state* st)
for( i = 2; i <= script_lastdata(st); i++ )
{
- script_reportdata(script_getdata(st,i));
+ script->reportdata(script_getdata(st,i));
}
}
else
@@ -424,33 +271,33 @@ static void script_reportfunc(struct script_state* st)
/*==========================================
* Output error message
*------------------------------------------*/
-static void disp_error_message2(const char *mes,const char *pos,int report)
+void disp_error_message2(const char *mes,const char *pos,int report)
{
- error_msg = aStrdup(mes);
- error_pos = pos;
- error_report = report;
- longjmp( error_jump, 1 );
+ script->error_msg = aStrdup(mes);
+ script->error_pos = pos;
+ script->error_report = report;
+ longjmp( script->error_jump, 1 );
}
-#define disp_error_message(mes,pos) disp_error_message2(mes,pos,1)
+#define disp_error_message(mes,pos) script->disp_error_message2(mes,pos,1)
-static void disp_warning_message(const char *mes, const char *pos) {
- script->warning(parser_current_src,parser_current_file,parser_current_line,mes,pos);
+void disp_warning_message(const char *mes, const char *pos) {
+ script->warning(script->parser_current_src,script->parser_current_file,script->parser_current_line,mes,pos);
}
/// Checks event parameter validity
-static void check_event(struct script_state *st, const char *evt)
+void check_event(struct script_state *st, const char *evt)
{
if( evt && evt[0] && !stristr(evt, "::On") )
{
ShowWarning("NPC event parameter deprecated! Please use 'NPCNAME::OnEVENT' instead of '%s'.\n", evt);
- script_reportsrc(st);
+ script->reportsrc(st);
}
}
/*==========================================
* Hashes the input string
*------------------------------------------*/
-static unsigned int calc_hash(const char* p)
+unsigned int calc_hash(const char* p)
{
unsigned int h;
@@ -500,7 +347,7 @@ int script_search_str(const char* p)
{
int i;
- for( i = str_hash[calc_hash(p)]; i != 0; i = script->str_data[i].next )
+ for( i = script->str_hash[script->calc_hash(p)]; i != 0; i = script->str_data[i].next )
if( strcasecmp(script->get_str(i),p) == 0 )
return i;
@@ -514,12 +361,12 @@ int script_add_str(const char* p)
int i, h;
int len;
- h = calc_hash(p);
+ h = script->calc_hash(p);
- if( str_hash[h] == 0 ) {// empty bucket, add new node here
- str_hash[h] = script->str_num;
+ if( script->str_hash[h] == 0 ) {// empty bucket, add new node here
+ script->str_hash[h] = script->str_num;
} else {// scan for end of list, or occurence of identical string
- for( i = str_hash[h]; ; i = script->str_data[i].next ) {
+ for( i = script->str_hash[h]; ; i = script->str_data[i].next ) {
if( strcasecmp(script->get_str(i),p) == 0 )
return i; // string already in list
if( script->str_data[i].next == 0 )
@@ -561,43 +408,43 @@ int script_add_str(const char* p)
/// Appends 1 byte to the script buffer.
-static void add_scriptb(int a)
+void add_scriptb(int a)
{
- if( script_pos+1 >= script_size )
+ if( script->pos+1 >= script->size )
{
- script_size += SCRIPT_BLOCK_SIZE;
- RECREATE(script_buf,unsigned char,script_size);
+ script->size += SCRIPT_BLOCK_SIZE;
+ RECREATE(script->buf,unsigned char,script->size);
}
- script_buf[script_pos++] = (uint8)(a);
+ script->buf[script->pos++] = (uint8)(a);
}
/// Appends a c_op value to the script buffer.
/// The value is variable-length encoded into 8-bit blocks.
/// The encoding scheme is ( 01?????? )* 00??????, LSB first.
/// All blocks but the last hold 7 bits of data, topmost bit is always 1 (carries).
-static void add_scriptc(int a)
+void add_scriptc(int a)
{
while( a >= 0x40 )
{
- add_scriptb((a&0x3f)|0x40);
+ script->addb((a&0x3f)|0x40);
a = (a - 0x40) >> 6;
}
- add_scriptb(a);
+ script->addb(a);
}
/// Appends an integer value to the script buffer.
/// The value is variable-length encoded into 8-bit blocks.
/// The encoding scheme is ( 11?????? )* 10??????, LSB first.
/// All blocks but the last hold 7 bits of data, topmost bit is always 1 (carries).
-static void add_scripti(int a)
+void add_scripti(int a)
{
while( a >= 0x40 )
{
- add_scriptb((a&0x3f)|0xc0);
+ script->addb((a&0x3f)|0xc0);
a = (a - 0x40) >> 6;
}
- add_scriptb(a|0x80);
+ script->addb(a|0x80);
}
/// Appends a script->str_data object (label/function/variable/integer) to the script buffer.
@@ -605,37 +452,37 @@ static void add_scripti(int a)
///
/// @param l The id of the script->str_data entry
// Maximum up to 16M
-static void add_scriptl(int l)
+void add_scriptl(int l)
{
int backpatch = script->str_data[l].backpatch;
switch(script->str_data[l].type){
case C_POS:
case C_USERFUNC_POS:
- add_scriptc(C_POS);
- add_scriptb(script->str_data[l].label);
- add_scriptb(script->str_data[l].label>>8);
- add_scriptb(script->str_data[l].label>>16);
+ script->addc(C_POS);
+ script->addb(script->str_data[l].label);
+ script->addb(script->str_data[l].label>>8);
+ script->addb(script->str_data[l].label>>16);
break;
case C_NOP:
case C_USERFUNC:
// Embedded data backpatch there is a possibility of label
- add_scriptc(C_NAME);
- script->str_data[l].backpatch = script_pos;
- add_scriptb(backpatch);
- add_scriptb(backpatch>>8);
- add_scriptb(backpatch>>16);
+ script->addc(C_NAME);
+ script->str_data[l].backpatch = script->pos;
+ script->addb(backpatch);
+ script->addb(backpatch>>8);
+ script->addb(backpatch>>16);
break;
case C_INT:
- add_scripti(abs(script->str_data[l].val));
+ script->addi(abs(script->str_data[l].val));
if( script->str_data[l].val < 0 ) //Notice that this is negative, from jA (Rayce)
- add_scriptc(C_NEG);
+ script->addc(C_NEG);
break;
default: // assume C_NAME
- add_scriptc(C_NAME);
- add_scriptb(l);
- add_scriptb(l>>8);
- add_scriptb(l>>16);
+ script->addc(C_NAME);
+ script->addb(l);
+ script->addb(l>>8);
+ script->addb(l>>16);
break;
}
}
@@ -659,9 +506,9 @@ void set_label(int l,int pos, const char* script_pos)
script->str_data[l].type=(script->str_data[l].type == C_USERFUNC ? C_USERFUNC_POS : C_POS);
script->str_data[l].label=pos;
for(i=script->str_data[l].backpatch;i>=0 && i!=0x00ffffff;){
- next=GETVALUE(script_buf,i);
- script_buf[i-1]=(script->str_data[l].type == C_USERFUNC ? C_USERFUNC_POS : C_POS);
- SETVALUE(script_buf,i,pos);
+ next=GETVALUE(script->buf,i);
+ script->buf[i-1]=(script->str_data[l].type == C_USERFUNC ? C_USERFUNC_POS : C_POS);
+ SETVALUE(script->buf,i,pos);
i=next;
}
}
@@ -686,7 +533,7 @@ const char* script_skip_space(const char* p)
for(;;)
{
if( *p == '\0' ) {
- disp_warning_message("script:script->skip_space: end of file while parsing block comment. expected "CL_BOLD"*/"CL_NORM, p);
+ script->disp_warning_message("script:script->skip_space: end of file while parsing block comment. expected "CL_BOLD"*/"CL_NORM, p);
return p;
}
if( *p == '*' && p[1] == '/' )
@@ -706,7 +553,7 @@ const char* script_skip_space(const char* p)
/// Skips a word.
/// A word consists of undercores and/or alphanumeric characters,
/// and valid variable prefixes/postfixes.
-static const char* skip_word(const char* p) {
+const char* skip_word(const char* p) {
// prefix
switch( *p ) {
case '@':// temporary char variable
@@ -733,12 +580,12 @@ static const char* skip_word(const char* p) {
/// Adds a word to script->str_data.
/// @see skip_word
/// @see script->add_str
-static int add_word(const char* p) {
+int add_word(const char* p) {
int len;
int i;
// Check for a word
- len = skip_word(p) - p;
+ len = script->skip_word(p) - p;
if( len == 0 )
disp_error_message("script:add_word: invalid word. A word consists of undercores and/or alphanumeric characters, and valid variable prefixes/postfixes.", p);
@@ -765,20 +612,20 @@ const char* parse_callfunc(const char* p, int require_paren, int is_custom)
char *arg = NULL;
int func;
- func = add_word(p);
+ func = script->add_word(p);
if( script->str_data[func].type == C_FUNC ){
char argT = 0;
// buildin function
- add_scriptl(func);
- add_scriptc(C_ARG);
+ script->addl(func);
+ script->addc(C_ARG);
arg = script->buildin[script->str_data[func].val];
if( !arg ) arg = &argT;
} else if( script->str_data[func].type == C_USERFUNC || script->str_data[func].type == C_USERFUNC_POS ){
// script defined function
- add_scriptl(buildin_callsub_ref);
- add_scriptc(C_ARG);
- add_scriptl(func);
- arg = script->buildin[script->str_data[buildin_callsub_ref].val];
+ script->addl(script->buildin_callsub_ref);
+ script->addc(C_ARG);
+ script->addl(func);
+ arg = script->buildin[script->str_data[script->buildin_callsub_ref].val];
if( *arg == 0 )
disp_error_message("parse_callfunc: callsub has no arguments, please review its definition",p);
if( *arg != '*' )
@@ -791,45 +638,45 @@ const char* parse_callfunc(const char* p, int require_paren, int is_custom)
disp_error_message("parse_line: expect command, missing function name or calling undeclared function",p);
#ifdef SCRIPT_CALLFUNC_CHECK
} else {;
- add_scriptl(buildin_callfunc_ref);
- add_scriptc(C_ARG);
- add_scriptc(C_STR);
- while( *name ) add_scriptb(*name ++);
- add_scriptb(0);
- arg = script->buildin[script->str_data[buildin_callfunc_ref].val];
+ script->addl(script->buildin_callfunc_ref);
+ script->addc(C_ARG);
+ script->addc(C_STR);
+ while( *name ) script->addb(*name ++);
+ script->addb(0);
+ arg = script->buildin[script->str_data[script->buildin_callfunc_ref].val];
if( *arg != '*' ) ++ arg;
}
#endif
}
- p = skip_word(p);
+ p = script->skip_word(p);
p = script->skip_space(p);
- syntax.curly[syntax.curly_count].type = TYPE_ARGLIST;
- syntax.curly[syntax.curly_count].count = 0;
+ script->syntax.curly[script->syntax.curly_count].type = TYPE_ARGLIST;
+ script->syntax.curly[script->syntax.curly_count].count = 0;
if( *p == ';' )
{// <func name> ';'
- syntax.curly[syntax.curly_count].flag = ARGLIST_NO_PAREN;
+ script->syntax.curly[script->syntax.curly_count].flag = ARGLIST_NO_PAREN;
} else if( *p == '(' && *(p2=script->skip_space(p+1)) == ')' )
{// <func name> '(' ')'
- syntax.curly[syntax.curly_count].flag = ARGLIST_PAREN;
+ script->syntax.curly[script->syntax.curly_count].flag = ARGLIST_PAREN;
p = p2;
/*
} else if( 0 && require_paren && *p != '(' )
{// <func name>
- syntax.curly[syntax.curly_count].flag = ARGLIST_NO_PAREN;
+ script->syntax.curly[script->syntax.curly_count].flag = ARGLIST_NO_PAREN;
*/
} else {// <func name> <arg list>
if( require_paren ){
if( *p != '(' )
disp_error_message("need '('",p);
++p; // skip '('
- syntax.curly[syntax.curly_count].flag = ARGLIST_PAREN;
+ script->syntax.curly[script->syntax.curly_count].flag = ARGLIST_PAREN;
} else if( *p == '(' ){
- syntax.curly[syntax.curly_count].flag = ARGLIST_UNDEFINED;
+ script->syntax.curly[script->syntax.curly_count].flag = ARGLIST_UNDEFINED;
} else {
- syntax.curly[syntax.curly_count].flag = ARGLIST_NO_PAREN;
+ script->syntax.curly[script->syntax.curly_count].flag = ARGLIST_NO_PAREN;
}
- ++syntax.curly_count;
+ ++script->syntax.curly_count;
while( *arg ) {
p2=script->parse_subexpr(p,-1);
if( p == p2 )
@@ -842,30 +689,30 @@ const char* parse_callfunc(const char* p, int require_paren, int is_custom)
break; // no more arguments
++p; // skip comma
}
- --syntax.curly_count;
+ --script->syntax.curly_count;
}
if( arg && *arg && *arg != '?' && *arg != '*' )
disp_error_message2("parse_callfunc: not enough arguments, expected ','", p, script->config.warn_func_mismatch_paramnum);
- if( syntax.curly[syntax.curly_count].type != TYPE_ARGLIST )
+ if( script->syntax.curly[script->syntax.curly_count].type != TYPE_ARGLIST )
disp_error_message("parse_callfunc: DEBUG last curly is not an argument list",p);
- if( syntax.curly[syntax.curly_count].flag == ARGLIST_PAREN ){
+ if( script->syntax.curly[script->syntax.curly_count].flag == ARGLIST_PAREN ){
if( *p != ')' )
disp_error_message("parse_callfunc: expected ')' to close argument list",p);
++p;
}
- add_scriptc(C_FUNC);
+ script->addc(C_FUNC);
return p;
}
/// Processes end of logical script line.
/// @param first When true, only fix up scheduling data is initialized
/// @param p Script position for error reporting in set_label
-static void parse_nextline(bool first, const char* p)
+void parse_nextline(bool first, const char* p)
{
if( !first )
{
- add_scriptc(C_EOL); // mark end of line for stack cleanup
- set_label(LABEL_NEXTLINE, script_pos, p); // fix up '-' labels
+ script->addc(C_EOL); // mark end of line for stack cleanup
+ script->set_label(LABEL_NEXTLINE, script->pos, p); // fix up '-' labels
}
// initialize data for new '-' label fix up scheduling
@@ -884,7 +731,7 @@ const char* parse_variable(const char* p) {
const char *var = p;
// skip the variable where applicable
- p = skip_word(p);
+ p = script->skip_word(p);
p = script->skip_space(p);
if( p == NULL ) {// end of the line or invalid buffer
@@ -944,19 +791,19 @@ const char* parse_variable(const char* p) {
}
// push the set function onto the stack
- add_scriptl(buildin_set_ref);
- add_scriptc(C_ARG);
+ script->addl(script->buildin_set_ref);
+ script->addc(C_ARG);
// always append parenthesis to avoid errors
- syntax.curly[syntax.curly_count].type = TYPE_ARGLIST;
- syntax.curly[syntax.curly_count].count = 0;
- syntax.curly[syntax.curly_count].flag = ARGLIST_PAREN;
+ script->syntax.curly[script->syntax.curly_count].type = TYPE_ARGLIST;
+ script->syntax.curly[script->syntax.curly_count].count = 0;
+ script->syntax.curly[script->syntax.curly_count].flag = ARGLIST_PAREN;
// increment the total curly count for the position in the script
- ++ syntax.curly_count;
+ ++ script->syntax.curly_count;
// parse the variable currently being modified
- word = add_word(var);
+ word = script->add_word(var);
if( script->str_data[word].type == C_FUNC || script->str_data[word].type == C_USERFUNC || script->str_data[word].type == C_USERFUNC_POS )
{// cannot assign a variable which exists as a function or label
@@ -967,9 +814,9 @@ const char* parse_variable(const char* p) {
const char* p3 = NULL;
// push the getelementofarray method into the stack
- add_scriptl(buildin_getelementofarray_ref);
- add_scriptc(C_ARG);
- add_scriptl(word);
+ script->addl(script->buildin_getelementofarray_ref);
+ script->addc(C_ARG);
+ script->addl(word);
// process the sub-expression for this assignment
p3 = script->parse_subexpr(p2 + 1, 1);
@@ -980,32 +827,32 @@ const char* parse_variable(const char* p) {
}
// push the closing function stack operator onto the stack
- add_scriptc(C_FUNC);
+ script->addc(C_FUNC);
p3 ++;
} else {// simply push the variable or value onto the stack
- add_scriptl(word);
+ script->addl(word);
}
if( type != C_EQ )
- add_scriptc(C_REF);
+ script->addc(C_REF);
if( type == C_ADD_PP || type == C_SUB_PP ) {// incremental operator for the method
- add_scripti(1);
- add_scriptc(type == C_ADD_PP ? C_ADD : C_SUB);
+ script->addi(1);
+ script->addc(type == C_ADD_PP ? C_ADD : C_SUB);
} else {// process the value as an expression
p = script->parse_subexpr(p, -1);
if( type != C_EQ )
{// push the type of modifier onto the stack
- add_scriptc(type);
+ script->addc(type);
}
}
// decrement the curly count for the position within the script
- -- syntax.curly_count;
+ -- script->syntax.curly_count;
// close the script by appending the function operator
- add_scriptc(C_FUNC);
+ script->addc(C_FUNC);
// push the buffer from the method
return p;
@@ -1022,18 +869,18 @@ const char* parse_simpleexpr(const char *p)
if(*p==';' || *p==',')
disp_error_message("parse_simpleexpr: unexpected end of expression",p);
if(*p=='('){
- if( (i=syntax.curly_count-1) >= 0 && syntax.curly[i].type == TYPE_ARGLIST )
- ++syntax.curly[i].count;
+ if( (i=script->syntax.curly_count-1) >= 0 && script->syntax.curly[i].type == TYPE_ARGLIST )
+ ++script->syntax.curly[i].count;
p=script->parse_subexpr(p+1,-1);
p=script->skip_space(p);
- if( (i=syntax.curly_count-1) >= 0 && syntax.curly[i].type == TYPE_ARGLIST &&
- syntax.curly[i].flag == ARGLIST_UNDEFINED && --syntax.curly[i].count == 0
+ if( (i=script->syntax.curly_count-1) >= 0 && script->syntax.curly[i].type == TYPE_ARGLIST &&
+ script->syntax.curly[i].flag == ARGLIST_UNDEFINED && --script->syntax.curly[i].count == 0
){
if( *p == ',' ){
- syntax.curly[i].flag = ARGLIST_PAREN;
+ script->syntax.curly[i].flag = ARGLIST_PAREN;
return p;
} else
- syntax.curly[i].flag = ARGLIST_NO_PAREN;
+ script->syntax.curly[i].flag = ARGLIST_NO_PAREN;
}
if( *p != ')' )
disp_error_message("parse_simpleexpr: unmatched ')'",p);
@@ -1044,15 +891,15 @@ const char* parse_simpleexpr(const char *p)
i=strtoll(p,&np,0);
if( i < INT_MIN ) {
i = INT_MIN;
- disp_warning_message("parse_simpleexpr: underflow detected, capping value to INT_MIN",p);
+ script->disp_warning_message("parse_simpleexpr: underflow detected, capping value to INT_MIN",p);
} else if( i > INT_MAX ) {
i = INT_MAX;
- disp_warning_message("parse_simpleexpr: overflow detected, capping value to INT_MAX",p);
+ script->disp_warning_message("parse_simpleexpr: overflow detected, capping value to INT_MAX",p);
}
- add_scripti((int)i);
+ script->addi((int)i);
p=np;
} else if(*p=='"'){
- add_scriptc(C_STR);
+ script->addc(C_STR);
p++;
while( *p && *p != '"' ){
if( (unsigned char)p[-1] <= 0x7e && *p == '\\' ) {
@@ -1062,56 +909,56 @@ const char* parse_simpleexpr(const char *p)
if( n != 1 )
ShowDebug("parse_simpleexpr: unexpected length %d after unescape (\"%.*s\" -> %.*s)\n", (int)n, (int)len, p, (int)n, buf);
p += len;
- add_scriptb(*buf);
+ script->addb(*buf);
continue;
} else if( *p == '\n' )
disp_error_message("parse_simpleexpr: unexpected newline @ string",p);
- add_scriptb(*p++);
+ script->addb(*p++);
}
if(!*p)
disp_error_message("parse_simpleexpr: unexpected end of file @ string",p);
- add_scriptb(0);
+ script->addb(0);
p++; //'"'
} else {
int l;
const char* pv;
// label , register , function etc
- if(skip_word(p)==p)
+ if(script->skip_word(p)==p)
disp_error_message("parse_simpleexpr: unexpected character",p);
- l=add_word(p);
+ l=script->add_word(p);
if( script->str_data[l].type == C_FUNC || script->str_data[l].type == C_USERFUNC || script->str_data[l].type == C_USERFUNC_POS)
- return parse_callfunc(p,1,0);
+ return script->parse_callfunc(p,1,0);
#ifdef SCRIPT_CALLFUNC_CHECK
else {
const char* name = script->get_str(l);
if( strdb_get(script->userfunc_db,name) != NULL ) {
- return parse_callfunc(p,1,1);
+ return script->parse_callfunc(p,1,1);
}
}
#endif
- if( (pv = parse_variable(p)) )
+ if( (pv = script->parse_variable(p)) )
{// successfully processed a variable assignment
return pv;
}
- p=skip_word(p);
+ p=script->skip_word(p);
if( *p == '[' ){
// array(name[i] => getelementofarray(name,i) )
- add_scriptl(buildin_getelementofarray_ref);
- add_scriptc(C_ARG);
- add_scriptl(l);
+ script->addl(script->buildin_getelementofarray_ref);
+ script->addc(C_ARG);
+ script->addl(l);
p=script->parse_subexpr(p+1,-1);
p=script->skip_space(p);
if( *p != ']' )
disp_error_message("parse_simpleexpr: unmatched ']'",p);
++p;
- add_scriptc(C_FUNC);
+ script->addc(C_FUNC);
}else
- add_scriptl(l);
+ script->addl(l);
}
@@ -1131,7 +978,7 @@ const char* script_parse_subexpr(const char* p,int limit)
if( *p == '-' ){
tmpp = script->skip_space(p+1);
if( *tmpp == ';' || *tmpp == ',' ){
- add_scriptl(LABEL_NEXTLINE);
+ script->addl(LABEL_NEXTLINE);
p++;
return p;
}
@@ -1139,9 +986,9 @@ const char* script_parse_subexpr(const char* p,int limit)
if((op=C_NEG,*p=='-') || (op=C_LNOT,*p=='!') || (op=C_NOT,*p=='~')){
p=script->parse_subexpr(p+1,10);
- add_scriptc(op);
+ script->addc(op);
} else
- p=parse_simpleexpr(p);
+ p=script->parse_simpleexpr(p);
p=script->skip_space(p);
while((
(op=C_OP3,opl=0,len=1,*p=='?') ||
@@ -1173,7 +1020,7 @@ const char* script_parse_subexpr(const char* p,int limit)
} else {
p=script->parse_subexpr(p,opl);
}
- add_scriptc(op);
+ script->addc(op);
p=script->skip_space(p);
}
@@ -1204,40 +1051,40 @@ const char* parse_line(const char* p)
p=script->skip_space(p);
if(*p==';') {
//Close decision for if(); for(); while();
- p = parse_syntax_close(p + 1);
+ p = script->parse_syntax_close(p + 1);
return p;
}
- if(*p==')' && parse_syntax_for_flag)
+ if(*p==')' && script->parse_syntax_for_flag)
return p+1;
p = script->skip_space(p);
if(p[0] == '{') {
- syntax.curly[syntax.curly_count].type = TYPE_NULL;
- syntax.curly[syntax.curly_count].count = -1;
- syntax.curly[syntax.curly_count].index = -1;
- syntax.curly_count++;
+ script->syntax.curly[script->syntax.curly_count].type = TYPE_NULL;
+ script->syntax.curly[script->syntax.curly_count].count = -1;
+ script->syntax.curly[script->syntax.curly_count].index = -1;
+ script->syntax.curly_count++;
return p + 1;
} else if(p[0] == '}') {
- return parse_curly_close(p);
+ return script->parse_curly_close(p);
}
// Syntax-related processing
- p2 = parse_syntax(p);
+ p2 = script->parse_syntax(p);
if(p2 != NULL)
return p2;
// attempt to process a variable assignment
- p2 = parse_variable(p);
+ p2 = script->parse_variable(p);
if( p2 != NULL )
{// variable assignment processed so leave the method
- return parse_syntax_close(p2 + 1);
+ return script->parse_syntax_close(p2 + 1);
}
- p = parse_callfunc(p,0,0);
+ p = script->parse_callfunc(p,0,0);
p = script->skip_space(p);
- if(parse_syntax_for_flag) {
+ if(script->parse_syntax_for_flag) {
if( *p != ')' )
disp_error_message("parse_line: need ')'",p);
} else {
@@ -1246,7 +1093,7 @@ const char* parse_line(const char* p)
}
//Binding decision for if(), for(), while()
- p = parse_syntax_close(p+1);
+ p = script->parse_syntax_close(p+1);
return p;
}
@@ -1254,52 +1101,52 @@ const char* parse_line(const char* p)
// { ... } Closing process
const char* parse_curly_close(const char* p)
{
- if(syntax.curly_count <= 0) {
+ if(script->syntax.curly_count <= 0) {
disp_error_message("parse_curly_close: unexpected string",p);
return p + 1;
- } else if(syntax.curly[syntax.curly_count-1].type == TYPE_NULL) {
- syntax.curly_count--;
+ } else if(script->syntax.curly[script->syntax.curly_count-1].type == TYPE_NULL) {
+ script->syntax.curly_count--;
//Close decision if, for , while
- p = parse_syntax_close(p + 1);
+ p = script->parse_syntax_close(p + 1);
return p;
- } else if(syntax.curly[syntax.curly_count-1].type == TYPE_SWITCH) {
+ } else if(script->syntax.curly[script->syntax.curly_count-1].type == TYPE_SWITCH) {
//Closing switch()
- int pos = syntax.curly_count-1;
+ int pos = script->syntax.curly_count-1;
char label[256];
int l;
// Remove temporary variables
- sprintf(label,"set $@__SW%x_VAL,0;",syntax.curly[pos].index);
- syntax.curly[syntax.curly_count++].type = TYPE_NULL;
- parse_line(label);
- syntax.curly_count--;
+ sprintf(label,"set $@__SW%x_VAL,0;",script->syntax.curly[pos].index);
+ script->syntax.curly[script->syntax.curly_count++].type = TYPE_NULL;
+ script->parse_line(label);
+ script->syntax.curly_count--;
// Go to the end pointer unconditionally
- sprintf(label,"goto __SW%x_FIN;",syntax.curly[pos].index);
- syntax.curly[syntax.curly_count++].type = TYPE_NULL;
- parse_line(label);
- syntax.curly_count--;
+ sprintf(label,"goto __SW%x_FIN;",script->syntax.curly[pos].index);
+ script->syntax.curly[script->syntax.curly_count++].type = TYPE_NULL;
+ script->parse_line(label);
+ script->syntax.curly_count--;
// You are here labeled
- sprintf(label,"__SW%x_%x",syntax.curly[pos].index,syntax.curly[pos].count);
+ sprintf(label,"__SW%x_%x",script->syntax.curly[pos].index,script->syntax.curly[pos].count);
l=script->add_str(label);
- set_label(l,script_pos, p);
+ script->set_label(l,script->pos, p);
- if(syntax.curly[pos].flag) {
+ if(script->syntax.curly[pos].flag) {
//Exists default
- sprintf(label,"goto __SW%x_DEF;",syntax.curly[pos].index);
- syntax.curly[syntax.curly_count++].type = TYPE_NULL;
- parse_line(label);
- syntax.curly_count--;
+ sprintf(label,"goto __SW%x_DEF;",script->syntax.curly[pos].index);
+ script->syntax.curly[script->syntax.curly_count++].type = TYPE_NULL;
+ script->parse_line(label);
+ script->syntax.curly_count--;
}
// Label end
- sprintf(label,"__SW%x_FIN",syntax.curly[pos].index);
+ sprintf(label,"__SW%x_FIN",script->syntax.curly[pos].index);
l=script->add_str(label);
- set_label(l,script_pos, p);
- linkdb_final(&syntax.curly[pos].case_label); // free the list of case label
- syntax.curly_count--;
+ script->set_label(l,script->pos, p);
+ linkdb_final(&script->syntax.curly[pos].case_label); // free the list of case label
+ script->syntax.curly_count--;
//Closing decision if, for , while
- p = parse_syntax_close(p + 1);
+ p = script->parse_syntax_close(p + 1);
return p;
} else {
disp_error_message("parse_curly_close: unexpected string",p);
@@ -1312,7 +1159,7 @@ const char* parse_curly_close(const char* p)
// if, switch, while ? will handle this internally.
const char* parse_syntax(const char* p)
{
- const char *p2 = skip_word(p);
+ const char *p2 = script->skip_word(p);
switch(*p) {
case 'B':
@@ -1320,19 +1167,19 @@ const char* parse_syntax(const char* p)
if(p2 - p == 5 && !strncasecmp(p,"break",5)) {
// break Processing
char label[256];
- int pos = syntax.curly_count - 1;
+ int pos = script->syntax.curly_count - 1;
while(pos >= 0) {
- if(syntax.curly[pos].type == TYPE_DO) {
- sprintf(label,"goto __DO%x_FIN;",syntax.curly[pos].index);
+ if(script->syntax.curly[pos].type == TYPE_DO) {
+ sprintf(label,"goto __DO%x_FIN;",script->syntax.curly[pos].index);
break;
- } else if(syntax.curly[pos].type == TYPE_FOR) {
- sprintf(label,"goto __FR%x_FIN;",syntax.curly[pos].index);
+ } else if(script->syntax.curly[pos].type == TYPE_FOR) {
+ sprintf(label,"goto __FR%x_FIN;",script->syntax.curly[pos].index);
break;
- } else if(syntax.curly[pos].type == TYPE_WHILE) {
- sprintf(label,"goto __WL%x_FIN;",syntax.curly[pos].index);
+ } else if(script->syntax.curly[pos].type == TYPE_WHILE) {
+ sprintf(label,"goto __WL%x_FIN;",script->syntax.curly[pos].index);
break;
- } else if(syntax.curly[pos].type == TYPE_SWITCH) {
- sprintf(label,"goto __SW%x_FIN;",syntax.curly[pos].index);
+ } else if(script->syntax.curly[pos].type == TYPE_SWITCH) {
+ sprintf(label,"goto __SW%x_FIN;",script->syntax.curly[pos].index);
break;
}
pos--;
@@ -1340,15 +1187,15 @@ const char* parse_syntax(const char* p)
if(pos < 0) {
disp_error_message("parse_syntax: unexpected 'break'",p);
} else {
- syntax.curly[syntax.curly_count++].type = TYPE_NULL;
- parse_line(label);
- syntax.curly_count--;
+ script->syntax.curly[script->syntax.curly_count++].type = TYPE_NULL;
+ script->parse_line(label);
+ script->syntax.curly_count--;
}
p = script->skip_space(p2);
if(*p != ';')
disp_error_message("parse_syntax: need ';'",p);
// Closing decision if, for , while
- p = parse_syntax_close(p + 1);
+ p = script->parse_syntax_close(p + 1);
return p;
}
break;
@@ -1356,25 +1203,25 @@ const char* parse_syntax(const char* p)
case 'C':
if(p2 - p == 4 && !strncasecmp(p,"case",4)) {
//Processing case
- int pos = syntax.curly_count-1;
- if(pos < 0 || syntax.curly[pos].type != TYPE_SWITCH) {
+ int pos = script->syntax.curly_count-1;
+ if(pos < 0 || script->syntax.curly[pos].type != TYPE_SWITCH) {
disp_error_message("parse_syntax: unexpected 'case' ",p);
return p+1;
} else {
char label[256];
int l,v;
char *np;
- if(syntax.curly[pos].count != 1) {
+ if(script->syntax.curly[pos].count != 1) {
//Jump for FALLTHRU
- sprintf(label,"goto __SW%x_%xJ;",syntax.curly[pos].index,syntax.curly[pos].count);
- syntax.curly[syntax.curly_count++].type = TYPE_NULL;
- parse_line(label);
- syntax.curly_count--;
+ sprintf(label,"goto __SW%x_%xJ;",script->syntax.curly[pos].index,script->syntax.curly[pos].count);
+ script->syntax.curly[script->syntax.curly_count++].type = TYPE_NULL;
+ script->parse_line(label);
+ script->syntax.curly_count--;
// You are here labeled
- sprintf(label,"__SW%x_%x",syntax.curly[pos].index,syntax.curly[pos].count);
+ sprintf(label,"__SW%x_%x",script->syntax.curly[pos].index,script->syntax.curly[pos].count);
l=script->add_str(label);
- set_label(l,script_pos, p);
+ script->set_label(l,script->pos, p);
}
//Decision statement switch
p = script->skip_space(p2);
@@ -1384,17 +1231,17 @@ const char* parse_syntax(const char* p)
// check whether case label is integer or not
v = strtol(p,&np,0);
if(np == p) { //Check for constants
- p2 = skip_word(p);
+ p2 = script->skip_word(p);
v = p2-p; // length of word at p2
memcpy(label,p,v);
label[v]='\0';
if( !script->get_constant(label, &v) )
disp_error_message("parse_syntax: 'case' label is not an integer",p);
- p = skip_word(p);
+ p = script->skip_word(p);
} else { //Numeric value
if((*p == '-' || *p == '+') && ISDIGIT(p[1])) // pre-skip because '-' can not skip_word
p++;
- p = skip_word(p);
+ p = script->skip_word(p);
if(np != p)
disp_error_message("parse_syntax: 'case' label is not an integer",np);
}
@@ -1402,45 +1249,45 @@ const char* parse_syntax(const char* p)
if(*p != ':')
disp_error_message("parse_syntax: expect ':'",p);
sprintf(label,"if(%d != $@__SW%x_VAL) goto __SW%x_%x;",
- v,syntax.curly[pos].index,syntax.curly[pos].index,syntax.curly[pos].count+1);
- syntax.curly[syntax.curly_count++].type = TYPE_NULL;
+ v,script->syntax.curly[pos].index,script->syntax.curly[pos].index,script->syntax.curly[pos].count+1);
+ script->syntax.curly[script->syntax.curly_count++].type = TYPE_NULL;
// Bad I do not parse twice
- p2 = parse_line(label);
- parse_line(p2);
- syntax.curly_count--;
- if(syntax.curly[pos].count != 1) {
+ p2 = script->parse_line(label);
+ script->parse_line(p2);
+ script->syntax.curly_count--;
+ if(script->syntax.curly[pos].count != 1) {
// Label after the completion of FALLTHRU
- sprintf(label,"__SW%x_%xJ",syntax.curly[pos].index,syntax.curly[pos].count);
+ sprintf(label,"__SW%x_%xJ",script->syntax.curly[pos].index,script->syntax.curly[pos].count);
l=script->add_str(label);
- set_label(l,script_pos,p);
+ script->set_label(l,script->pos,p);
}
// check duplication of case label [Rayce]
- if(linkdb_search(&syntax.curly[pos].case_label, (void*)__64BPTRSIZE(v)) != NULL)
+ if(linkdb_search(&script->syntax.curly[pos].case_label, (void*)__64BPTRSIZE(v)) != NULL)
disp_error_message("parse_syntax: dup 'case'",p);
- linkdb_insert(&syntax.curly[pos].case_label, (void*)__64BPTRSIZE(v), (void*)1);
+ linkdb_insert(&script->syntax.curly[pos].case_label, (void*)__64BPTRSIZE(v), (void*)1);
- sprintf(label,"set $@__SW%x_VAL,0;",syntax.curly[pos].index);
- syntax.curly[syntax.curly_count++].type = TYPE_NULL;
+ sprintf(label,"set $@__SW%x_VAL,0;",script->syntax.curly[pos].index);
+ script->syntax.curly[script->syntax.curly_count++].type = TYPE_NULL;
- parse_line(label);
- syntax.curly_count--;
- syntax.curly[pos].count++;
+ script->parse_line(label);
+ script->syntax.curly_count--;
+ script->syntax.curly[pos].count++;
}
return p + 1;
} else if(p2 - p == 8 && !strncasecmp(p,"continue",8)) {
// Processing continue
char label[256];
- int pos = syntax.curly_count - 1;
+ int pos = script->syntax.curly_count - 1;
while(pos >= 0) {
- if(syntax.curly[pos].type == TYPE_DO) {
- sprintf(label,"goto __DO%x_NXT;",syntax.curly[pos].index);
- syntax.curly[pos].flag = 1; //Flag put the link for continue
+ if(script->syntax.curly[pos].type == TYPE_DO) {
+ sprintf(label,"goto __DO%x_NXT;",script->syntax.curly[pos].index);
+ script->syntax.curly[pos].flag = 1; //Flag put the link for continue
break;
- } else if(syntax.curly[pos].type == TYPE_FOR) {
- sprintf(label,"goto __FR%x_NXT;",syntax.curly[pos].index);
+ } else if(script->syntax.curly[pos].type == TYPE_FOR) {
+ sprintf(label,"goto __FR%x_NXT;",script->syntax.curly[pos].index);
break;
- } else if(syntax.curly[pos].type == TYPE_WHILE) {
- sprintf(label,"goto __WL%x_NXT;",syntax.curly[pos].index);
+ } else if(script->syntax.curly[pos].type == TYPE_WHILE) {
+ sprintf(label,"goto __WL%x_NXT;",script->syntax.curly[pos].index);
break;
}
pos--;
@@ -1448,15 +1295,15 @@ const char* parse_syntax(const char* p)
if(pos < 0) {
disp_error_message("parse_syntax: unexpected 'continue'",p);
} else {
- syntax.curly[syntax.curly_count++].type = TYPE_NULL;
- parse_line(label);
- syntax.curly_count--;
+ script->syntax.curly[script->syntax.curly_count++].type = TYPE_NULL;
+ script->parse_line(label);
+ script->syntax.curly_count--;
}
p = script->skip_space(p2);
if(*p != ';')
disp_error_message("parse_syntax: need ';'",p);
//Closing decision if, for , while
- p = parse_syntax_close(p + 1);
+ p = script->parse_syntax_close(p + 1);
return p;
}
break;
@@ -1464,10 +1311,10 @@ const char* parse_syntax(const char* p)
case 'D':
if(p2 - p == 7 && !strncasecmp(p,"default",7)) {
// Switch - default processing
- int pos = syntax.curly_count-1;
- if(pos < 0 || syntax.curly[pos].type != TYPE_SWITCH) {
+ int pos = script->syntax.curly_count-1;
+ if(pos < 0 || script->syntax.curly[pos].type != TYPE_SWITCH) {
disp_error_message("parse_syntax: unexpected 'default'",p);
- } else if(syntax.curly[pos].flag) {
+ } else if(script->syntax.curly[pos].flag) {
disp_error_message("parse_syntax: dup 'default'",p);
} else {
char label[256];
@@ -1477,23 +1324,23 @@ const char* parse_syntax(const char* p)
if(*p != ':') {
disp_error_message("parse_syntax: need ':'",p);
}
- sprintf(label,"__SW%x_%x",syntax.curly[pos].index,syntax.curly[pos].count);
+ sprintf(label,"__SW%x_%x",script->syntax.curly[pos].index,script->syntax.curly[pos].count);
l=script->add_str(label);
- set_label(l,script_pos,p);
+ script->set_label(l,script->pos,p);
// Skip to the next link w/o condition
- sprintf(label,"goto __SW%x_%x;",syntax.curly[pos].index,syntax.curly[pos].count+1);
- syntax.curly[syntax.curly_count++].type = TYPE_NULL;
- parse_line(label);
- syntax.curly_count--;
+ sprintf(label,"goto __SW%x_%x;",script->syntax.curly[pos].index,script->syntax.curly[pos].count+1);
+ script->syntax.curly[script->syntax.curly_count++].type = TYPE_NULL;
+ script->parse_line(label);
+ script->syntax.curly_count--;
// The default label
- sprintf(label,"__SW%x_DEF",syntax.curly[pos].index);
+ sprintf(label,"__SW%x_DEF",script->syntax.curly[pos].index);
l=script->add_str(label);
- set_label(l,script_pos,p);
+ script->set_label(l,script->pos,p);
- syntax.curly[syntax.curly_count - 1].flag = 1;
- syntax.curly[pos].count++;
+ script->syntax.curly[script->syntax.curly_count - 1].flag = 1;
+ script->syntax.curly[pos].count++;
}
return p + 1;
} else if(p2 - p == 2 && !strncasecmp(p,"do",2)) {
@@ -1501,15 +1348,15 @@ const char* parse_syntax(const char* p)
char label[256];
p=script->skip_space(p2);
- syntax.curly[syntax.curly_count].type = TYPE_DO;
- syntax.curly[syntax.curly_count].count = 1;
- syntax.curly[syntax.curly_count].index = syntax.index++;
- syntax.curly[syntax.curly_count].flag = 0;
+ script->syntax.curly[script->syntax.curly_count].type = TYPE_DO;
+ script->syntax.curly[script->syntax.curly_count].count = 1;
+ script->syntax.curly[script->syntax.curly_count].index = script->syntax.index++;
+ script->syntax.curly[script->syntax.curly_count].flag = 0;
// Label of the (do) form here
- sprintf(label,"__DO%x_BGN",syntax.curly[syntax.curly_count].index);
+ sprintf(label,"__DO%x_BGN",script->syntax.curly[script->syntax.curly_count].index);
l=script->add_str(label);
- set_label(l,script_pos,p);
- syntax.curly_count++;
+ script->set_label(l,script->pos,p);
+ script->syntax.curly_count++;
return p;
}
break;
@@ -1518,12 +1365,12 @@ const char* parse_syntax(const char* p)
if(p2 - p == 3 && !strncasecmp(p,"for",3)) {
int l;
char label[256];
- int pos = syntax.curly_count;
- syntax.curly[syntax.curly_count].type = TYPE_FOR;
- syntax.curly[syntax.curly_count].count = 1;
- syntax.curly[syntax.curly_count].index = syntax.index++;
- syntax.curly[syntax.curly_count].flag = 0;
- syntax.curly_count++;
+ int pos = script->syntax.curly_count;
+ script->syntax.curly[script->syntax.curly_count].type = TYPE_FOR;
+ script->syntax.curly[script->syntax.curly_count].count = 1;
+ script->syntax.curly[script->syntax.curly_count].index = script->syntax.index++;
+ script->syntax.curly[script->syntax.curly_count].flag = 0;
+ script->syntax.curly_count++;
p=script->skip_space(p2);
@@ -1532,14 +1379,14 @@ const char* parse_syntax(const char* p)
p++;
// Execute the initialization statement
- syntax.curly[syntax.curly_count++].type = TYPE_NULL;
- p=parse_line(p);
- syntax.curly_count--;
+ script->syntax.curly[script->syntax.curly_count++].type = TYPE_NULL;
+ p=script->parse_line(p);
+ script->syntax.curly_count--;
// Form the start of label decision
- sprintf(label,"__FR%x_J",syntax.curly[pos].index);
+ sprintf(label,"__FR%x_J",script->syntax.curly[pos].index);
l=script->add_str(label);
- set_label(l,script_pos,p);
+ script->set_label(l,script->pos,p);
p=script->skip_space(p);
if(*p == ';') {
@@ -1547,47 +1394,47 @@ const char* parse_syntax(const char* p)
;
} else {
// Skip to the end point if the condition is false
- sprintf(label,"__FR%x_FIN",syntax.curly[pos].index);
- add_scriptl(script->add_str("jump_zero"));
- add_scriptc(C_ARG);
- p=parse_expr(p);
+ sprintf(label,"__FR%x_FIN",script->syntax.curly[pos].index);
+ script->addl(script->add_str("jump_zero"));
+ script->addc(C_ARG);
+ p=script->parse_expr(p);
p=script->skip_space(p);
- add_scriptl(script->add_str(label));
- add_scriptc(C_FUNC);
+ script->addl(script->add_str(label));
+ script->addc(C_FUNC);
}
if(*p != ';')
disp_error_message("parse_syntax: need ';'",p);
p++;
// Skip to the beginning of the loop
- sprintf(label,"goto __FR%x_BGN;",syntax.curly[pos].index);
- syntax.curly[syntax.curly_count++].type = TYPE_NULL;
- parse_line(label);
- syntax.curly_count--;
+ sprintf(label,"goto __FR%x_BGN;",script->syntax.curly[pos].index);
+ script->syntax.curly[script->syntax.curly_count++].type = TYPE_NULL;
+ script->parse_line(label);
+ script->syntax.curly_count--;
// Labels to form the next loop
- sprintf(label,"__FR%x_NXT",syntax.curly[pos].index);
+ sprintf(label,"__FR%x_NXT",script->syntax.curly[pos].index);
l=script->add_str(label);
- set_label(l,script_pos,p);
+ script->set_label(l,script->pos,p);
// Process the next time you enter the loop
// A ')' last for; flag to be treated as'
- parse_syntax_for_flag = 1;
- syntax.curly[syntax.curly_count++].type = TYPE_NULL;
- p=parse_line(p);
- syntax.curly_count--;
- parse_syntax_for_flag = 0;
+ script->parse_syntax_for_flag = 1;
+ script->syntax.curly[script->syntax.curly_count++].type = TYPE_NULL;
+ p=script->parse_line(p);
+ script->syntax.curly_count--;
+ script->parse_syntax_for_flag = 0;
// Skip to the determination process conditions
- sprintf(label,"goto __FR%x_J;",syntax.curly[pos].index);
- syntax.curly[syntax.curly_count++].type = TYPE_NULL;
- parse_line(label);
- syntax.curly_count--;
+ sprintf(label,"goto __FR%x_J;",script->syntax.curly[pos].index);
+ script->syntax.curly[script->syntax.curly_count++].type = TYPE_NULL;
+ script->parse_line(label);
+ script->syntax.curly_count--;
// Loop start labeling
- sprintf(label,"__FR%x_BGN",syntax.curly[pos].index);
+ sprintf(label,"__FR%x_BGN",script->syntax.curly[pos].index);
l=script->add_str(label);
- set_label(l,script_pos,p);
+ script->set_label(l,script->pos,p);
return p;
}
else if( p2 - p == 8 && strncasecmp(p,"function",8) == 0 )
@@ -1595,7 +1442,7 @@ const char* parse_syntax(const char* p)
const char *func_name;
func_name = script->skip_space(p2);
- p = skip_word(func_name);
+ p = script->skip_word(func_name);
if( p == func_name )
disp_error_message("parse_syntax:function: function name is missing or invalid", p);
p2 = script->skip_space(p);
@@ -1603,7 +1450,7 @@ const char* parse_syntax(const char* p)
{// function <name> ;
// function declaration - just register the name
int l;
- l = add_word(func_name);
+ l = script->add_word(func_name);
if( script->str_data[l].type == C_NOP )// register only, if the name was not used by something else
script->str_data[l].type = C_USERFUNC;
else if( script->str_data[l].type == C_USERFUNC )
@@ -1612,7 +1459,7 @@ const char* parse_syntax(const char* p)
disp_error_message("parse_syntax:function: function name is invalid", func_name);
// Close condition of if, for, while
- p = parse_syntax_close(p2 + 1);
+ p = script->parse_syntax_close(p2 + 1);
return p;
}
else if(*p2 == '{')
@@ -1620,27 +1467,27 @@ const char* parse_syntax(const char* p)
char label[256];
int l;
- syntax.curly[syntax.curly_count].type = TYPE_USERFUNC;
- syntax.curly[syntax.curly_count].count = 1;
- syntax.curly[syntax.curly_count].index = syntax.index++;
- syntax.curly[syntax.curly_count].flag = 0;
- ++syntax.curly_count;
+ script->syntax.curly[script->syntax.curly_count].type = TYPE_USERFUNC;
+ script->syntax.curly[script->syntax.curly_count].count = 1;
+ script->syntax.curly[script->syntax.curly_count].index = script->syntax.index++;
+ script->syntax.curly[script->syntax.curly_count].flag = 0;
+ ++script->syntax.curly_count;
// Jump over the function code
- sprintf(label, "goto __FN%x_FIN;", syntax.curly[syntax.curly_count-1].index);
- syntax.curly[syntax.curly_count].type = TYPE_NULL;
- ++syntax.curly_count;
- parse_line(label);
- --syntax.curly_count;
+ sprintf(label, "goto __FN%x_FIN;", script->syntax.curly[script->syntax.curly_count-1].index);
+ script->syntax.curly[script->syntax.curly_count].type = TYPE_NULL;
+ ++script->syntax.curly_count;
+ script->parse_line(label);
+ --script->syntax.curly_count;
// Set the position of the function (label)
- l=add_word(func_name);
+ l=script->add_word(func_name);
if( script->str_data[l].type == C_NOP || script->str_data[l].type == C_USERFUNC )// register only, if the name was not used by something else
{
script->str_data[l].type = C_USERFUNC;
- set_label(l, script_pos, p);
- if( parse_options&SCRIPT_USE_LABEL_DB )
- script->label_add(l,script_pos);
+ script->set_label(l, script->pos, p);
+ if( script->parse_options&SCRIPT_USE_LABEL_DB )
+ script->label_add(l,script->pos);
}
else
disp_error_message("parse_syntax:function: function name is invalid", func_name);
@@ -1659,21 +1506,21 @@ const char* parse_syntax(const char* p)
// If process
char label[256];
p=script->skip_space(p2);
- if(*p != '(') { //Prevent if this {} non-c syntax. from Rayce (jA)
+ if(*p != '(') { //Prevent if this {} non-c script->syntax. from Rayce (jA)
disp_error_message("need '('",p);
}
- syntax.curly[syntax.curly_count].type = TYPE_IF;
- syntax.curly[syntax.curly_count].count = 1;
- syntax.curly[syntax.curly_count].index = syntax.index++;
- syntax.curly[syntax.curly_count].flag = 0;
- sprintf(label,"__IF%x_%x",syntax.curly[syntax.curly_count].index,syntax.curly[syntax.curly_count].count);
- syntax.curly_count++;
- add_scriptl(script->add_str("jump_zero"));
- add_scriptc(C_ARG);
- p=parse_expr(p);
+ script->syntax.curly[script->syntax.curly_count].type = TYPE_IF;
+ script->syntax.curly[script->syntax.curly_count].count = 1;
+ script->syntax.curly[script->syntax.curly_count].index = script->syntax.index++;
+ script->syntax.curly[script->syntax.curly_count].flag = 0;
+ sprintf(label,"__IF%x_%x",script->syntax.curly[script->syntax.curly_count].index,script->syntax.curly[script->syntax.curly_count].count);
+ script->syntax.curly_count++;
+ script->addl(script->add_str("jump_zero"));
+ script->addc(C_ARG);
+ p=script->parse_expr(p);
p=script->skip_space(p);
- add_scriptl(script->add_str(label));
- add_scriptc(C_FUNC);
+ script->addl(script->add_str(label));
+ script->addc(C_FUNC);
return p;
}
break;
@@ -1686,21 +1533,21 @@ const char* parse_syntax(const char* p)
if(*p != '(') {
disp_error_message("need '('",p);
}
- syntax.curly[syntax.curly_count].type = TYPE_SWITCH;
- syntax.curly[syntax.curly_count].count = 1;
- syntax.curly[syntax.curly_count].index = syntax.index++;
- syntax.curly[syntax.curly_count].flag = 0;
- sprintf(label,"$@__SW%x_VAL",syntax.curly[syntax.curly_count].index);
- syntax.curly_count++;
- add_scriptl(script->add_str("set"));
- add_scriptc(C_ARG);
- add_scriptl(script->add_str(label));
- p=parse_expr(p);
+ script->syntax.curly[script->syntax.curly_count].type = TYPE_SWITCH;
+ script->syntax.curly[script->syntax.curly_count].count = 1;
+ script->syntax.curly[script->syntax.curly_count].index = script->syntax.index++;
+ script->syntax.curly[script->syntax.curly_count].flag = 0;
+ sprintf(label,"$@__SW%x_VAL",script->syntax.curly[script->syntax.curly_count].index);
+ script->syntax.curly_count++;
+ script->addl(script->add_str("set"));
+ script->addc(C_ARG);
+ script->addl(script->add_str(label));
+ p=script->parse_expr(p);
p=script->skip_space(p);
if(*p != '{') {
disp_error_message("parse_syntax: need '{'",p);
}
- add_scriptc(C_FUNC);
+ script->addc(C_FUNC);
return p + 1;
}
break;
@@ -1713,24 +1560,24 @@ const char* parse_syntax(const char* p)
if(*p != '(') {
disp_error_message("need '('",p);
}
- syntax.curly[syntax.curly_count].type = TYPE_WHILE;
- syntax.curly[syntax.curly_count].count = 1;
- syntax.curly[syntax.curly_count].index = syntax.index++;
- syntax.curly[syntax.curly_count].flag = 0;
+ script->syntax.curly[script->syntax.curly_count].type = TYPE_WHILE;
+ script->syntax.curly[script->syntax.curly_count].count = 1;
+ script->syntax.curly[script->syntax.curly_count].index = script->syntax.index++;
+ script->syntax.curly[script->syntax.curly_count].flag = 0;
// Form the start of label decision
- sprintf(label,"__WL%x_NXT",syntax.curly[syntax.curly_count].index);
+ sprintf(label,"__WL%x_NXT",script->syntax.curly[script->syntax.curly_count].index);
l=script->add_str(label);
- set_label(l,script_pos,p);
+ script->set_label(l,script->pos,p);
// Skip to the end point if the condition is false
- sprintf(label,"__WL%x_FIN",syntax.curly[syntax.curly_count].index);
- syntax.curly_count++;
- add_scriptl(script->add_str("jump_zero"));
- add_scriptc(C_ARG);
- p=parse_expr(p);
+ sprintf(label,"__WL%x_FIN",script->syntax.curly[script->syntax.curly_count].index);
+ script->syntax.curly_count++;
+ script->addl(script->add_str("jump_zero"));
+ script->addc(C_ARG);
+ p=script->parse_expr(p);
p=script->skip_space(p);
- add_scriptl(script->add_str(label));
- add_scriptc(C_FUNC);
+ script->addl(script->add_str(label));
+ script->addc(C_FUNC);
return p;
}
break;
@@ -1743,7 +1590,7 @@ const char* parse_syntax_close(const char *p) {
int flag;
do {
- p = parse_syntax_close_sub(p,&flag);
+ p = script->parse_syntax_close_sub(p,&flag);
} while(flag);
return p;
}
@@ -1754,88 +1601,88 @@ const char* parse_syntax_close(const char *p) {
const char* parse_syntax_close_sub(const char* p,int* flag)
{
char label[256];
- int pos = syntax.curly_count - 1;
+ int pos = script->syntax.curly_count - 1;
int l;
*flag = 1;
- if(syntax.curly_count <= 0) {
+ if(script->syntax.curly_count <= 0) {
*flag = 0;
return p;
- } else if(syntax.curly[pos].type == TYPE_IF) {
+ } else if(script->syntax.curly[pos].type == TYPE_IF) {
const char *bp = p;
const char *p2;
// if-block and else-block end is a new line
- parse_nextline(false, p);
+ script->parse_nextline(false, p);
// Skip to the last location if
- sprintf(label,"goto __IF%x_FIN;",syntax.curly[pos].index);
- syntax.curly[syntax.curly_count++].type = TYPE_NULL;
- parse_line(label);
- syntax.curly_count--;
+ sprintf(label,"goto __IF%x_FIN;",script->syntax.curly[pos].index);
+ script->syntax.curly[script->syntax.curly_count++].type = TYPE_NULL;
+ script->parse_line(label);
+ script->syntax.curly_count--;
// Put the label of the location
- sprintf(label,"__IF%x_%x",syntax.curly[pos].index,syntax.curly[pos].count);
+ sprintf(label,"__IF%x_%x",script->syntax.curly[pos].index,script->syntax.curly[pos].count);
l=script->add_str(label);
- set_label(l,script_pos,p);
+ script->set_label(l,script->pos,p);
- syntax.curly[pos].count++;
+ script->syntax.curly[pos].count++;
p = script->skip_space(p);
- p2 = skip_word(p);
- if(!syntax.curly[pos].flag && p2 - p == 4 && !strncasecmp(p,"else",4)) {
+ p2 = script->skip_word(p);
+ if(!script->syntax.curly[pos].flag && p2 - p == 4 && !strncasecmp(p,"else",4)) {
// else or else - if
p = script->skip_space(p2);
- p2 = skip_word(p);
+ p2 = script->skip_word(p);
if(p2 - p == 2 && !strncasecmp(p,"if",2)) {
// else - if
p=script->skip_space(p2);
if(*p != '(') {
disp_error_message("need '('",p);
}
- sprintf(label,"__IF%x_%x",syntax.curly[pos].index,syntax.curly[pos].count);
- add_scriptl(script->add_str("jump_zero"));
- add_scriptc(C_ARG);
- p=parse_expr(p);
+ sprintf(label,"__IF%x_%x",script->syntax.curly[pos].index,script->syntax.curly[pos].count);
+ script->addl(script->add_str("jump_zero"));
+ script->addc(C_ARG);
+ p=script->parse_expr(p);
p=script->skip_space(p);
- add_scriptl(script->add_str(label));
- add_scriptc(C_FUNC);
+ script->addl(script->add_str(label));
+ script->addc(C_FUNC);
*flag = 0;
return p;
} else {
// else
- if(!syntax.curly[pos].flag) {
- syntax.curly[pos].flag = 1;
+ if(!script->syntax.curly[pos].flag) {
+ script->syntax.curly[pos].flag = 1;
*flag = 0;
return p;
}
}
}
// Close if
- syntax.curly_count--;
+ script->syntax.curly_count--;
// Put the label of the final location
- sprintf(label,"__IF%x_FIN",syntax.curly[pos].index);
+ sprintf(label,"__IF%x_FIN",script->syntax.curly[pos].index);
l=script->add_str(label);
- set_label(l,script_pos,p);
- if(syntax.curly[pos].flag == 1) {
+ script->set_label(l,script->pos,p);
+ if(script->syntax.curly[pos].flag == 1) {
// Because the position of the pointer is the same if not else for this
return bp;
}
return p;
- } else if(syntax.curly[pos].type == TYPE_DO) {
+ } else if(script->syntax.curly[pos].type == TYPE_DO) {
int l;
char label[256];
const char *p2;
- if(syntax.curly[pos].flag) {
+ if(script->syntax.curly[pos].flag) {
// (Come here continue) to form the label here
- sprintf(label,"__DO%x_NXT",syntax.curly[pos].index);
+ sprintf(label,"__DO%x_NXT",script->syntax.curly[pos].index);
l=script->add_str(label);
- set_label(l,script_pos,p);
+ script->set_label(l,script->pos,p);
}
// Skip to the end point if the condition is false
p = script->skip_space(p);
- p2 = skip_word(p);
+ p2 = script->skip_word(p);
if(p2 - p != 5 || strncasecmp(p,"while",5))
disp_error_message("parse_syntax: need 'while'",p);
@@ -1845,81 +1692,81 @@ const char* parse_syntax_close_sub(const char* p,int* flag)
}
// do-block end is a new line
- parse_nextline(false, p);
+ script->parse_nextline(false, p);
- sprintf(label,"__DO%x_FIN",syntax.curly[pos].index);
- add_scriptl(script->add_str("jump_zero"));
- add_scriptc(C_ARG);
- p=parse_expr(p);
+ sprintf(label,"__DO%x_FIN",script->syntax.curly[pos].index);
+ script->addl(script->add_str("jump_zero"));
+ script->addc(C_ARG);
+ p=script->parse_expr(p);
p=script->skip_space(p);
- add_scriptl(script->add_str(label));
- add_scriptc(C_FUNC);
+ script->addl(script->add_str(label));
+ script->addc(C_FUNC);
// Skip to the starting point
- sprintf(label,"goto __DO%x_BGN;",syntax.curly[pos].index);
- syntax.curly[syntax.curly_count++].type = TYPE_NULL;
- parse_line(label);
- syntax.curly_count--;
+ sprintf(label,"goto __DO%x_BGN;",script->syntax.curly[pos].index);
+ script->syntax.curly[script->syntax.curly_count++].type = TYPE_NULL;
+ script->parse_line(label);
+ script->syntax.curly_count--;
// Form label of the end point conditions
- sprintf(label,"__DO%x_FIN",syntax.curly[pos].index);
+ sprintf(label,"__DO%x_FIN",script->syntax.curly[pos].index);
l=script->add_str(label);
- set_label(l,script_pos,p);
+ script->set_label(l,script->pos,p);
p = script->skip_space(p);
if(*p != ';') {
disp_error_message("parse_syntax: need ';'",p);
return p+1;
}
p++;
- syntax.curly_count--;
+ script->syntax.curly_count--;
return p;
- } else if(syntax.curly[pos].type == TYPE_FOR) {
+ } else if(script->syntax.curly[pos].type == TYPE_FOR) {
// for-block end is a new line
- parse_nextline(false, p);
+ script->parse_nextline(false, p);
// Skip to the next loop
- sprintf(label,"goto __FR%x_NXT;",syntax.curly[pos].index);
- syntax.curly[syntax.curly_count++].type = TYPE_NULL;
- parse_line(label);
- syntax.curly_count--;
+ sprintf(label,"goto __FR%x_NXT;",script->syntax.curly[pos].index);
+ script->syntax.curly[script->syntax.curly_count++].type = TYPE_NULL;
+ script->parse_line(label);
+ script->syntax.curly_count--;
// End for labeling
- sprintf(label,"__FR%x_FIN",syntax.curly[pos].index);
+ sprintf(label,"__FR%x_FIN",script->syntax.curly[pos].index);
l=script->add_str(label);
- set_label(l,script_pos,p);
- syntax.curly_count--;
+ script->set_label(l,script->pos,p);
+ script->syntax.curly_count--;
return p;
- } else if(syntax.curly[pos].type == TYPE_WHILE) {
+ } else if(script->syntax.curly[pos].type == TYPE_WHILE) {
// while-block end is a new line
- parse_nextline(false, p);
+ script->parse_nextline(false, p);
// Skip to the decision while
- sprintf(label,"goto __WL%x_NXT;",syntax.curly[pos].index);
- syntax.curly[syntax.curly_count++].type = TYPE_NULL;
- parse_line(label);
- syntax.curly_count--;
+ sprintf(label,"goto __WL%x_NXT;",script->syntax.curly[pos].index);
+ script->syntax.curly[script->syntax.curly_count++].type = TYPE_NULL;
+ script->parse_line(label);
+ script->syntax.curly_count--;
// End while labeling
- sprintf(label,"__WL%x_FIN",syntax.curly[pos].index);
+ sprintf(label,"__WL%x_FIN",script->syntax.curly[pos].index);
l=script->add_str(label);
- set_label(l,script_pos,p);
- syntax.curly_count--;
+ script->set_label(l,script->pos,p);
+ script->syntax.curly_count--;
return p;
- } else if(syntax.curly[syntax.curly_count-1].type == TYPE_USERFUNC) {
- int pos = syntax.curly_count-1;
+ } else if(script->syntax.curly[script->syntax.curly_count-1].type == TYPE_USERFUNC) {
+ int pos = script->syntax.curly_count-1;
char label[256];
int l;
// Back
sprintf(label,"return;");
- syntax.curly[syntax.curly_count++].type = TYPE_NULL;
- parse_line(label);
- syntax.curly_count--;
+ script->syntax.curly[script->syntax.curly_count++].type = TYPE_NULL;
+ script->parse_line(label);
+ script->syntax.curly_count--;
// Put the label of the location
- sprintf(label,"__FN%x_FIN",syntax.curly[pos].index);
+ sprintf(label,"__FN%x_FIN",script->syntax.curly[pos].index);
l=script->add_str(label);
- set_label(l,script_pos,p);
- syntax.curly_count--;
+ script->set_label(l,script->pos,p);
+ script->syntax.curly_count--;
return p;
} else {
*flag = 0;
@@ -1951,7 +1798,7 @@ void script_set_constant(const char* name, int value, bool isparameter) {
} else if( script->str_data[n].type == C_PARAM || script->str_data[n].type == C_INT ) {// existing parameter or constant
ShowError("script_set_constant: Attempted to overwrite existing %s '%s' (old value=%d, new value=%d).\n", ( script->str_data[n].type == C_PARAM ) ? "parameter" : "constant", name, script->str_data[n].val, value);
} else {// existing name
- ShowError("script_set_constant: Invalid name for %s '%s' (already defined as %s).\n", isparameter ? "parameter" : "constant", name, script_op2name(script->str_data[n].type));
+ ShowError("script_set_constant: Invalid name for %s '%s' (already defined as %s).\n", isparameter ? "parameter" : "constant", name, script->op2name(script->str_data[n].type));
}
}
/* adds data to a existent constant in the database, inserted normally via parse */
@@ -1992,7 +1839,7 @@ void script_set_constant_force(const char *name, int value, bool isparameter) {
* Reading constant databases
* const.txt
*------------------------------------------*/
-static void read_constdb(void) {
+void read_constdb(void) {
FILE *fp;
char line[1024],name[1024],val[1024];
int type;
@@ -2010,7 +1857,7 @@ static void read_constdb(void) {
type=0;
if(sscanf(line,"%[A-Za-z0-9_],%[-0-9xXA-Fa-f],%d",name,val,&type)>=2 ||
sscanf(line,"%[A-Za-z0-9_] %[-0-9xXA-Fa-f] %d",name,val,&type)>=2){
- script_set_constant(name, (int)strtol(val, NULL, 0), (bool)type);
+ script->set_constant(name, (int)strtol(val, NULL, 0), (bool)type);
}
}
fclose(fp);
@@ -2019,7 +1866,7 @@ static void read_constdb(void) {
/*==========================================
* Display emplacement line of script
*------------------------------------------*/
-static const char* script_print_line(StringBuf* buf, const char* p, const char* mark, int line)
+const char* script_print_line(StringBuf* buf, const char* p, const char* mark, int line)
{
int i;
if( p == NULL || !p[0] ) return NULL;
@@ -2063,11 +1910,11 @@ void script_errorwarning_sub(StringBuf *buf, const char* src, const char* file,
StrBuf->Printf(buf, " %s\n", error_msg);
for(j = 0; j < 5; j++ ) {
- script_print_line(buf, linestart[j], NULL, line + j - 5);
+ script->print_line(buf, linestart[j], NULL, line + j - 5);
}
- p = script_print_line(buf, p, error_pos, -line);
+ p = script->print_line(buf, p, error_pos, -line);
for(j = 0; j < 5; j++) {
- p = script_print_line(buf, p, NULL, line + j + 1 );
+ p = script->print_line(buf, p, NULL, line + j + 1 );
}
}
@@ -2077,7 +1924,7 @@ void script_error(const char* src, const char* file, int start_line, const char*
StrBuf->Init(&buf);
StrBuf->AppendStr(&buf, "\a\n");
- script_errorwarning_sub(&buf, src, file, start_line, error_msg, error_pos);
+ script->errorwarning_sub(&buf, src, file, start_line, error_msg, error_pos);
ShowError("%s", StrBuf->Value(&buf));
StrBuf->Destroy(&buf);
@@ -2088,7 +1935,7 @@ void script_warning(const char* src, const char* file, int start_line, const cha
StrBuf->Init(&buf);
- script_errorwarning_sub(&buf, src, file, start_line, error_msg, error_pos);
+ script->errorwarning_sub(&buf, src, file, start_line, error_msg, error_pos);
ShowWarning("%s", StrBuf->Value(&buf));
StrBuf->Destroy(&buf);
@@ -2104,54 +1951,55 @@ struct script_code* parse_script(const char *src,const char *file,int line,int o
struct script_code* code = NULL;
char end;
bool unresolved_names = false;
- parser_current_src = src;
- parser_current_file = file;
- parser_current_line = line;
+
+ script->parser_current_src = src;
+ script->parser_current_file = file;
+ script->parser_current_line = line;
if( src == NULL )
return NULL;// empty script
- memset(&syntax,0,sizeof(syntax));
+ memset(&script->syntax,0,sizeof(script->syntax));
- script_buf=(unsigned char *)aMalloc(SCRIPT_BLOCK_SIZE*sizeof(unsigned char));
- script_pos=0;
- script_size=SCRIPT_BLOCK_SIZE;
- parse_nextline(true, NULL);
+ script->buf=(unsigned char *)aMalloc(SCRIPT_BLOCK_SIZE*sizeof(unsigned char));
+ script->pos=0;
+ script->size=SCRIPT_BLOCK_SIZE;
+ script->parse_nextline(true, NULL);
// who called parse_script is responsible for clearing the database after using it, but just in case... lets clear it here
if( options&SCRIPT_USE_LABEL_DB )
script->label_count = 0;
- parse_options = options;
+ script->parse_options = options;
- if( setjmp( error_jump ) != 0 ) {
+ if( setjmp( script->error_jump ) != 0 ) {
//Restore program state when script has problems. [from jA]
int i;
- const int size = ARRAYLENGTH(syntax.curly);
- if( error_report )
- script->error(src,file,line,error_msg,error_pos);
- aFree( error_msg );
- aFree( script_buf );
- script_pos = 0;
- script_size = 0;
- script_buf = NULL;
+ const int size = ARRAYLENGTH(script->syntax.curly);
+ if( script->error_report )
+ script->error(src,file,line,script->error_msg,script->error_pos);
+ aFree( script->error_msg );
+ aFree( script->buf );
+ script->pos = 0;
+ script->size = 0;
+ script->buf = NULL;
for(i=LABEL_START;i<script->str_num;i++)
if(script->str_data[i].type == C_NOP) script->str_data[i].type = C_NAME;
for(i=0; i<size; i++)
- linkdb_final(&syntax.curly[i].case_label);
+ linkdb_final(&script->syntax.curly[i].case_label);
return NULL;
}
- parse_syntax_for_flag=0;
+ script->parse_syntax_for_flag=0;
p=src;
p=script->skip_space(p);
if( options&SCRIPT_IGNORE_EXTERNAL_BRACKETS )
{// does not require brackets around the script
if( *p == '\0' && !(options&SCRIPT_RETURN_EMPTY_SCRIPT) )
{// empty script and can return NULL
- aFree( script_buf );
- script_pos = 0;
- script_size = 0;
- script_buf = NULL;
+ aFree( script->buf );
+ script->pos = 0;
+ script->size = 0;
+ script->buf = NULL;
return NULL;
}
end = '\0';
@@ -2163,10 +2011,10 @@ struct script_code* parse_script(const char *src,const char *file,int line,int o
p = script->skip_space(p+1);
if( *p == '}' && !(options&SCRIPT_RETURN_EMPTY_SCRIPT) )
{// empty script and can return NULL
- aFree( script_buf );
- script_pos = 0;
- script_size = 0;
- script_buf = NULL;
+ aFree( script->buf );
+ script->pos = 0;
+ script->size = 0;
+ script->buf = NULL;
return NULL;
}
end = '}';
@@ -2184,34 +2032,34 @@ struct script_code* parse_script(const char *src,const char *file,int line,int o
}
}
- while( syntax.curly_count != 0 || *p != end )
+ while( script->syntax.curly_count != 0 || *p != end )
{
if( *p == '\0' )
disp_error_message("unexpected end of script",p);
// Special handling only label
- tmpp=script->skip_space(skip_word(p));
+ tmpp=script->skip_space(script->skip_word(p));
if(*tmpp==':' && !(!strncasecmp(p,"default:",8) && p + 7 == tmpp)){
- i=add_word(p);
- set_label(i,script_pos,p);
- if( parse_options&SCRIPT_USE_LABEL_DB )
- script->label_add(i,script_pos);
+ i=script->add_word(p);
+ script->set_label(i,script->pos,p);
+ if( script->parse_options&SCRIPT_USE_LABEL_DB )
+ script->label_add(i,script->pos);
p=tmpp+1;
p=script->skip_space(p);
continue;
}
// All other lumped
- p=parse_line(p);
+ p=script->parse_line(p);
p=script->skip_space(p);
- parse_nextline(false, p);
+ script->parse_nextline(false, p);
}
- add_scriptc(C_NOP);
+ script->addc(C_NOP);
// trim code to size
- script_size = script_pos;
- RECREATE(script_buf,unsigned char,script_pos);
+ script->size = script->pos;
+ RECREATE(script->buf,unsigned char,script->pos);
// default unknown references to variables
for(i=LABEL_START;i<script->str_num;i++){
@@ -2220,8 +2068,8 @@ struct script_code* parse_script(const char *src,const char *file,int line,int o
script->str_data[i].type=C_NAME;
script->str_data[i].label=i;
for(j=script->str_data[i].backpatch;j>=0 && j!=0x00ffffff;){
- next=GETVALUE(script_buf,j);
- SETVALUE(script_buf,j,i);
+ next=GETVALUE(script->buf,j);
+ SETVALUE(script->buf,j,i);
j=next;
}
}
@@ -2237,38 +2085,38 @@ struct script_code* parse_script(const char *src,const char *file,int line,int o
disp_error_message("parse_script: unresolved function references", p);
}
-#ifdef DEBUG_DISP
- for(i=0;i<script_pos;i++){
+#ifdef SCRIPT_DEBUG_DISP
+ for(i=0;i<script->pos;i++){
if((i&15)==0) ShowMessage("%04x : ",i);
- ShowMessage("%02x ",script_buf[i]);
+ ShowMessage("%02x ",script->buf[i]);
if((i&15)==15) ShowMessage("\n");
}
ShowMessage("\n");
#endif
-#ifdef DEBUG_DISASM
+#ifdef SCRIPT_DEBUG_DISASM
{
int i = 0,j;
- while(i < script_pos) {
- c_op op = get_com(script_buf,&i);
+ while(i < script->pos) {
+ c_op op = script->get_com(script->buf,&i);
- ShowMessage("%06x %s", i, script_op2name(op));
+ ShowMessage("%06x %s", i, script->op2name(op));
j = i;
switch(op) {
case C_INT:
- ShowMessage(" %d", get_num(script_buf,&i));
+ ShowMessage(" %d", script->get_num(script->buf,&i));
break;
case C_POS:
- ShowMessage(" 0x%06x", *(int*)(script_buf+i)&0xffffff);
+ ShowMessage(" 0x%06x", *(int*)(script->buf+i)&0xffffff);
i += 3;
break;
case C_NAME:
- j = (*(int*)(script_buf+i)&0xffffff);
+ j = (*(int*)(script->buf+i)&0xffffff);
ShowMessage(" %s", ( j == 0xffffff ) ? "?? unknown ??" : script->get_str(j));
i += 3;
break;
case C_STR:
- j = strlen(script_buf + i);
- ShowMessage(" %s", script_buf + i);
+ j = strlen(script->buf + i);
+ ShowMessage(" %s", script->buf + i);
i += j+1;
break;
}
@@ -2278,8 +2126,8 @@ struct script_code* parse_script(const char *src,const char *file,int line,int o
#endif
CREATE(code,struct script_code,1);
- code->script_buf = script_buf;
- code->script_size = script_size;
+ code->script_buf = script->buf;
+ code->script_size = script->size;
code->script_vars = NULL;
return code;
}
@@ -2290,8 +2138,8 @@ TBL_PC *script_rid2sd(struct script_state *st) {
TBL_PC *sd;
if( !( sd = map->id2sd(st->rid) ) ){
ShowError("script_rid2sd: fatal error ! player not attached!\n");
- script_reportfunc(st);
- script_reportsrc(st);
+ script->reportfunc(st);
+ script->reportsrc(st);
st->state = END;
}
return sd;
@@ -2317,7 +2165,7 @@ void get_val(struct script_state* st, struct script_data* data)
//##TODO use reference_tovariable(data) when it's confirmed that it works [FlavioJS]
if( !reference_toconstant(data) && not_server_variable(prefix) ) {
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL ) {// needs player attached
if( postfix == '$' ) {// string variable
ShowWarning("script_get_val: cannot access player variable '%s', defaulting to \"\"\n", name);
@@ -2446,7 +2294,7 @@ void* get_val2(struct script_state* st, int uid, struct DBMap** ref) {
* Stores the value of a script variable
* Return value is 0 on fail, 1 on success.
*------------------------------------------*/
-static int set_reg(struct script_state* st, TBL_PC* sd, int num, const char* name, const void* value, struct DBMap** ref)
+int set_reg(struct script_state* st, TBL_PC* sd, int num, const char* name, const void* value, struct DBMap** ref)
{
char prefix = name[0];
@@ -2492,7 +2340,7 @@ static int set_reg(struct script_state* st, TBL_PC* sd, int num, const char* nam
if( st != NULL )
{
ShowError("script:set_reg: failed to set param '%s' to %d.\n", name, val);
- script_reportsrc(st);
+ script->reportsrc(st);
st->state = END;
}
return 0;
@@ -2535,12 +2383,12 @@ static int set_reg(struct script_state* st, TBL_PC* sd, int num, const char* nam
int set_var(TBL_PC* sd, char* name, void* val)
{
- return set_reg(NULL, sd, reference_uid(script->add_str(name),0), name, val, NULL);
+ return script->set_reg(NULL, sd, reference_uid(script->add_str(name),0), name, val, NULL);
}
void setd_sub(struct script_state *st, TBL_PC *sd, const char *varname, int elem, void *value, struct DBMap **ref)
{
- set_reg(st, sd, reference_uid(script->add_str(varname),elem), varname, value, ref);
+ script->set_reg(st, sd, reference_uid(script->add_str(varname),elem), varname, value, ref);
}
/// Converts the data to a string
@@ -2569,8 +2417,8 @@ const char* conv_str(struct script_state* st, struct script_data* data)
else
{// unsupported data type
ShowError("script:conv_str: cannot convert to string, defaulting to \"\"\n");
- script_reportdata(data);
- script_reportsrc(st);
+ script->reportdata(data);
+ script->reportsrc(st);
data->type = C_CONSTSTR;
data->u.str = "";
}
@@ -2609,8 +2457,8 @@ int conv_num(struct script_state* st, struct script_data* data) {
num = INT_MAX;
ShowError("script:conv_num: overflow detected, capping to %ld\n", num);
}
- script_reportdata(data);
- script_reportsrc(st);
+ script->reportdata(data);
+ script->reportsrc(st);
}
if( data->type == C_STR )
aFree(p);
@@ -2623,8 +2471,8 @@ int conv_num(struct script_state* st, struct script_data* data) {
else
{// unsupported data type
ShowError("script:conv_num: cannot convert to number, defaulting to 0\n");
- script_reportdata(data);
- script_reportsrc(st);
+ script->reportdata(data);
+ script->reportsrc(st);
data->type = C_INT;
data->u.num = 0;
}
@@ -2648,7 +2496,7 @@ void stack_expand(struct script_stack* stack) {
/// Pushes a value into the stack (with reference)
struct script_data* push_val(struct script_stack* stack, enum c_op type, int val, struct DBMap** ref) {
if( stack->sp >= stack->sp_max )
- stack_expand(stack);
+ script->stack_expand(stack);
stack->stack_data[stack->sp].type = type;
stack->stack_data[stack->sp].u.num = val;
stack->stack_data[stack->sp].ref = ref;
@@ -2660,7 +2508,7 @@ struct script_data* push_val(struct script_stack* stack, enum c_op type, int val
struct script_data* push_str(struct script_stack* stack, enum c_op type, char* str)
{
if( stack->sp >= stack->sp_max )
- stack_expand(stack);
+ script->stack_expand(stack);
stack->stack_data[stack->sp].type = type;
stack->stack_data[stack->sp].u.str = str;
stack->stack_data[stack->sp].ref = NULL;
@@ -2672,7 +2520,7 @@ struct script_data* push_str(struct script_stack* stack, enum c_op type, char* s
struct script_data* push_retinfo(struct script_stack* stack, struct script_retinfo* ri, DBMap **ref)
{
if( stack->sp >= stack->sp_max )
- stack_expand(stack);
+ script->stack_expand(stack);
stack->stack_data[stack->sp].type = C_RETINFO;
stack->stack_data[stack->sp].u.ri = ri;
stack->stack_data[stack->sp].ref = ref;
@@ -2905,8 +2753,8 @@ void op_3(struct script_state* st, int op)
else
{
ShowError("script:op_3: invalid data for the ternary operator test\n");
- script_reportdata(data);
- script_reportsrc(st);
+ script->reportdata(data);
+ script->reportsrc(st);
script_removetop(st, -3, 0);
script_pushnil(st);
return;
@@ -2946,8 +2794,8 @@ void op_2str(struct script_state* st, int op, const char* s1, const char* s2)
return;
}
default:
- ShowError("script:op2_str: unexpected string operator %s\n", script_op2name(op));
- script_reportsrc(st);
+ ShowError("script:op2_str: unexpected string operator %s\n", script->op2name(op));
+ script->reportsrc(st);
script_pushnil(st);
st->state = END;
return;
@@ -2982,8 +2830,8 @@ void op_2num(struct script_state* st, int op, int i1, int i2)
case C_MOD:
if( i2 == 0 )
{
- ShowError("script:op_2num: division by zero detected op=%s i1=%d i2=%d\n", script_op2name(op), i1, i2);
- script_reportsrc(st);
+ ShowError("script:op_2num: division by zero detected op=%s i1=%d i2=%d\n", script->op2name(op), i1, i2);
+ script->reportsrc(st);
script_pushnil(st);
st->state = END;
return;
@@ -3000,21 +2848,21 @@ void op_2num(struct script_state* st, int op, int i1, int i2)
case C_SUB: ret = i1 - i2; ret_double = (double)i1 - (double)i2; break;
case C_MUL: ret = i1 * i2; ret_double = (double)i1 * (double)i2; break;
default:
- ShowError("script:op_2num: unexpected number operator %s i1=%d i2=%d\n", script_op2name(op), i1, i2);
- script_reportsrc(st);
+ ShowError("script:op_2num: unexpected number operator %s i1=%d i2=%d\n", script->op2name(op), i1, i2);
+ script->reportsrc(st);
script_pushnil(st);
return;
}
if( ret_double < (double)INT_MIN )
{
- ShowWarning("script:op_2num: underflow detected op=%s i1=%d i2=%d\n", script_op2name(op), i1, i2);
- script_reportsrc(st);
+ ShowWarning("script:op_2num: underflow detected op=%s i1=%d i2=%d\n", script->op2name(op), i1, i2);
+ script->reportsrc(st);
ret = INT_MIN;
}
else if( ret_double > (double)INT_MAX )
{
- ShowWarning("script:op_2num: overflow detected op=%s i1=%d i2=%d\n", script_op2name(op), i1, i2);
- script_reportsrc(st);
+ ShowWarning("script:op_2num: overflow detected op=%s i1=%d i2=%d\n", script->op2name(op), i1, i2);
+ script->reportsrc(st);
ret = INT_MAX;
}
}
@@ -3060,7 +2908,7 @@ void op_2(struct script_state *st, int op)
if( data_isstring(left) && data_isstring(right) )
{// ss => op_2str
- op_2str(st, op, left->u.str, right->u.str);
+ script->op_2str(st, op, left->u.str, right->u.str);
script_removetop(st, leftref.type == C_NOP ? -3 : -2, -1);// pop the two values before the top one
if (leftref.type != C_NOP)
@@ -3076,17 +2924,17 @@ void op_2(struct script_state *st, int op)
int i2 = right->u.num;
script_removetop(st, leftref.type == C_NOP ? -2 : -1, 0);
- op_2num(st, op, i1, i2);
+ script->op_2num(st, op, i1, i2);
if (leftref.type != C_NOP)
*left = leftref;
}
else
{// invalid argument
- ShowError("script:op_2: invalid data for operator %s\n", script_op2name(op));
- script_reportdata(left);
- script_reportdata(right);
- script_reportsrc(st);
+ ShowError("script:op_2: invalid data for operator %s\n", script->op2name(op));
+ script->reportdata(left);
+ script->reportdata(right);
+ script->reportsrc(st);
script_removetop(st, -2, 0);
script_pushnil(st);
st->state = END;
@@ -3107,9 +2955,9 @@ void op_1(struct script_state* st, int op)
if( !data_isint(data) )
{// not a number
- ShowError("script:op_1: argument is not a number (op=%s)\n", script_op2name(op));
- script_reportdata(data);
- script_reportsrc(st);
+ ShowError("script:op_1: argument is not a number (op=%s)\n", script->op2name(op));
+ script->reportdata(data);
+ script->reportsrc(st);
script_pushnil(st);
st->state = END;
return;
@@ -3123,8 +2971,8 @@ void op_1(struct script_state* st, int op)
case C_NOT: i1 = ~i1; break;
case C_LNOT: i1 = !i1; break;
default:
- ShowError("script:op_1: unexpected operator %s i1=%d\n", script_op2name(op), i1);
- script_reportsrc(st);
+ ShowError("script:op_1: unexpected operator %s i1=%d\n", script->op2name(op), i1);
+ script->reportsrc(st);
script_pushnil(st);
st->state = END;
return;
@@ -3137,7 +2985,7 @@ void op_1(struct script_state* st, int op)
///
/// @param st Script state whose stack arguments should be inspected.
/// @param func Built-in function for which the arguments are intended.
-static void script_check_buildin_argtype(struct script_state* st, int func)
+void script_check_buildin_argtype(struct script_state* st, int func)
{
char type;
int idx, invalid = 0;
@@ -3151,7 +2999,7 @@ static void script_check_buildin_argtype(struct script_state* st, int func)
if( type == '?' || type == '*' ) {// optional argument or unknown number of optional parameters ( no types are after this )
break;
} else if( type == 0 ) {// more arguments than necessary ( should not happen, as it is checked before )
- ShowWarning("Found more arguments than necessary. unexpected arg type %s\n",script_op2name(data->type));
+ ShowWarning("Found more arguments than necessary. unexpected arg type %s\n",script->op2name(data->type));
invalid++;
break;
} else {
@@ -3167,7 +3015,7 @@ static void script_check_buildin_argtype(struct script_state* st, int func)
if( !data_isstring(data) && !data_isint(data) && !data_isreference(data) )
{// variant
ShowWarning("Unexpected type for argument %d. Expected string, number or variable.\n", idx-1);
- script_reportdata(data);
+ script->reportdata(data);
invalid++;
}
break;
@@ -3175,7 +3023,7 @@ static void script_check_buildin_argtype(struct script_state* st, int func)
if( !data_isstring(data) && !( data_isreference(data) && is_string_variable(name) ) )
{// string
ShowWarning("Unexpected type for argument %d. Expected string.\n", idx-1);
- script_reportdata(data);
+ script->reportdata(data);
invalid++;
}
break;
@@ -3183,23 +3031,23 @@ static void script_check_buildin_argtype(struct script_state* st, int func)
if( !data_isint(data) && !( data_isreference(data) && ( reference_toparam(data) || reference_toconstant(data) || !is_string_variable(name) ) ) )
{// int ( params and constants are always int )
ShowWarning("Unexpected type for argument %d. Expected number.\n", idx-1);
- script_reportdata(data);
+ script->reportdata(data);
invalid++;
}
break;
case 'r':
if( !data_isreference(data) )
{// variables
- ShowWarning("Unexpected type for argument %d. Expected variable, got %s.\n", idx-1,script_op2name(data->type));
- script_reportdata(data);
+ ShowWarning("Unexpected type for argument %d. Expected variable, got %s.\n", idx-1,script->op2name(data->type));
+ script->reportdata(data);
invalid++;
}
break;
case 'l':
if( !data_islabel(data) && !data_isfunclabel(data) )
{// label
- ShowWarning("Unexpected type for argument %d. Expected label, got %s\n", idx-1,script_op2name(data->type));
- script_reportdata(data);
+ ShowWarning("Unexpected type for argument %d. Expected label, got %s\n", idx-1,script->op2name(data->type));
+ script->reportdata(data);
invalid++;
}
break;
@@ -3209,7 +3057,7 @@ static void script_check_buildin_argtype(struct script_state* st, int func)
if(invalid) {
ShowDebug("Function: %s\n", script->get_str(func));
- script_reportsrc(st);
+ script->reportsrc(st);
}
}
@@ -3229,7 +3077,7 @@ int run_func(struct script_state *st)
{
ShowError("script:run_func: C_ARG not found. please report this!!!\n");
st->state = END;
- script_reportsrc(st);
+ script->reportsrc(st);
return 1;
}
start_sp = i-1;// C_NAME of the command
@@ -3242,22 +3090,22 @@ int run_func(struct script_state *st)
else
{
ShowError("script:run_func: not a buildin command.\n");
- script_reportdata(data);
- script_reportsrc(st);
+ script->reportdata(data);
+ script->reportsrc(st);
st->state = END;
return 1;
}
if( script->config.warn_func_mismatch_argtypes ) {
- script_check_buildin_argtype(st, func);
+ script->check_buildin_argtype(st, func);
}
if(script->str_data[func].func){
if (!(script->str_data[func].func(st))) //Report error
- script_reportsrc(st);
+ script->reportsrc(st);
} else {
- ShowError("script:run_func: '%s' (id=%d type=%s) has no C function. please report this!!!\n", script->get_str(func), func, script_op2name(script->str_data[func].type));
- script_reportsrc(st);
+ ShowError("script:run_func: '%s' (id=%d type=%s) has no C function. please report this!!!\n", script->get_str(func), func, script->op2name(script->str_data[func].type));
+ script->reportsrc(st);
st->state = END;
}
@@ -3276,7 +3124,7 @@ int run_func(struct script_state *st)
if( st->stack->defsp < 1 || st->stack->stack_data[st->stack->defsp-1].type != C_RETINFO )
{
ShowWarning("script:run_func: return without callfunc or callsub!\n");
- script_reportsrc(st);
+ script->reportsrc(st);
st->state = END;
return 1;
}
@@ -3357,7 +3205,7 @@ int run_script_timer(int tid, unsigned int tick, int id, intptr_t data) {
///
/// @param st Script state to detach.
/// @param dequeue_event Whether to schedule any queued events, when there was no previous script.
-static void script_detach_state(struct script_state* st, bool dequeue_event) {
+void script_detach_state(struct script_state* st, bool dequeue_event) {
struct map_session_data* sd;
if(st->rid && (sd = map->id2sd(st->rid))!=NULL) {
@@ -3385,7 +3233,7 @@ static void script_detach_state(struct script_state* st, bool dequeue_event) {
}
} else if(st->bk_st) { // rid was set to 0, before detaching the script state
ShowError("script_detach_state: Found previous script state without attached player (rid=%d, oid=%d, state=%d, bk_npcid=%d)\n", st->bk_st->rid, st->bk_st->oid, st->bk_st->state, st->bk_npcid);
- script_reportsrc(st->bk_st);
+ script->reportsrc(st->bk_st);
script->free_state(st->bk_st);
st->bk_st = NULL;
@@ -3442,14 +3290,14 @@ void run_script_main(struct script_state *st) {
st->instance_id = -1;
if(st->state == RERUNLINE) {
- run_func(st);
+ script->run_func(st);
if(st->state == GOTO)
st->state = RUN;
} else if(st->state != END)
st->state = RUN;
while( st->state == RUN ){
- enum c_op c = get_com(st->script->script_buf,&st->pos);
+ enum c_op c = script->get_com(st->script->script_buf,&st->pos);
switch(c){
case C_EOL:
if( stack->defsp > stack->sp )
@@ -3458,7 +3306,7 @@ void run_script_main(struct script_state *st) {
script->pop_stack(st, stack->defsp, stack->sp);// pop unused stack data. (unused return value)
break;
case C_INT:
- script->push_val(stack,C_INT,get_num(st->script->script_buf,&st->pos),NULL);
+ script->push_val(stack,C_INT,script->get_num(st->script->script_buf,&st->pos),NULL);
break;
case C_POS:
case C_NAME:
@@ -3473,12 +3321,12 @@ void run_script_main(struct script_state *st) {
while(st->script->script_buf[st->pos++]);
break;
case C_FUNC:
- run_func(st);
+ script->run_func(st);
if(st->state==GOTO){
st->state = RUN;
if( !st->freeloop && gotocount>0 && (--gotocount)<=0 ){
ShowError("run_script: infinity loop !\n");
- script_reportsrc(st);
+ script->reportsrc(st);
st->state=END;
}
}
@@ -3491,7 +3339,7 @@ void run_script_main(struct script_state *st) {
case C_NEG:
case C_NOT:
case C_LNOT:
- op_1(st ,c);
+ script->op_1(st ,c);
break;
case C_ADD:
@@ -3512,11 +3360,11 @@ void run_script_main(struct script_state *st) {
case C_LOR:
case C_R_SHIFT:
case C_L_SHIFT:
- op_2(st, c);
+ script->op_2(st, c);
break;
case C_OP3:
- op_3(st, c);
+ script->op_3(st, c);
break;
case C_NOP:
@@ -3530,14 +3378,14 @@ void run_script_main(struct script_state *st) {
}
if( !st->freeloop && cmdcount>0 && (--cmdcount)<=0 ){
ShowError("run_script: infinity loop !\n");
- script_reportsrc(st);
+ script->reportsrc(st);
st->state=END;
}
}
if(st->sleep.tick > 0) {
//Restore previous script
- script_detach_state(st, false);
+ script->detach_state(st, false);
//Delay execution
sd = map->id2sd(st->rid); // Get sd since script might have attached someone while running. [Inkfish]
st->sleep.charid = sd?sd->status.char_id:0;
@@ -3549,9 +3397,9 @@ void run_script_main(struct script_state *st) {
ShowWarning("Unable to restore stack! Double continuation!\n");
//Report BOTH scripts to see if that can help somehow.
ShowDebug("Previous script (lost):\n");
- script_reportsrc(st->bk_st);
+ script->reportsrc(st->bk_st);
ShowDebug("Current script:\n");
- script_reportsrc(st);
+ script->reportsrc(st);
script->free_state(st->bk_st);
st->bk_st = NULL;
@@ -3564,7 +3412,7 @@ void run_script_main(struct script_state *st) {
sd->state.using_fake_npc = 0;
}
//Restore previous script if any.
- script_detach_state(st, true);
+ script->detach_state(st, true);
if (sd->state.reg_dirty&2)
intif->saveregistry(sd,2);
if (sd->state.reg_dirty&1)
@@ -3625,7 +3473,7 @@ int script_config_read(char *cfgName) {
/**
* @see DBApply
*/
-static int db_script_free_code_sub(DBKey key, DBData *data, va_list ap)
+int db_script_free_code_sub(DBKey key, DBData *data, va_list ap)
{
struct script_code *code = DB->data2ptr(data);
if (code)
@@ -3727,7 +3575,7 @@ void do_final_script(void) {
DBIterator *iter;
struct script_state *st;
-#ifdef DEBUG_HASH
+#ifdef SCRIPT_DEBUG_HASH
if (battle_config.etc_log)
{
FILE *fp = fopen("hash_dump.txt","wt");
@@ -3744,7 +3592,7 @@ void do_final_script(void) {
fprintf(fp,"num : hash : data_name\n");
fprintf(fp,"---------------------------------------------------------------\n");
for(i=LABEL_START; i<script->str_num; i++) {
- unsigned int h = calc_hash(script->get_str(i));
+ unsigned int h = script->calc_hash(script->get_str(i));
fprintf(fp,"%04d : %4u : %s\n",i,h, script->get_str(i));
++count[h];
}
@@ -3792,8 +3640,8 @@ void do_final_script(void) {
mapreg->final();
- script->userfunc_db->destroy(script->userfunc_db, db_script_free_code_sub);
- script->autobonus_db->destroy(script->autobonus_db, db_script_free_code_sub);
+ script->userfunc_db->destroy(script->userfunc_db, script->db_free_code_sub);
+ script->autobonus_db->destroy(script->autobonus_db, script->db_free_code_sub);
if (script->str_data)
aFree(script->str_data);
@@ -3858,7 +3706,7 @@ void do_init_script(void) {
ers_chunk_size(script->stack_ers, 10);
script->parse_builtin();
- read_constdb();
+ script->read_constdb();
mapreg->init();
}
@@ -3875,7 +3723,7 @@ int script_reload(void) {
dbi_destroy(iter);
- script->userfunc_db->clear(script->userfunc_db, db_script_free_code_sub);
+ script->userfunc_db->clear(script->userfunc_db, script->db_free_code_sub);
script->label_count = 0;
for( i = 0; i < atcommand->binding_count; i++ ) {
@@ -3912,7 +3760,7 @@ int script_reload(void) {
///
/// mes "<message>";
BUILDIN(mes) {
- TBL_PC* sd = script_rid2sd(st);
+ TBL_PC* sd = script->rid2sd(st);
if( sd == NULL )
return true;
@@ -3938,7 +3786,7 @@ BUILDIN(next)
{
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
#ifdef SECURE_NPCTIMEOUT
@@ -3956,7 +3804,7 @@ BUILDIN(next)
BUILDIN(close) {
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
@@ -3972,7 +3820,7 @@ BUILDIN(close) {
BUILDIN(close2) {
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
@@ -3980,7 +3828,7 @@ BUILDIN(close2) {
st->state = STOP;
else {
ShowWarning("misuse of 'close2'! trying to use it without prior dialog! skipping...\n");
- script_reportsrc(st);
+ script->reportsrc(st);
}
clif->scriptclose(sd, st->oid);
@@ -3990,7 +3838,7 @@ BUILDIN(close2) {
/// Counts the number of valid and total number of options in 'str'
/// If max_count > 0 the counting stops when that valid option is reached
/// total is incremented for each option (NULL is supported)
-static int menu_countoptions(const char* str, int max_count, int* total)
+int menu_countoptions(const char* str, int max_count, int* total)
{
int count = 0;
int bogus_total;
@@ -4045,7 +3893,7 @@ BUILDIN(menu)
const char* text;
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
@@ -4079,7 +3927,7 @@ BUILDIN(menu)
{// not a label
StrBuf->Destroy(&buf);
ShowError("script:menu: argument #%d (from 1) is not a label or label not found.\n", i);
- script_reportdata(data);
+ script->reportdata(data);
st->state = END;
return false;
}
@@ -4090,7 +3938,7 @@ BUILDIN(menu)
if( sd->npc_menu > 0 )
StrBuf->AppendStr(&buf, ":");
StrBuf->AppendStr(&buf, text);
- sd->npc_menu += menu_countoptions(text, 0, NULL);
+ sd->npc_menu += script->menu_countoptions(text, 0, NULL);
}
st->state = RERUNLINE;
sd->state.menu_or_input = 1;
@@ -4114,7 +3962,7 @@ BUILDIN(menu)
if( sd->npc_menu >= 0xff )
{// client supports only up to 254 entries; 0 is not used and 255 is reserved for cancel; excess entries are displayed but cause 'uint8' overflow
ShowWarning("buildin_menu: Too many options specified (current=%d, max=254).\n", sd->npc_menu);
- script_reportsrc(st);
+ script->reportsrc(st);
}
}
else if( sd->npc_menu == 0xff )
@@ -4138,7 +3986,7 @@ BUILDIN(menu)
for( i = 2; i < script_lastdata(st); i += 2 )
{
text = script_getstr(st, i);
- sd->npc_menu -= menu_countoptions(text, sd->npc_menu, &menu);
+ sd->npc_menu -= script->menu_countoptions(text, sd->npc_menu, &menu);
if( sd->npc_menu <= 0 )
break;// entry found
}
@@ -4151,7 +3999,7 @@ BUILDIN(menu)
if( !data_islabel(script_getdata(st, i + 1)) )
{// TODO remove this temporary crash-prevention code (fallback for multiple scripts requesting user input)
ShowError("script:menu: unexpected data in label argument\n");
- script_reportdata(script_getdata(st, i + 1));
+ script->reportdata(script_getdata(st, i + 1));
st->state = END;
return false;
}
@@ -4174,7 +4022,7 @@ BUILDIN(select)
const char* text;
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
@@ -4194,7 +4042,7 @@ BUILDIN(select)
StrBuf->AppendStr(&buf, ":");
StrBuf->AppendStr(&buf, text);
- sd->npc_menu += menu_countoptions(text, 0, NULL);
+ sd->npc_menu += script->menu_countoptions(text, 0, NULL);
}
st->state = RERUNLINE;
@@ -4217,7 +4065,7 @@ BUILDIN(select)
if( sd->npc_menu >= 0xff ) {
ShowWarning("buildin_select: Too many options specified (current=%d, max=254).\n", sd->npc_menu);
- script_reportsrc(st);
+ script->reportsrc(st);
}
} else if( sd->npc_menu == 0xff ) {// Cancel was pressed
sd->state.menu_or_input = 0;
@@ -4228,7 +4076,7 @@ BUILDIN(select)
sd->state.menu_or_input = 0;
for( i = 2; i <= script_lastdata(st); ++i ) {
text = script_getstr(st, i);
- sd->npc_menu -= menu_countoptions(text, sd->npc_menu, &menu);
+ sd->npc_menu -= script->menu_countoptions(text, sd->npc_menu, &menu);
if( sd->npc_menu <= 0 )
break;// entry found
}
@@ -4253,7 +4101,7 @@ BUILDIN(prompt)
const char *text;
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
@@ -4273,7 +4121,7 @@ BUILDIN(prompt)
if( sd->npc_menu > 0 )
StrBuf->AppendStr(&buf, ":");
StrBuf->AppendStr(&buf, text);
- sd->npc_menu += menu_countoptions(text, 0, NULL);
+ sd->npc_menu += script->menu_countoptions(text, 0, NULL);
}
st->state = RERUNLINE;
@@ -4297,7 +4145,7 @@ BUILDIN(prompt)
if( sd->npc_menu >= 0xff )
{
ShowWarning("buildin_prompt: Too many options specified (current=%d, max=254).\n", sd->npc_menu);
- script_reportsrc(st);
+ script->reportsrc(st);
}
}
else if( sd->npc_menu == 0xff )
@@ -4315,7 +4163,7 @@ BUILDIN(prompt)
for( i = 2; i <= script_lastdata(st); ++i )
{
text = script_getstr(st, i);
- sd->npc_menu -= menu_countoptions(text, sd->npc_menu, &menu);
+ sd->npc_menu -= script->menu_countoptions(text, sd->npc_menu, &menu);
if( sd->npc_menu <= 0 )
break;// entry found
}
@@ -4338,7 +4186,7 @@ BUILDIN(goto)
if( !data_islabel(script_getdata(st,2)) )
{
ShowError("script:goto: not a label\n");
- script_reportdata(script_getdata(st,2));
+ script->reportdata(script_getdata(st,2));
st->state = END;
return false;
}
@@ -4389,7 +4237,7 @@ BUILDIN(callfunc)
ri->pos = st->pos;// script location
ri->nargs = j;// argument count
ri->defsp = st->stack->defsp;// default stack pointer
- push_retinfo(st->stack, ri, ref);
+ script->push_retinfo(st->stack, ri, ref);
st->pos = 0;
st->script = scr;
@@ -4412,7 +4260,7 @@ BUILDIN(callsub)
if( !data_islabel(script_getdata(st,2)) && !data_isfunclabel(script_getdata(st,2)) )
{
ShowError("script:callsub: argument is not a label\n");
- script_reportdata(script_getdata(st,2));
+ script->reportdata(script_getdata(st,2));
st->state = END;
return false;
}
@@ -4439,7 +4287,7 @@ BUILDIN(callsub)
ri->pos = st->pos;// script location
ri->nargs = j;// argument count
ri->defsp = st->stack->defsp;// default stack pointer
- push_retinfo(st->stack, ri, ref);
+ script->push_retinfo(st->stack, ri, ref);
st->pos = pos;
st->stack->defsp = st->stack->sp;
@@ -4558,7 +4406,7 @@ BUILDIN(warp)
const char* str;
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
@@ -4575,7 +4423,7 @@ BUILDIN(warp)
if( ret ) {
ShowError("buildin_warp: moving player '%s' to \"%s\",%d,%d failed.\n", sd->status.name, str, x, y);
- script_reportsrc(st);
+ script->reportsrc(st);
}
return true;
@@ -4583,7 +4431,7 @@ BUILDIN(warp)
/*==========================================
* Warp a specified area
*------------------------------------------*/
-static int buildin_areawarp_sub(struct block_list *bl,va_list ap)
+int buildin_areawarp_sub(struct block_list *bl,va_list ap)
{
int x2,y2,x3,y3;
unsigned int index;
@@ -4651,14 +4499,14 @@ BUILDIN(areawarp)
else if( !(index=mapindex_name2id(str)) )
return true;
- map->foreachinarea(buildin_areawarp_sub, m,x0,y0,x1,y1, BL_PC, index,x2,y2,x3,y3);
+ map->foreachinarea(script->buildin_areawarp_sub, m,x0,y0,x1,y1, BL_PC, index,x2,y2,x3,y3);
return true;
}
/*==========================================
* areapercentheal <map>,<x1>,<y1>,<x2>,<y2>,<hp>,<sp>
*------------------------------------------*/
-static int buildin_areapercentheal_sub(struct block_list *bl,va_list ap)
+int buildin_areapercentheal_sub(struct block_list *bl,va_list ap)
{
int hp, sp;
hp = va_arg(ap, int);
@@ -4682,7 +4530,7 @@ BUILDIN(areapercentheal) {
if( (m=map->mapname2mapid(mapname))< 0)
return true;
- map->foreachinarea(buildin_areapercentheal_sub,m,x0,y0,x1,y1,BL_PC,hp,sp);
+ map->foreachinarea(script->buildin_areapercentheal_sub,m,x0,y0,x1,y1,BL_PC,hp,sp);
return true;
}
@@ -4764,7 +4612,7 @@ BUILDIN(warpparty)
break;
case 2:
//"SavePoint" uses save point of the currently attached player
- if (( sd = script_rid2sd(st) ) == NULL )
+ if (( sd = script->rid2sd(st) ) == NULL )
return true;
default:
mapindex = 0;
@@ -4831,7 +4679,7 @@ BUILDIN(warpguild)
: ( strcmp(str,"SavePoint")==0 ) ? 2
: 3;
- if( type == 2 && ( sd = script_rid2sd(st) ) == NULL )
+ if( type == 2 && ( sd = script->rid2sd(st) ) == NULL )
{// "SavePoint" uses save point of the currently attached player
return true;
}
@@ -4873,7 +4721,7 @@ BUILDIN(heal) {
TBL_PC *sd;
int hp,sp;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if (!sd) return true;
hp=script_getnum(st,2);
@@ -4898,7 +4746,7 @@ BUILDIN(itemheal)
return true;
}
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if (!sd) return true;
pc->itemheal(sd,sd->itemid,hp,sp);
return true;
@@ -4920,7 +4768,7 @@ BUILDIN(percentheal)
return true;
}
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
#ifdef RENEWAL
@@ -4946,7 +4794,7 @@ BUILDIN(jobchange)
{
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
@@ -4982,14 +4830,14 @@ BUILDIN(input)
int min;
int max;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
data = script_getdata(st,2);
if( !data_isreference(data) ){
ShowError("script:input: not a variable\n");
- script_reportdata(data);
+ script->reportdata(data);
st->state = END;
return false;
}
@@ -5017,13 +4865,13 @@ BUILDIN(input)
if( is_string_variable(name) )
{
int len = (int)strlen(sd->npc_str);
- set_reg(st, sd, uid, name, (void*)sd->npc_str, script_getref(st,2));
+ script->set_reg(st, sd, uid, name, (void*)sd->npc_str, script_getref(st,2));
script_pushint(st, (len > max ? 1 : len < min ? -1 : 0));
}
else
{
int amount = sd->npc_amount;
- set_reg(st, sd, uid, name, (void*)__64BPTRSIZE(cap_value(amount,min,max)), script_getref(st,2));
+ script->set_reg(st, sd, uid, name, (void*)__64BPTRSIZE(cap_value(amount,min,max)), script_getref(st,2));
script_pushint(st, (amount > max ? 1 : amount < min ? -1 : 0));
}
st->state = RUN;
@@ -5052,7 +4900,7 @@ BUILDIN(set)
if( !data_isreference(data) )
{
ShowError("script:set: not a variable\n");
- script_reportdata(script_getdata(st,2));
+ script->reportdata(script_getdata(st,2));
st->state = END;
return false;
}
@@ -5063,7 +4911,7 @@ BUILDIN(set)
if( not_server_variable(prefix) )
{
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
{
ShowError("script:set: no player attached for player variable '%s'\n", name);
@@ -5078,7 +4926,7 @@ BUILDIN(set)
if( !not_array_variable(*namevalue) )
{// array variable being copied into another array variable
- if( sd == NULL && not_server_variable(*namevalue) && !(sd = script_rid2sd(st)) )
+ if( sd == NULL && not_server_variable(*namevalue) && !(sd = script->rid2sd(st)) )
{// player must be attached in order to copy a player variable
ShowError("script:set: no player attached for player variable '%s'\n", namevalue);
return true;
@@ -5100,9 +4948,9 @@ BUILDIN(set)
#endif
if( is_string_variable(name) )
- set_reg(st,sd,num,name,(void*)script_getstr(st,3),script_getref(st,2));
+ script->set_reg(st,sd,num,name,(void*)script_getstr(st,3),script_getref(st,2));
else
- set_reg(st,sd,num,name,(void*)__64BPTRSIZE(script_getnum(st,3)),script_getref(st,2));
+ script->set_reg(st,sd,num,name,(void*)__64BPTRSIZE(script_getnum(st,3)),script_getref(st,2));
// return a copy of the variable reference
script_pushcopy(st,2);
@@ -5115,7 +4963,7 @@ BUILDIN(set)
///
/// Returns the size of the specified array
-static int32 getarraysize(struct script_state* st, int32 id, int32 idx, int isstring, struct DBMap** ref)
+int32 getarraysize(struct script_state* st, int32 id, int32 idx, int isstring, struct DBMap** ref)
{
int32 ret = idx;
@@ -5160,7 +5008,7 @@ BUILDIN(setarray)
if( !data_isreference(data) )
{
ShowError("script:setarray: not a variable\n");
- script_reportdata(data);
+ script->reportdata(data);
st->state = END;
return false;// not a variable
}
@@ -5171,14 +5019,14 @@ BUILDIN(setarray)
if( not_array_variable(*name) )
{
ShowError("script:setarray: illegal scope\n");
- script_reportdata(data);
+ script->reportdata(data);
st->state = END;
return false;// not supported
}
if( not_server_variable(*name) )
{
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;// no player attached
}
@@ -5190,12 +5038,12 @@ BUILDIN(setarray)
if( is_string_variable(name) )
{// string array
for( i = 3; start < end; ++start, ++i )
- set_reg(st, sd, reference_uid(id, start), name, (void*)script_getstr(st,i), reference_getref(data));
+ script->set_reg(st, sd, reference_uid(id, start), name, (void*)script_getstr(st,i), reference_getref(data));
}
else
{// int array
for( i = 3; start < end; ++start, ++i )
- set_reg(st, sd, reference_uid(id, start), name, (void*)__64BPTRSIZE(script_getnum(st,i)), reference_getref(data));
+ script->set_reg(st, sd, reference_uid(id, start), name, (void*)__64BPTRSIZE(script_getnum(st,i)), reference_getref(data));
}
return true;
}
@@ -5218,7 +5066,7 @@ BUILDIN(cleararray)
if( !data_isreference(data) )
{
ShowError("script:cleararray: not a variable\n");
- script_reportdata(data);
+ script->reportdata(data);
st->state = END;
return false;// not a variable
}
@@ -5229,14 +5077,14 @@ BUILDIN(cleararray)
if( not_array_variable(*name) )
{
ShowError("script:cleararray: illegal scope\n");
- script_reportdata(data);
+ script->reportdata(data);
st->state = END;
return false;// not supported
}
if( not_server_variable(*name) )
{
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;// no player attached
}
@@ -5251,7 +5099,7 @@ BUILDIN(cleararray)
end = SCRIPT_MAX_ARRAYSIZE;
for( ; start < end; ++start )
- set_reg(st, sd, reference_uid(id, start), name, v, script_getref(st,2));
+ script->set_reg(st, sd, reference_uid(id, start), name, v, script_getref(st,2));
return true;
}
@@ -5279,8 +5127,8 @@ BUILDIN(copyarray)
if( !data_isreference(data1) || !data_isreference(data2) )
{
ShowError("script:copyarray: not a variable\n");
- script_reportdata(data1);
- script_reportdata(data2);
+ script->reportdata(data1);
+ script->reportdata(data2);
st->state = END;
return false;// not a variable
}
@@ -5294,8 +5142,8 @@ BUILDIN(copyarray)
if( not_array_variable(*name1) || not_array_variable(*name2) )
{
ShowError("script:copyarray: illegal scope\n");
- script_reportdata(data1);
- script_reportdata(data2);
+ script->reportdata(data1);
+ script->reportdata(data2);
st->state = END;
return false;// not supported
}
@@ -5303,15 +5151,15 @@ BUILDIN(copyarray)
if( is_string_variable(name1) != is_string_variable(name2) )
{
ShowError("script:copyarray: type mismatch\n");
- script_reportdata(data1);
- script_reportdata(data2);
+ script->reportdata(data1);
+ script->reportdata(data2);
st->state = END;
return false;// data type mismatch
}
if( not_server_variable(*name1) || not_server_variable(*name2) )
{
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;// no player attached
}
@@ -5327,7 +5175,7 @@ BUILDIN(copyarray)
for( i = count - 1; i >= 0; --i )
{
v = script->get_val2(st, reference_uid(id2, idx2 + i), reference_getref(data2));
- set_reg(st, sd, reference_uid(id1, idx1 + i), name1, v, reference_getref(data1));
+ script->set_reg(st, sd, reference_uid(id1, idx1 + i), name1, v, reference_getref(data1));
script_removetop(st, -1, 0);
}
}
@@ -5338,11 +5186,11 @@ BUILDIN(copyarray)
if( idx2 + i < SCRIPT_MAX_ARRAYSIZE )
{
v = script->get_val2(st, reference_uid(id2, idx2 + i), reference_getref(data2));
- set_reg(st, sd, reference_uid(id1, idx1 + i), name1, v, reference_getref(data1));
+ script->set_reg(st, sd, reference_uid(id1, idx1 + i), name1, v, reference_getref(data1));
script_removetop(st, -1, 0);
}
else// out of range - assume ""/0
- set_reg(st, sd, reference_uid(id1, idx1 + i), name1, (is_string_variable(name1)?(void*)"":(void*)0), reference_getref(data1));
+ script->set_reg(st, sd, reference_uid(id1, idx1 + i), name1, (is_string_variable(name1)?(void*)"":(void*)0), reference_getref(data1));
}
}
return true;
@@ -5362,7 +5210,7 @@ BUILDIN(getarraysize)
if( !data_isreference(data) )
{
ShowError("script:getarraysize: not a variable\n");
- script_reportdata(data);
+ script->reportdata(data);
script_pushnil(st);
st->state = END;
return false;// not a variable
@@ -5372,13 +5220,13 @@ BUILDIN(getarraysize)
if( not_array_variable(*name) )
{
ShowError("script:getarraysize: illegal scope\n");
- script_reportdata(data);
+ script->reportdata(data);
script_pushnil(st);
st->state = END;
return false;// not supported
}
- script_pushint(st, getarraysize(st, reference_getid(data), reference_getindex(data), is_string_variable(name), reference_getref(data)));
+ script_pushint(st, script->getarraysize(st, reference_getid(data), reference_getindex(data), is_string_variable(name), reference_getref(data)));
return true;
}
@@ -5400,7 +5248,7 @@ BUILDIN(deletearray)
if( !data_isreference(data) )
{
ShowError("script:deletearray: not a variable\n");
- script_reportdata(data);
+ script->reportdata(data);
st->state = END;
return false;// not a variable
}
@@ -5411,14 +5259,14 @@ BUILDIN(deletearray)
if( not_array_variable(*name) )
{
ShowError("script:deletearray: illegal scope\n");
- script_reportdata(data);
+ script->reportdata(data);
st->state = END;
return false;// not supported
}
if( not_server_variable(*name) )
{
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;// no player attached
}
@@ -5440,7 +5288,7 @@ BUILDIN(deletearray)
for( ; start + count < end; ++start )
{
void* v = script->get_val2(st, reference_uid(id, start + count), reference_getref(data));
- set_reg(st, sd, reference_uid(id, start), name, v, reference_getref(data));
+ script->set_reg(st, sd, reference_uid(id, start), name, v, reference_getref(data));
script_removetop(st, -1, 0);
}
}
@@ -5449,12 +5297,12 @@ BUILDIN(deletearray)
if( is_string_variable(name) )
{
for( ; start < end; ++start )
- set_reg(st, sd, reference_uid(id, start), name, (void *)"", reference_getref(data));
+ script->set_reg(st, sd, reference_uid(id, start), name, (void *)"", reference_getref(data));
}
else
{
for( ; start < end; ++start )
- set_reg(st, sd, reference_uid(id, start), name, (void*)0, reference_getref(data));
+ script->set_reg(st, sd, reference_uid(id, start), name, (void*)0, reference_getref(data));
}
return true;
}
@@ -5474,7 +5322,7 @@ BUILDIN(getelementofarray)
if( !data_isreference(data) )
{
ShowError("script:getelementofarray: not a variable\n");
- script_reportdata(data);
+ script->reportdata(data);
script_pushnil(st);
st->state = END;
return false;// not a variable
@@ -5485,7 +5333,7 @@ BUILDIN(getelementofarray)
if( not_array_variable(*name) )
{
ShowError("script:getelementofarray: illegal scope\n");
- script_reportdata(data);
+ script->reportdata(data);
script_pushnil(st);
st->state = END;
return false;// not supported
@@ -5495,7 +5343,7 @@ BUILDIN(getelementofarray)
if( i < 0 || i >= SCRIPT_MAX_ARRAYSIZE )
{
ShowWarning("script:getelementofarray: index out of range (%d)\n", i);
- script_reportdata(data);
+ script->reportdata(data);
script_pushnil(st);
st->state = END;
return false;// out of range
@@ -5520,7 +5368,7 @@ BUILDIN(setlook)
type=script_getnum(st,2);
val=script_getnum(st,3);
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
@@ -5537,7 +5385,7 @@ BUILDIN(changelook)
type=script_getnum(st,2);
val=script_getnum(st,3);
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
@@ -5553,7 +5401,7 @@ BUILDIN(cutin)
{
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
@@ -5575,7 +5423,7 @@ BUILDIN(viewpoint)
id=script_getnum(st,5);
color=script_getnum(st,6);
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
@@ -5594,7 +5442,7 @@ BUILDIN(countitem)
struct item_data* id = NULL;
struct script_data* data;
- TBL_PC* sd = script_rid2sd(st);
+ TBL_PC* sd = script->rid2sd(st);
if (!sd) {
script_pushint(st,0);
return true;
@@ -5641,7 +5489,7 @@ BUILDIN(countitem2)
struct item_data* id = NULL;
struct script_data* data;
- TBL_PC* sd = script_rid2sd(st);
+ TBL_PC* sd = script->rid2sd(st);
if (!sd) {
script_pushint(st,0);
return true;
@@ -5704,7 +5552,7 @@ BUILDIN(checkweight)
struct map_session_data* sd;
struct script_data* data;
- if( ( sd = script_rid2sd(st) ) == NULL ){
+ if( ( sd = script->rid2sd(st) ) == NULL ){
return true;
}
nbargs = script_lastdata(st)+1;
@@ -5790,7 +5638,7 @@ BUILDIN(checkweight2)
int32 idx_it, idx_nb;
int nb_it, nb_nb; //array size
- TBL_PC *sd = script_rid2sd(st);
+ TBL_PC *sd = script->rid2sd(st);
nullpo_retr(1,sd);
data_it = script_getdata(st, 2);
@@ -5820,8 +5668,8 @@ BUILDIN(checkweight2)
script_pushint(st,0);
return false;// not supported
}
- nb_it = getarraysize(st, id_it, idx_it, 0, reference_getref(data_it));
- nb_nb = getarraysize(st, id_nb, idx_nb, 0, reference_getref(data_nb));
+ nb_it = script->getarraysize(st, id_it, idx_it, 0, reference_getref(data_it));
+ nb_nb = script->getarraysize(st, id_nb, idx_nb, 0, reference_getref(data_nb));
if(nb_it != nb_nb){
ShowError("Size mistmatch: nb_it=%d, nb_nb=%d\n",nb_it,nb_nb);
fail = 1;
@@ -5928,7 +5776,7 @@ BUILDIN(getitem)
if( script_hasdata(st,4) )
sd=map->id2sd(script_getnum(st,4)); // <Account ID>
else
- sd=script_rid2sd(st); // Attached player
+ sd=script->rid2sd(st); // Attached player
if( sd == NULL ) // no target
return true;
@@ -5968,7 +5816,7 @@ BUILDIN(getitem2)
if( script_hasdata(st,11) )
sd=map->id2sd(script_getnum(st,11)); // <Account ID>
else
- sd=script_rid2sd(st); // Attached player
+ sd=script->rid2sd(st); // Attached player
if( sd == NULL ) // no target
return true;
@@ -6064,7 +5912,7 @@ BUILDIN(rentitem)
data = script_getdata(st,2);
script->get_val(st,data);
- if( (sd = script_rid2sd(st)) == NULL )
+ if( (sd = script->rid2sd(st)) == NULL )
return true;
if( data_isstring(data) )
@@ -6121,7 +5969,7 @@ BUILDIN(getnameditem)
TBL_PC *sd, *tsd;
struct script_data *data;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if (sd == NULL)
{ //Player not attached!
script_pushint(st,0);
@@ -6242,7 +6090,7 @@ BUILDIN(makeitem)
if(strcmp(mapname,"this")==0) {
TBL_PC *sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if (!sd) return true; //Failed...
m=sd->bl.m;
} else
@@ -6270,7 +6118,7 @@ BUILDIN(makeitem)
/// Counts / deletes the current item given by idx.
/// Used by buildin_delitem_search
/// Relies on all input data being already fully valid.
-static void buildin_delitem_delete(struct map_session_data* sd, int idx, int* amount, bool delete_items)
+void buildin_delitem_delete(struct map_session_data* sd, int idx, int* amount, bool delete_items)
{
int delamount;
struct item* inv = &sd->status.inventory[idx];
@@ -6295,7 +6143,7 @@ static void buildin_delitem_delete(struct map_session_data* sd, int idx, int* am
/// Relies on all input data being already fully valid.
/// @param exact_match will also match item attributes and cards, not just name id
/// @return true when all items could be deleted, false when there were not enough items to delete
-static bool buildin_delitem_search(struct map_session_data* sd, struct item* it, bool exact_match)
+bool buildin_delitem_search(struct map_session_data* sd, struct item* it, bool exact_match)
{
bool delete_items = false;
int i, amount, important;
@@ -6358,7 +6206,7 @@ static bool buildin_delitem_search(struct map_session_data* sd, struct item* it,
}
// count / delete item
- buildin_delitem_delete(sd, i, &amount, delete_items);
+ script->buildin_delitem_delete(sd, i, &amount, delete_items);
}
// 2nd pass -- any matching item
@@ -6389,7 +6237,7 @@ static bool buildin_delitem_search(struct map_session_data* sd, struct item* it,
}
// count / delete item
- buildin_delitem_delete(sd, i, &amount, delete_items);
+ script->buildin_delitem_delete(sd, i, &amount, delete_items);
}
if( amount )
@@ -6432,7 +6280,7 @@ BUILDIN(delitem)
}
else
{
- sd = script_rid2sd(st);// attached player
+ sd = script->rid2sd(st);// attached player
if( sd == NULL )
return true;
}
@@ -6467,7 +6315,7 @@ BUILDIN(delitem)
if( it.amount <= 0 )
return true;// nothing to do
- if( buildin_delitem_search(sd, &it, false) )
+ if( script->buildin_delitem_search(sd, &it, false) )
{// success
return true;
}
@@ -6498,7 +6346,7 @@ BUILDIN(delitem2) {
}
else
{
- sd = script_rid2sd(st);// attached player
+ sd = script->rid2sd(st);// attached player
if( sd == NULL )
return true;
}
@@ -6540,7 +6388,7 @@ BUILDIN(delitem2) {
if( it.amount <= 0 )
return true;// nothing to do
- if( buildin_delitem_search(sd, &it, true) )
+ if( script->buildin_delitem_search(sd, &it, true) )
{// success
return true;
}
@@ -6557,7 +6405,7 @@ BUILDIN(delitem2) {
BUILDIN(enableitemuse)
{
TBL_PC *sd;
- sd=script_rid2sd(st);
+ sd=script->rid2sd(st);
if (sd)
st->npc_item_flag = sd->npc_item_flag = 1;
return true;
@@ -6566,7 +6414,7 @@ BUILDIN(enableitemuse)
BUILDIN(disableitemuse)
{
TBL_PC *sd;
- sd=script_rid2sd(st);
+ sd=script->rid2sd(st);
if (sd)
st->npc_item_flag = sd->npc_item_flag = 0;
return true;
@@ -6584,7 +6432,7 @@ BUILDIN(readparam) {
if( script_hasdata(st,3) )
sd=map->nick2sd(script_getstr(st,3));
else
- sd=script_rid2sd(st);
+ sd=script->rid2sd(st);
if(sd==NULL){
script_pushint(st,-1);
@@ -6613,7 +6461,7 @@ BUILDIN(getcharid) {
if( script_hasdata(st,3) )
sd=map->nick2sd(script_getstr(st,3));
else
- sd=script_rid2sd(st);
+ sd=script->rid2sd(st);
if(sd==NULL){
script_pushint(st,0); //return 0, according docs
@@ -6842,7 +6690,7 @@ BUILDIN(strcharinfo)
struct guild* g;
struct party_data* p;
- sd=script_rid2sd(st);
+ sd=script->rid2sd(st);
if (!sd) { //Avoid crashing....
script_pushconststr(st,"");
return true;
@@ -6931,10 +6779,6 @@ BUILDIN(strnpcinfo) {
return true;
}
-
-// aegis->athena slot position conversion table
-static unsigned int equip[] = {EQP_HEAD_TOP,EQP_ARMOR,EQP_HAND_L,EQP_HAND_R,EQP_GARMENT,EQP_SHOES,EQP_ACC_L,EQP_ACC_R,EQP_HEAD_MID,EQP_HEAD_LOW,EQP_COSTUME_HEAD_LOW,EQP_COSTUME_HEAD_MID,EQP_COSTUME_HEAD_TOP,EQP_COSTUME_GARMENT};
-
/*==========================================
* GetEquipID(Pos); Pos: 1-10
*------------------------------------------*/
@@ -6944,19 +6788,19 @@ BUILDIN(getequipid)
TBL_PC* sd;
struct item_data* item;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
num = script_getnum(st,2) - 1;
- if( num < 0 || num >= ARRAYLENGTH(equip) )
+ if( num < 0 || num >= ARRAYLENGTH(script->equip) )
{
script_pushint(st,-1);
return true;
}
// get inventory position of item
- i = pc->checkequip(sd,equip[num]);
+ i = pc->checkequip(sd,script->equip[num]);
if( i < 0 )
{
script_pushint(st,-1);
@@ -6982,19 +6826,19 @@ BUILDIN(getequipname)
TBL_PC* sd;
struct item_data* item;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
num = script_getnum(st,2) - 1;
- if( num < 0 || num >= ARRAYLENGTH(equip) )
+ if( num < 0 || num >= ARRAYLENGTH(script->equip) )
{
script_pushconststr(st,"");
return true;
}
// get inventory position of item
- i = pc->checkequip(sd,equip[num]);
+ i = pc->checkequip(sd,script->equip[num]);
if( i < 0 )
{
script_pushconststr(st,"");
@@ -7018,7 +6862,7 @@ BUILDIN(getbrokenid)
int i,num,id=0,brokencounter=0;
TBL_PC *sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
@@ -7047,7 +6891,7 @@ BUILDIN(repair)
int repaircounter=0;
TBL_PC *sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
@@ -7076,7 +6920,7 @@ BUILDIN(repairall)
int i, repaircounter = 0;
TBL_PC *sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if(sd == NULL)
return true;
@@ -7108,12 +6952,12 @@ BUILDIN(getequipisequiped)
TBL_PC *sd;
num = script_getnum(st,2);
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
- if (num > 0 && num <= ARRAYLENGTH(equip))
- i=pc->checkequip(sd,equip[num-1]);
+ if (num > 0 && num <= ARRAYLENGTH(script->equip))
+ i=pc->checkequip(sd,script->equip[num-1]);
if(i >= 0)
script_pushint(st,1);
@@ -7135,12 +6979,12 @@ BUILDIN(getequipisenableref)
TBL_PC *sd;
num = script_getnum(st,2);
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
- if( num > 0 && num <= ARRAYLENGTH(equip) )
- i = pc->checkequip(sd,equip[num-1]);
+ if( num > 0 && num <= ARRAYLENGTH(script->equip) )
+ i = pc->checkequip(sd,script->equip[num-1]);
if( i >= 0 && sd->inventory_data[i] && !sd->inventory_data[i]->flag.no_refine && !sd->status.inventory[i].expire_time )
script_pushint(st,1);
else
@@ -7161,12 +7005,12 @@ BUILDIN(getequipisidentify)
TBL_PC *sd;
num = script_getnum(st,2);
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
- if (num > 0 && num <= ARRAYLENGTH(equip))
- i=pc->checkequip(sd,equip[num-1]);
+ if (num > 0 && num <= ARRAYLENGTH(script->equip))
+ i=pc->checkequip(sd,script->equip[num-1]);
if(i >= 0)
script_pushint(st,sd->status.inventory[i].identify);
else
@@ -7187,12 +7031,12 @@ BUILDIN(getequiprefinerycnt)
TBL_PC *sd;
num = script_getnum(st,2);
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
- if (num > 0 && num <= ARRAYLENGTH(equip))
- i=pc->checkequip(sd,equip[num-1]);
+ if (num > 0 && num <= ARRAYLENGTH(script->equip))
+ i=pc->checkequip(sd,script->equip[num-1]);
if(i >= 0)
script_pushint(st,sd->status.inventory[i].refine);
else
@@ -7214,12 +7058,12 @@ BUILDIN(getequipweaponlv)
TBL_PC *sd;
num = script_getnum(st,2);
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
- if (num > 0 && num <= ARRAYLENGTH(equip))
- i=pc->checkequip(sd,equip[num-1]);
+ if (num > 0 && num <= ARRAYLENGTH(script->equip))
+ i=pc->checkequip(sd,script->equip[num-1]);
if(i >= 0 && sd->inventory_data[i])
script_pushint(st,sd->inventory_data[i]->wlv);
else
@@ -7239,12 +7083,12 @@ BUILDIN(getequippercentrefinery) {
TBL_PC *sd;
num = script_getnum(st,2);
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
- if (num > 0 && num <= ARRAYLENGTH(equip))
- i=pc->checkequip(sd,equip[num-1]);
+ if (num > 0 && num <= ARRAYLENGTH(script->equip))
+ i=pc->checkequip(sd,script->equip[num-1]);
if(i >= 0 && sd->status.inventory[i].nameid && sd->status.inventory[i].refine < MAX_REFINE)
script_pushint(st,status->get_refine_chance(itemdb_wlv(sd->status.inventory[i].nameid), (int)sd->status.inventory[i].refine));
else
@@ -7262,12 +7106,12 @@ BUILDIN(successrefitem)
TBL_PC *sd;
num = script_getnum(st,2);
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
- if (num > 0 && num <= ARRAYLENGTH(equip))
- i=pc->checkequip(sd,equip[num-1]);
+ if (num > 0 && num <= ARRAYLENGTH(script->equip))
+ i=pc->checkequip(sd,script->equip[num-1]);
if(i >= 0) {
ep=sd->status.inventory[i].equip;
@@ -7319,12 +7163,12 @@ BUILDIN(failedrefitem)
TBL_PC *sd;
num = script_getnum(st,2);
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
- if (num > 0 && num <= ARRAYLENGTH(equip))
- i=pc->checkequip(sd,equip[num-1]);
+ if (num > 0 && num <= ARRAYLENGTH(script->equip))
+ i=pc->checkequip(sd,script->equip[num-1]);
if(i >= 0) {
sd->status.inventory[i].refine = 0;
pc->unequipitem(sd,i,3); //recalculate bonus
@@ -7347,12 +7191,12 @@ BUILDIN(downrefitem)
TBL_PC *sd;
num = script_getnum(st,2);
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
- if (num > 0 && num <= ARRAYLENGTH(equip))
- i = pc->checkequip(sd,equip[num-1]);
+ if (num > 0 && num <= ARRAYLENGTH(script->equip))
+ i = pc->checkequip(sd,script->equip[num-1]);
if(i >= 0) {
ep = sd->status.inventory[i].equip;
@@ -7385,12 +7229,12 @@ BUILDIN(delequip)
TBL_PC *sd;
num = script_getnum(st,2);
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
- if (num > 0 && num <= ARRAYLENGTH(equip))
- i=pc->checkequip(sd,equip[num-1]);
+ if (num > 0 && num <= ARRAYLENGTH(script->equip))
+ i=pc->checkequip(sd,script->equip[num-1]);
if(i >= 0) {
pc->unequipitem(sd,i,3); //recalculate bonus
pc->delitem(sd,i,1,0,2,LOG_TYPE_SCRIPT);
@@ -7408,7 +7252,7 @@ BUILDIN(statusup)
TBL_PC *sd;
type=script_getnum(st,2);
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
@@ -7426,7 +7270,7 @@ BUILDIN(statusup2)
type=script_getnum(st,2);
val=script_getnum(st,3);
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
@@ -7452,7 +7296,7 @@ BUILDIN(bonus)
int val5 = 0;
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true; // no player attached
@@ -7531,7 +7375,7 @@ BUILDIN(autobonus) {
TBL_PC* sd;
const char *bonus_script, *other_script = NULL;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true; // no player attached
@@ -7552,9 +7396,9 @@ BUILDIN(autobonus) {
if( pc->addautobonus(sd->autobonus,ARRAYLENGTH(sd->autobonus),bonus_script,rate,dur,atk_type,other_script,
sd->status.inventory[status->current_equip_item_index].equip,false)
) {
- script_add_autobonus(bonus_script);
+ script->add_autobonus(bonus_script);
if( other_script )
- script_add_autobonus(other_script);
+ script->add_autobonus(other_script);
}
return true;
@@ -7567,7 +7411,7 @@ BUILDIN(autobonus2) {
TBL_PC* sd;
const char *bonus_script, *other_script = NULL;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true; // no player attached
@@ -7588,9 +7432,9 @@ BUILDIN(autobonus2) {
if( pc->addautobonus(sd->autobonus2,ARRAYLENGTH(sd->autobonus2),bonus_script,rate,dur,atk_type,other_script,
sd->status.inventory[status->current_equip_item_index].equip,false)
) {
- script_add_autobonus(bonus_script);
+ script->add_autobonus(bonus_script);
if( other_script )
- script_add_autobonus(other_script);
+ script->add_autobonus(other_script);
}
return true;
@@ -7602,7 +7446,7 @@ BUILDIN(autobonus3) {
TBL_PC* sd;
const char *bonus_script, *other_script = NULL;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true; // no player attached
@@ -7622,9 +7466,9 @@ BUILDIN(autobonus3) {
if( pc->addautobonus(sd->autobonus3,ARRAYLENGTH(sd->autobonus3),bonus_script,rate,dur,atk_type,other_script,
sd->status.inventory[status->current_equip_item_index].equip,true)
) {
- script_add_autobonus(bonus_script);
+ script->add_autobonus(bonus_script);
if( other_script )
- script_add_autobonus(other_script);
+ script->add_autobonus(other_script);
}
return true;
@@ -7647,7 +7491,7 @@ BUILDIN(skill)
int flag = 1;
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;// no player attached, report source
@@ -7676,7 +7520,7 @@ BUILDIN(addtoskill)
int flag = 2;
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;// no player attached, report source
@@ -7700,7 +7544,7 @@ BUILDIN(guildskill)
TBL_PC* sd;
int i;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;// no player attached, report source
@@ -7721,7 +7565,7 @@ BUILDIN(getskilllv)
int id;
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;// no player attached, report source
@@ -7770,7 +7614,7 @@ BUILDIN(getgmlevel)
{
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;// no player attached, report source
@@ -7786,7 +7630,7 @@ BUILDIN(getgroupid)
{
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if (sd == NULL)
return false; // no player attached, report source
script_pushint(st, pc_get_group_id(sd));
@@ -7810,7 +7654,7 @@ BUILDIN(checkoption)
int option;
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;// no player attached, report source
@@ -7831,7 +7675,7 @@ BUILDIN(checkoption1)
int opt1;
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;// no player attached, report source
@@ -7852,7 +7696,7 @@ BUILDIN(checkoption2)
int opt2;
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;// no player attached, report source
@@ -7878,7 +7722,7 @@ BUILDIN(setoption)
int flag = 1;
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;// no player attached, report source
@@ -7911,7 +7755,7 @@ BUILDIN(checkcart)
{
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;// no player attached, report source
@@ -7939,7 +7783,7 @@ BUILDIN(setcart)
int type = 1;
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;// no player attached, report source
@@ -7959,7 +7803,7 @@ BUILDIN(checkfalcon)
{
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;// no player attached, report source
@@ -7981,7 +7825,7 @@ BUILDIN(setfalcon)
int flag = 1;
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;// no player attached, report source
@@ -8002,7 +7846,7 @@ BUILDIN(checkriding)
{
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;// no player attached, report source
@@ -8024,7 +7868,7 @@ BUILDIN(setriding)
int flag = 1;
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;// no player attached, report source
@@ -8043,7 +7887,7 @@ BUILDIN(checkwug)
{
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;// no player attached, report source
@@ -8063,7 +7907,7 @@ BUILDIN(checkmadogear)
{
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;// no player attached, report source
@@ -8085,7 +7929,7 @@ BUILDIN(setmadogear)
int flag = 1;
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;// no player attached, report source
@@ -8107,7 +7951,7 @@ BUILDIN(savepoint) {
const char* str;
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;// no player attached, report source
@@ -8226,7 +8070,7 @@ BUILDIN(gettimestr)
BUILDIN(openstorage) {
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
@@ -8238,7 +8082,7 @@ BUILDIN(guildopenstorage) {
TBL_PC* sd;
int ret;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
@@ -8257,7 +8101,7 @@ BUILDIN(itemskill) {
int lv;
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL || sd->ud.skilltimer != INVALID_TIMER )
return true;
@@ -8283,7 +8127,7 @@ BUILDIN(produce)
int trigger;
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
@@ -8299,7 +8143,7 @@ BUILDIN(cooking)
int trigger;
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
@@ -8316,7 +8160,7 @@ BUILDIN(makepet)
int id,pet_id;
id=script_getnum(st,2);
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
@@ -8344,7 +8188,7 @@ BUILDIN(getexp)
int base=0,job=0;
double bonus;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
@@ -8371,7 +8215,7 @@ BUILDIN(guildgetexp)
TBL_PC* sd;
int exp;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
@@ -8431,7 +8275,7 @@ BUILDIN(monster)
if (script_hasdata(st, 8))
{
event = script_getstr(st, 8);
- check_event(st, event);
+ script->check_event(st, event);
}
if (script_hasdata(st, 9))
@@ -8540,7 +8384,7 @@ BUILDIN(areamonster)
if (script_hasdata(st,10)) {
event = script_getstr(st, 10);
- check_event(st, event);
+ script->check_event(st, event);
}
if (script_hasdata(st, 11)) {
@@ -8584,7 +8428,7 @@ BUILDIN(areamonster)
/*==========================================
* KillMonster subcheck, verify if mob to kill ain't got an even to handle, could be force kill by allflag
*------------------------------------------*/
-static int buildin_killmonster_sub_strip(struct block_list *bl,va_list ap)
+int buildin_killmonster_sub_strip(struct block_list *bl,va_list ap)
{ //same fix but with killmonster instead - stripping events from mobs.
TBL_MOB* md = (TBL_MOB*)bl;
char *event=va_arg(ap,char *);
@@ -8602,7 +8446,7 @@ static int buildin_killmonster_sub_strip(struct block_list *bl,va_list ap)
md->state.npc_killmonster = 0;
return 0;
}
-static int buildin_killmonster_sub(struct block_list *bl,va_list ap)
+int buildin_killmonster_sub(struct block_list *bl,va_list ap)
{
TBL_MOB* md = (TBL_MOB*)bl;
char *event=va_arg(ap,char *);
@@ -8625,7 +8469,7 @@ BUILDIN(killmonster) {
if(strcmp(event,"All")==0)
allflag = 1;
else
- check_event(st, event);
+ script->check_event(st, event);
if( (m=map->mapname2mapid(mapname))<0 )
return true;
@@ -8635,18 +8479,18 @@ BUILDIN(killmonster) {
if( script_hasdata(st,4) ) {
if ( script_getnum(st,4) == 1 ) {
- map->foreachinmap(buildin_killmonster_sub, m, BL_MOB, event ,allflag);
+ map->foreachinmap(script->buildin_killmonster_sub, m, BL_MOB, event ,allflag);
return true;
}
}
map->freeblock_lock();
- map->foreachinmap(buildin_killmonster_sub_strip, m, BL_MOB, event ,allflag);
+ map->foreachinmap(script->buildin_killmonster_sub_strip, m, BL_MOB, event ,allflag);
map->freeblock_unlock();
return true;
}
-static int buildin_killmonsterall_sub_strip(struct block_list *bl,va_list ap)
+int buildin_killmonsterall_sub_strip(struct block_list *bl,va_list ap)
{ //Strips the event from the mob if it's killed the old method.
struct mob_data *md;
@@ -8657,7 +8501,7 @@ static int buildin_killmonsterall_sub_strip(struct block_list *bl,va_list ap)
status_kill(bl);
return 0;
}
-static int buildin_killmonsterall_sub(struct block_list *bl,va_list ap)
+int buildin_killmonsterall_sub(struct block_list *bl,va_list ap)
{
status_kill(bl);
return 0;
@@ -8675,12 +8519,12 @@ BUILDIN(killmonsterall) {
if( script_hasdata(st,3) ) {
if ( script_getnum(st,3) == 1 ) {
- map->foreachinmap(buildin_killmonsterall_sub,m,BL_MOB);
+ map->foreachinmap(script->buildin_killmonsterall_sub,m,BL_MOB);
return true;
}
}
- map->foreachinmap(buildin_killmonsterall_sub_strip,m,BL_MOB);
+ map->foreachinmap(script->buildin_killmonsterall_sub_strip,m,BL_MOB);
return true;
}
@@ -8712,7 +8556,7 @@ BUILDIN(clone) {
if( script_hasdata(st,10) )
duration=script_getnum(st,10);
- check_event(st, event);
+ script->check_event(st, event);
m = map->mapname2mapid(mapname);
if (m < 0) return true;
@@ -8740,12 +8584,12 @@ BUILDIN(doevent)
const char* event = script_getstr(st,2);
struct map_session_data* sd;
- if( ( sd = script_rid2sd(st) ) == NULL )
+ if( ( sd = script->rid2sd(st) ) == NULL )
{
return true;
}
- check_event(st, event);
+ script->check_event(st, event);
npc->event(sd, event, 0);
return true;
}
@@ -8754,7 +8598,7 @@ BUILDIN(doevent)
BUILDIN(donpcevent)
{
const char* event = script_getstr(st,2);
- check_event(st, event);
+ script->check_event(st, event);
if( !npc->event_do(event) ) {
struct npc_data * nd = map->id2nd(st->oid);
ShowDebug("NPCEvent '%s' not found! (source: %s)\n",event,nd?nd->name:"Unknown");
@@ -8772,7 +8616,7 @@ BUILDIN(cmdothernpc) // Added by RoVeRT
const char* command = script_getstr(st,3);
char event[EVENT_NAME_LENGTH];
snprintf(event, sizeof(event), "%s::OnCommand%s", npc_name, command);
- check_event(st, event);
+ script->check_event(st, event);
npc->event_do(event);
return true;
}
@@ -8785,8 +8629,8 @@ BUILDIN(addtimer)
const char* event = script_getstr(st, 3);
TBL_PC* sd;
- check_event(st, event);
- sd = script_rid2sd(st);
+ script->check_event(st, event);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
@@ -8801,11 +8645,11 @@ BUILDIN(deltimer)
TBL_PC* sd;
event=script_getstr(st, 2);
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
- check_event(st, event);
+ script->check_event(st, event);
pc->deleventtimer(sd,event);
return true;
}
@@ -8819,11 +8663,11 @@ BUILDIN(addtimercount)
event=script_getstr(st, 2);
tick=script_getnum(st,3);
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
- check_event(st, event);
+ script->check_event(st, event);
pc->addeventtimercount(sd,event,tick);
return true;
}
@@ -8862,7 +8706,7 @@ BUILDIN(initnpctimer)
return true;
if( flag ) //Attach
{
- TBL_PC* sd = script_rid2sd(st);
+ TBL_PC* sd = script->rid2sd(st);
if( sd == NULL )
return true;
nd->u.scr.rid = sd->bl.id;
@@ -8907,7 +8751,7 @@ BUILDIN(startnpctimer)
return true;
if( flag ) //Attach
{
- TBL_PC* sd = script_rid2sd(st);
+ TBL_PC* sd = script->rid2sd(st);
if( sd == NULL )
return true;
nd->u.scr.rid = sd->bl.id;
@@ -9034,7 +8878,7 @@ BUILDIN(attachnpctimer) {
if( script_hasdata(st,2) )
sd = map->nick2sd(script_getstr(st,2));
else
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( !sd )
{
@@ -9098,7 +8942,7 @@ BUILDIN(announce) {
if( flag&(BC_TARGET_MASK|BC_SOURCE_MASK) ) {
// Broadcast source or broadcast region defined
send_target target;
- struct block_list *bl = (flag&BC_NPC) ? map->id2bl(st->oid) : (struct block_list *)script_rid2sd(st); // If bc_npc flag is set, use NPC as broadcast source
+ struct block_list *bl = (flag&BC_NPC) ? map->id2bl(st->oid) : (struct block_list *)script->rid2sd(st); // If bc_npc flag is set, use NPC as broadcast source
if (bl == NULL)
return true;
@@ -9123,7 +8967,7 @@ BUILDIN(announce) {
}
/*==========================================
*------------------------------------------*/
-static int buildin_announce_sub(struct block_list *bl, va_list ap)
+int buildin_announce_sub(struct block_list *bl, va_list ap)
{
char *mes = va_arg(ap, char *);
int len = va_arg(ap, int);
@@ -9148,7 +8992,7 @@ BUILDIN(itemeffect) {
struct script_data *data;
struct item_data *item_data;
- nullpo_retr( 1, ( sd = script_rid2sd( st ) ) );
+ nullpo_retr( 1, ( sd = script->rid2sd( st ) ) );
nullpo_retr( 1, ( nd = (TBL_NPC *)map->id2bl( sd->npc_id ) ) );
data = script_getdata( st, 2 );
@@ -9192,7 +9036,7 @@ BUILDIN(mapannounce) {
if ((m = map->mapname2mapid(mapname)) < 0)
return true;
- map->foreachinmap(buildin_announce_sub, m, BL_PC,
+ map->foreachinmap(script->buildin_announce_sub, m, BL_PC,
mes, strlen(mes)+1, flag&BC_COLOR_MASK, fontColor, fontType, fontSize, fontAlign, fontY);
return true;
}
@@ -9216,7 +9060,7 @@ BUILDIN(areaannounce) {
if ((m = map->mapname2mapid(mapname)) < 0)
return true;
- map->foreachinarea(buildin_announce_sub, m, x0, y0, x1, y1, BL_PC,
+ map->foreachinarea(script->buildin_announce_sub, m, x0, y0, x1, y1, BL_PC,
mes, strlen(mes)+1, flag&BC_COLOR_MASK, fontColor, fontType, fontSize, fontAlign, fontY);
return true;
}
@@ -9235,7 +9079,7 @@ BUILDIN(getusers) {
if(flag&0x8) {
// npc
bl = map->id2bl(st->oid);
- } else if((sd = script_rid2sd(st))!=NULL) {
+ } else if((sd = script->rid2sd(st))!=NULL) {
// pc
bl = &sd->bl;
}
@@ -9265,7 +9109,7 @@ BUILDIN(getusersname)
int /*disp_num=1,*/ group_level = 0;
struct s_mapiterator* iter;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if (!sd) return true;
group_level = pc->get_group_level(sd);
@@ -9329,7 +9173,7 @@ BUILDIN(getmapusers) {
}
/*==========================================
*------------------------------------------*/
-static int buildin_getareausers_sub(struct block_list *bl,va_list ap)
+int buildin_getareausers_sub(struct block_list *bl,va_list ap)
{
int *users=va_arg(ap,int *);
(*users)++;
@@ -9348,7 +9192,7 @@ BUILDIN(getareausers)
script_pushint(st,-1);
return true;
}
- map->foreachinarea(buildin_getareausers_sub,
+ map->foreachinarea(script->buildin_getareausers_sub,
m,x0,y0,x1,y1,BL_PC,&users);
script_pushint(st,users);
return true;
@@ -9356,7 +9200,7 @@ BUILDIN(getareausers)
/*==========================================
*------------------------------------------*/
-static int buildin_getareadropitem_sub(struct block_list *bl,va_list ap)
+int buildin_getareadropitem_sub(struct block_list *bl,va_list ap)
{
int item=va_arg(ap,int);
int *amount=va_arg(ap,int *);
@@ -9395,7 +9239,7 @@ BUILDIN(getareadropitem)
script_pushint(st,-1);
return true;
}
- map->foreachinarea(buildin_getareadropitem_sub,
+ map->foreachinarea(script->buildin_getareadropitem_sub,
m,x0,y0,x1,y1,BL_ITEM,item,&amount);
script_pushint(st,amount);
return true;
@@ -9625,7 +9469,7 @@ BUILDIN(getscrate) {
BUILDIN(getstatus)
{
int id, type;
- struct map_session_data* sd = script_rid2sd(st);
+ struct map_session_data* sd = script->rid2sd(st);
if( sd == NULL )
{// no player attached
@@ -9687,7 +9531,7 @@ BUILDIN(catchpet)
TBL_PC *sd;
pet_id= script_getnum(st,2);
- sd=script_rid2sd(st);
+ sd=script->rid2sd(st);
if( sd == NULL )
return true;
@@ -9702,7 +9546,7 @@ BUILDIN(homunculus_evolution)
{
TBL_PC *sd;
- sd=script_rid2sd(st);
+ sd=script->rid2sd(st);
if( sd == NULL )
return true;
@@ -9723,7 +9567,7 @@ BUILDIN(homunculus_mutate) {
enum homun_type m_class, m_id;
TBL_PC *sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL || sd->hd == NULL )
return true;
@@ -9748,7 +9592,7 @@ BUILDIN(homunculus_mutate) {
BUILDIN(homunculus_shuffle) {
TBL_PC *sd;
- sd=script_rid2sd(st);
+ sd=script->rid2sd(st);
if( sd == NULL )
return true;
@@ -9767,7 +9611,7 @@ BUILDIN(homunculus_shuffle) {
*------------------------------------------*/
BUILDIN(checkhomcall)
{
- TBL_PC *sd = script_rid2sd(st);
+ TBL_PC *sd = script->rid2sd(st);
TBL_HOM *hd;
if( sd == NULL )
@@ -9791,7 +9635,7 @@ BUILDIN(eaclass)
class_ = script_getnum(st,2);
else {
TBL_PC *sd;
- sd=script_rid2sd(st);
+ sd=script->rid2sd(st);
if (!sd) {
script_pushint(st,-1);
return true;
@@ -9810,7 +9654,7 @@ BUILDIN(roclass)
sex = script_getnum(st,3);
else {
TBL_PC *sd;
- if (st->rid && (sd=script_rid2sd(st)))
+ if (st->rid && (sd=script->rid2sd(st)))
sex = sd->status.sex;
else
sex = 1; //Just use male when not found.
@@ -9825,7 +9669,7 @@ BUILDIN(roclass)
BUILDIN(birthpet)
{
TBL_PC *sd;
- sd=script_rid2sd(st);
+ sd=script->rid2sd(st);
if( sd == NULL )
return true;
@@ -9852,7 +9696,7 @@ BUILDIN(resetlvl)
int type=script_getnum(st,2);
- sd=script_rid2sd(st);
+ sd=script->rid2sd(st);
if( sd == NULL )
return true;
@@ -9865,7 +9709,7 @@ BUILDIN(resetlvl)
BUILDIN(resetstatus)
{
TBL_PC *sd;
- sd=script_rid2sd(st);
+ sd=script->rid2sd(st);
pc->resetstate(sd);
return true;
}
@@ -9876,7 +9720,7 @@ BUILDIN(resetstatus)
BUILDIN(resetskill)
{
TBL_PC *sd;
- sd=script_rid2sd(st);
+ sd=script->rid2sd(st);
pc->resetskill(sd,1);
return true;
}
@@ -9887,7 +9731,7 @@ BUILDIN(resetskill)
BUILDIN(skillpointcount)
{
TBL_PC *sd;
- sd=script_rid2sd(st);
+ sd=script->rid2sd(st);
script_pushint(st,sd->status.skill_point + pc->resetskill(sd,2));
return true;
}
@@ -9902,7 +9746,7 @@ BUILDIN(changebase) {
if( script_hasdata(st,3) )
sd=map->id2sd(script_getnum(st,3));
else
- sd=script_rid2sd(st);
+ sd=script->rid2sd(st);
if(sd == NULL)
return true;
@@ -9936,7 +9780,7 @@ BUILDIN(changesex)
{
int i;
TBL_PC *sd = NULL;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
pc->resetskill(sd,4);
// to avoid any problem with equipment and invalid sex, equipment is unequiped.
@@ -10180,7 +10024,7 @@ BUILDIN(warpwaitingpc) {
/// @param st Script state to detach the character from.
void script_detach_rid(struct script_state* st) {
if(st->rid) {
- script_detach_state(st, false);
+ script->detach_state(st, false);
st->rid = 0;
}
}
@@ -10192,7 +10036,7 @@ BUILDIN(attachrid) {
int rid = script_getnum(st,2);
if (map->id2sd(rid) != NULL) {
- script_detach_rid(st);
+ script->detach_rid(st);
st->rid = rid;
script->attach_state(st);
@@ -10206,7 +10050,7 @@ BUILDIN(attachrid) {
*------------------------------------------*/
BUILDIN(detachrid)
{
- script_detach_rid(st);
+ script->detach_rid(st);
return true;
}
/*==========================================
@@ -10314,7 +10158,7 @@ BUILDIN(getmapflag)
return true;
}
/* pvp timer handling */
-static int script_mapflag_pvp_sub(struct block_list *bl,va_list ap) {
+int script_mapflag_pvp_sub(struct block_list *bl,va_list ap) {
TBL_PC* sd = (TBL_PC*)bl;
if (sd->pvp_timer == INVALID_TIMER) {
sd->pvp_timer = timer->add(timer->gettick() + 200, pc->calc_pvprank_timer, sd->bl.id, 0);
@@ -10362,7 +10206,7 @@ BUILDIN(setmapflag) {
case MF_PVP:
maplist[m].flag.pvp = 1;
if( !battle_config.pk_mode ) {
- map->foreachinmap(script_mapflag_pvp_sub,m,BL_PC);
+ map->foreachinmap(script->mapflag_pvp_sub,m,BL_PC);
}
break;
case MF_PVP_NOPARTY: maplist[m].flag.pvp_noparty = 1; break;
@@ -10556,7 +10400,7 @@ BUILDIN(pvpon) {
return true;
}
-static int buildin_pvpoff_sub(struct block_list *bl,va_list ap)
+int buildin_pvpoff_sub(struct block_list *bl,va_list ap)
{
TBL_PC* sd = (TBL_PC*)bl;
clif->pvpset(sd, 0, 0, 2);
@@ -10587,7 +10431,7 @@ BUILDIN(pvpoff) {
if(battle_config.pk_mode) // disable ranking options if pk_mode is on [Valaris]
return true;
- map->foreachinmap(buildin_pvpoff_sub, m, BL_PC);
+ map->foreachinmap(script->buildin_pvpoff_sub, m, BL_PC);
return true;
}
@@ -10648,7 +10492,7 @@ BUILDIN(emotion) {
if( script_hasdata(st,4) )
sd = map->nick2sd(script_getstr(st,4));
else
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if (sd)
clif->emotion(&sd->bl,type);
} else if( script_hasdata(st,4) ) {
@@ -10660,7 +10504,7 @@ BUILDIN(emotion) {
return true;
}
-static int buildin_maprespawnguildid_sub_pc(struct map_session_data* sd, va_list ap)
+int buildin_maprespawnguildid_sub_pc(struct map_session_data* sd, va_list ap)
{
int16 m=va_arg(ap,int);
int g_id=va_arg(ap,int);
@@ -10677,7 +10521,7 @@ static int buildin_maprespawnguildid_sub_pc(struct map_session_data* sd, va_list
return 1;
}
-static int buildin_maprespawnguildid_sub_mob(struct block_list *bl,va_list ap)
+int buildin_maprespawnguildid_sub_mob(struct block_list *bl,va_list ap)
{
struct mob_data *md=(struct mob_data *)bl;
@@ -10698,9 +10542,9 @@ BUILDIN(maprespawnguildid) {
return true;
//Catch ALL players (in case some are 'between maps' on execution time)
- map->map_foreachpc(buildin_maprespawnguildid_sub_pc,m,g_id,flag);
+ map->map_foreachpc(script->buildin_maprespawnguildid_sub_pc,m,g_id,flag);
if (flag&4) //Remove script mobs.
- map->foreachinmap(buildin_maprespawnguildid_sub_mob,m,BL_MOB);
+ map->foreachinmap(script->buildin_maprespawnguildid_sub_mob,m,BL_MOB);
return true;
}
@@ -10857,7 +10701,7 @@ BUILDIN(requestguildinfo)
if( script_hasdata(st,3) ){
event=script_getstr(st,3);
- check_event(st, event);
+ script->check_event(st, event);
}
if(guild_id>0)
@@ -10874,9 +10718,9 @@ BUILDIN(getequipcardcnt)
int count;
num=script_getnum(st,2);
- sd=script_rid2sd(st);
- if (num > 0 && num <= ARRAYLENGTH(equip))
- i=pc->checkequip(sd,equip[num-1]);
+ sd=script->rid2sd(st);
+ if (num > 0 && num <= ARRAYLENGTH(script->equip))
+ i=pc->checkequip(sd,script->equip[num-1]);
if (i < 0 || !sd->inventory_data[i]) {
script_pushint(st,0);
@@ -10904,11 +10748,11 @@ BUILDIN(getequipcardcnt)
BUILDIN(successremovecards) {
int i=-1,j,c,cardflag=0;
- TBL_PC* sd = script_rid2sd(st);
+ TBL_PC* sd = script->rid2sd(st);
int num = script_getnum(st,2);
- if (num > 0 && num <= ARRAYLENGTH(equip))
- i=pc->checkequip(sd,equip[num-1]);
+ if (num > 0 && num <= ARRAYLENGTH(script->equip))
+ i=pc->checkequip(sd,script->equip[num-1]);
if (i < 0 || !sd->inventory_data[i]) {
return true;
@@ -10967,12 +10811,12 @@ BUILDIN(successremovecards) {
BUILDIN(failedremovecards) {
int i=-1,j,c,cardflag=0;
- TBL_PC* sd = script_rid2sd(st);
+ TBL_PC* sd = script->rid2sd(st);
int num = script_getnum(st,2);
int typefail = script_getnum(st,3);
- if (num > 0 && num <= ARRAYLENGTH(equip))
- i=pc->checkequip(sd,equip[num-1]);
+ if (num > 0 && num <= ARRAYLENGTH(script->equip))
+ i=pc->checkequip(sd,script->equip[num-1]);
if (i < 0 || !sd->inventory_data[i])
return true;
@@ -11084,14 +10928,14 @@ BUILDIN(mapwarp) {
}
break;
default:
- map->foreachinmap(buildin_areawarp_sub,m,BL_PC,index,x,y,0,0);
+ map->foreachinmap(script->buildin_areawarp_sub,m,BL_PC,index,x,y,0,0);
break;
}
return true;
}
-static int buildin_mobcount_sub(struct block_list *bl,va_list ap) // Added by RoVeRT
+int buildin_mobcount_sub(struct block_list *bl,va_list ap) // Added by RoVeRT
{
char *event=va_arg(ap,char *);
struct mob_data *md = ((struct mob_data *)bl);
@@ -11110,10 +10954,10 @@ BUILDIN(mobcount) {
if( strcmp(event, "all") == 0 )
event = NULL;
else
- check_event(st, event);
+ script->check_event(st, event);
if( strcmp(mapname, "this") == 0 ) {
- struct map_session_data *sd = script_rid2sd(st);
+ struct map_session_data *sd = script->rid2sd(st);
if( sd )
m = sd->bl.m;
else {
@@ -11130,14 +10974,14 @@ BUILDIN(mobcount) {
return true;
}
- script_pushint(st,map->foreachinmap(buildin_mobcount_sub, m, BL_MOB, event));
+ script_pushint(st,map->foreachinmap(script->buildin_mobcount_sub, m, BL_MOB, event));
return true;
}
BUILDIN(marriage) {
const char *partner=script_getstr(st,2);
- TBL_PC *sd=script_rid2sd(st);
+ TBL_PC *sd=script->rid2sd(st);
TBL_PC *p_sd=map->nick2sd(partner);
if(sd==NULL || p_sd==NULL || pc->marriage(sd,p_sd) < 0){
@@ -11148,7 +10992,7 @@ BUILDIN(marriage) {
return true;
}
BUILDIN(wedding_effect) {
- TBL_PC *sd=script_rid2sd(st);
+ TBL_PC *sd=script->rid2sd(st);
struct block_list *bl;
if(sd==NULL) {
@@ -11160,7 +11004,7 @@ BUILDIN(wedding_effect) {
}
BUILDIN(divorce)
{
- TBL_PC *sd=script_rid2sd(st);
+ TBL_PC *sd=script->rid2sd(st);
if(sd==NULL || pc->divorce(sd) < 0){
script_pushint(st,0);
return true;
@@ -11170,7 +11014,7 @@ BUILDIN(divorce)
}
BUILDIN(ispartneron) {
- TBL_PC *sd=script_rid2sd(st);
+ TBL_PC *sd=script->rid2sd(st);
if(sd==NULL || !pc->ismarried(sd) ||
map->charid2sd(sd->status.partner_id) == NULL) {
@@ -11184,7 +11028,7 @@ BUILDIN(ispartneron) {
BUILDIN(getpartnerid)
{
- TBL_PC *sd=script_rid2sd(st);
+ TBL_PC *sd=script->rid2sd(st);
if (sd == NULL) {
script_pushint(st,0);
return true;
@@ -11196,7 +11040,7 @@ BUILDIN(getpartnerid)
BUILDIN(getchildid)
{
- TBL_PC *sd=script_rid2sd(st);
+ TBL_PC *sd=script->rid2sd(st);
if (sd == NULL) {
script_pushint(st,0);
return true;
@@ -11208,7 +11052,7 @@ BUILDIN(getchildid)
BUILDIN(getmotherid)
{
- TBL_PC *sd=script_rid2sd(st);
+ TBL_PC *sd=script->rid2sd(st);
if (sd == NULL) {
script_pushint(st,0);
return true;
@@ -11220,7 +11064,7 @@ BUILDIN(getmotherid)
BUILDIN(getfatherid)
{
- TBL_PC *sd=script_rid2sd(st);
+ TBL_PC *sd=script->rid2sd(st);
if (sd == NULL) {
script_pushint(st,0);
return true;
@@ -11235,7 +11079,7 @@ BUILDIN(warppartner)
int x,y;
unsigned short mapindex;
const char *str;
- TBL_PC *sd=script_rid2sd(st);
+ TBL_PC *sd=script->rid2sd(st);
TBL_PC *p_sd=NULL;
if(sd==NULL || !pc->ismarried(sd) ||
@@ -11323,12 +11167,12 @@ BUILDIN(guardian) {
has_index = true;
} else {
ShowError("script:guardian: invalid data type for argument #6 (from 1)\n");
- script_reportdata(data);
+ script->reportdata(data);
return false;
}
}
- check_event(st, evt);
+ script->check_event(st, evt);
script_pushint(st, mob->spawn_guardian(mapname,x,y,str,class_,evt,guardian,has_index));
return true;
@@ -11554,9 +11398,9 @@ BUILDIN(getequipcardid)
num=script_getnum(st,2);
slot=script_getnum(st,3);
- sd=script_rid2sd(st);
- if (num > 0 && num <= ARRAYLENGTH(equip))
- i=pc->checkequip(sd,equip[num-1]);
+ sd=script->rid2sd(st);
+ if (num > 0 && num <= ARRAYLENGTH(script->equip))
+ i=pc->checkequip(sd,script->equip[num-1]);
if(i >= 0 && slot>=0 && slot<4)
script_pushint(st,sd->status.inventory[i].card[slot]);
else
@@ -11572,7 +11416,7 @@ BUILDIN(petskillbonus)
{
struct pet_data *pd;
- TBL_PC *sd=script_rid2sd(st);
+ TBL_PC *sd=script->rid2sd(st);
if(sd==NULL || sd->pd==NULL)
return true;
@@ -11609,7 +11453,7 @@ BUILDIN(petloot)
{
int max;
struct pet_data *pd;
- TBL_PC *sd=script_rid2sd(st);
+ TBL_PC *sd=script->rid2sd(st);
if(sd==NULL || sd->pd==NULL)
return true;
@@ -11647,7 +11491,7 @@ BUILDIN(petloot)
*------------------------------------------*/
BUILDIN(getinventorylist)
{
- TBL_PC *sd=script_rid2sd(st);
+ TBL_PC *sd=script->rid2sd(st);
char card_var[NAME_LENGTH];
int i,j=0,k;
@@ -11675,7 +11519,7 @@ BUILDIN(getinventorylist)
BUILDIN(getskilllist)
{
- TBL_PC *sd=script_rid2sd(st);
+ TBL_PC *sd=script->rid2sd(st);
int i,j=0;
if(!sd) return true;
for(i=0;i<MAX_SKILL;i++){
@@ -11692,7 +11536,7 @@ BUILDIN(getskilllist)
BUILDIN(clearitem)
{
- TBL_PC *sd=script_rid2sd(st);
+ TBL_PC *sd=script->rid2sd(st);
int i;
if(sd==NULL) return true;
for (i=0; i<MAX_INVENTORY; i++) {
@@ -11709,7 +11553,7 @@ BUILDIN(clearitem)
BUILDIN(disguise)
{
int id;
- TBL_PC* sd = script_rid2sd(st);
+ TBL_PC* sd = script->rid2sd(st);
if (sd == NULL) return true;
id = script_getnum(st,2);
@@ -11728,7 +11572,7 @@ BUILDIN(disguise)
*------------------------------------------*/
BUILDIN(undisguise)
{
- TBL_PC* sd = script_rid2sd(st);
+ TBL_PC* sd = script->rid2sd(st);
if (sd == NULL) return true;
if (sd->disguise != -1) {
@@ -11769,7 +11613,7 @@ BUILDIN(misceffect)
if (bl)
clif->specialeffect(bl,type,AREA);
} else{
- TBL_PC *sd=script_rid2sd(st);
+ TBL_PC *sd=script->rid2sd(st);
if(sd)
clif->specialeffect(&sd->bl,type,AREA);
}
@@ -11783,7 +11627,7 @@ BUILDIN(playBGM)
const char* name;
struct map_session_data* sd;
- if( ( sd = script_rid2sd(st) ) != NULL )
+ if( ( sd = script->rid2sd(st) ) != NULL )
{
name = script_getstr(st,2);
@@ -11793,7 +11637,7 @@ BUILDIN(playBGM)
return true;
}
-static int playBGM_sub(struct block_list* bl,va_list ap)
+int playBGM_sub(struct block_list* bl,va_list ap)
{
const char* name = va_arg(ap,const char*);
@@ -11802,7 +11646,7 @@ static int playBGM_sub(struct block_list* bl,va_list ap)
return 0;
}
-static int playBGM_foreachpc_sub(struct map_session_data* sd, va_list args)
+int playBGM_foreachpc_sub(struct map_session_data* sd, va_list args)
{
const char* name = va_arg(args, const char*);
@@ -11832,7 +11676,7 @@ BUILDIN(playBGMall) {
return true;
}
- map->foreachinarea(playBGM_sub, m, x0, y0, x1, y1, BL_PC, name);
+ map->foreachinarea(script->playBGM_sub, m, x0, y0, x1, y1, BL_PC, name);
} else if( script_hasdata(st,3) ) {
// entire map
const char* mapname = script_getstr(st,3);
@@ -11843,10 +11687,10 @@ BUILDIN(playBGMall) {
return true;
}
- map->foreachinmap(playBGM_sub, m, BL_PC, name);
+ map->foreachinmap(script->playBGM_sub, m, BL_PC, name);
} else {
// entire server
- map->map_foreachpc(&playBGM_foreachpc_sub, name);
+ map->map_foreachpc(script->playBGM_foreachpc_sub, name);
}
return true;
@@ -11857,7 +11701,7 @@ BUILDIN(playBGMall) {
*------------------------------------------*/
BUILDIN(soundeffect)
{
- TBL_PC* sd = script_rid2sd(st);
+ TBL_PC* sd = script->rid2sd(st);
const char* name = script_getstr(st,2);
int type = script_getnum(st,3);
@@ -11887,7 +11731,7 @@ BUILDIN(soundeffectall) {
const char* name;
int type;
- bl = (st->rid) ? &(script_rid2sd(st)->bl) : map->id2bl(st->oid);
+ bl = (st->rid) ? &(script->rid2sd(st)->bl) : map->id2bl(st->oid);
if (!bl)
return true;
@@ -11908,7 +11752,7 @@ BUILDIN(soundeffectall) {
return true;
}
- map->foreachinmap(soundeffect_sub, m, BL_PC, name, type);
+ map->foreachinmap(script->soundeffect_sub, m, BL_PC, name, type);
} else if(script_hasdata(st,8)) { // specified part of map
const char *mapname = script_getstr(st,4);
int x0 = script_getnum(st,5);
@@ -11922,7 +11766,7 @@ BUILDIN(soundeffectall) {
return true;
}
- map->foreachinarea(soundeffect_sub, m, x0, y0, x1, y1, BL_PC, name, type);
+ map->foreachinarea(script->soundeffect_sub, m, x0, y0, x1, y1, BL_PC, name, type);
} else {
ShowError("buildin_soundeffectall: insufficient arguments for specific area broadcast.\n");
}
@@ -11936,7 +11780,7 @@ BUILDIN(soundeffectall) {
BUILDIN(petrecovery)
{
struct pet_data *pd;
- TBL_PC *sd=script_rid2sd(st);
+ TBL_PC *sd=script->rid2sd(st);
if(sd==NULL || sd->pd==NULL)
return true;
@@ -11963,7 +11807,7 @@ BUILDIN(petrecovery)
BUILDIN(petheal)
{
struct pet_data *pd;
- TBL_PC *sd=script_rid2sd(st);
+ TBL_PC *sd=script->rid2sd(st);
if(sd==NULL || sd->pd==NULL)
return true;
@@ -12005,7 +11849,7 @@ BUILDIN(petheal)
BUILDIN(petskillattack)
{
struct pet_data *pd;
- TBL_PC *sd=script_rid2sd(st);
+ TBL_PC *sd=script->rid2sd(st);
if(sd==NULL || sd->pd==NULL)
return true;
@@ -12031,7 +11875,7 @@ BUILDIN(petskillattack)
BUILDIN(petskillattack2)
{
struct pet_data *pd;
- TBL_PC *sd=script_rid2sd(st);
+ TBL_PC *sd=script->rid2sd(st);
if(sd==NULL || sd->pd==NULL)
return true;
@@ -12057,7 +11901,7 @@ BUILDIN(petskillattack2)
BUILDIN(petskillsupport)
{
struct pet_data *pd;
- TBL_PC *sd=script_rid2sd(st);
+ TBL_PC *sd=script->rid2sd(st);
if(sd==NULL || sd->pd==NULL)
return true;
@@ -12101,7 +11945,7 @@ BUILDIN(skilleffect)
uint16 skill_id=( script_isstring(st,2) ? skill->name2id(script_getstr(st,2)) : script_getnum(st,2) );
uint16 skill_lv=script_getnum(st,3);
- sd=script_rid2sd(st);
+ sd=script->rid2sd(st);
clif->skill_nodamage(&sd->bl,&sd->bl,skill_id,skill_lv,1);
@@ -12147,7 +11991,7 @@ BUILDIN(specialeffect) {
else
{
if (target == SELF) {
- TBL_PC *sd=script_rid2sd(st);
+ TBL_PC *sd=script->rid2sd(st);
if (sd)
clif->specialeffect_single(bl,type,sd->fd);
} else {
@@ -12159,7 +12003,7 @@ BUILDIN(specialeffect) {
}
BUILDIN(specialeffect2) {
- TBL_PC *sd=script_rid2sd(st);
+ TBL_PC *sd=script->rid2sd(st);
int type = script_getnum(st,2);
enum send_target target = script_hasdata(st,3) ? (send_target)script_getnum(st,3) : AREA;
@@ -12177,7 +12021,7 @@ BUILDIN(specialeffect2) {
*------------------------------------------*/
BUILDIN(nude)
{
- TBL_PC *sd = script_rid2sd(st);
+ TBL_PC *sd = script->rid2sd(st);
int i, calcflag = 0;
if( sd == NULL )
@@ -12209,7 +12053,7 @@ BUILDIN(atcommand) {
cmd = script_getstr(st,2);
if (st->rid) {
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
fd = sd->fd;
} else { //Use a dummy character.
sd = dummy_sd = pc->get_dummy_sd();
@@ -12225,7 +12069,7 @@ BUILDIN(atcommand) {
if (!atcommand->parse(fd, sd, cmd, 0)) {
ShowWarning("script: buildin_atcommand: failed to execute command '%s'\n", cmd);
- script_reportsrc(st);
+ script->reportsrc(st);
ret = false;
}
if (dummy_sd) aFree(dummy_sd);
@@ -12237,7 +12081,7 @@ BUILDIN(atcommand) {
*------------------------------------------*/
BUILDIN(dispbottom)
{
- TBL_PC *sd=script_rid2sd(st);
+ TBL_PC *sd=script->rid2sd(st);
const char *message;
message=script_getstr(st,2);
if(sd)
@@ -12273,7 +12117,7 @@ BUILDIN(recovery)
*------------------------------------------*/
BUILDIN(getpetinfo)
{
- TBL_PC *sd=script_rid2sd(st);
+ TBL_PC *sd=script->rid2sd(st);
TBL_PET *pd;
int type=script_getnum(st,2);
@@ -12307,7 +12151,7 @@ BUILDIN(getpetinfo)
*------------------------------------------*/
BUILDIN(gethominfo)
{
- TBL_PC *sd=script_rid2sd(st);
+ TBL_PC *sd=script->rid2sd(st);
TBL_HOM *hd;
int type=script_getnum(st,2);
@@ -12354,7 +12198,7 @@ BUILDIN(getmercinfo) {
return false;
}
} else {
- if( ( sd = script_rid2sd(st) ) == NULL ) {
+ if( ( sd = script->rid2sd(st) ) == NULL ) {
script_pushnil(st);
return true;
}
@@ -12393,7 +12237,7 @@ BUILDIN(getmercinfo) {
*------------------------------------------*/
BUILDIN(checkequipedcard)
{
- TBL_PC *sd=script_rid2sd(st);
+ TBL_PC *sd=script->rid2sd(st);
if(sd){
int n,i,c=0;
@@ -12550,7 +12394,7 @@ BUILDIN(getlook)
{
int type,val;
TBL_PC *sd;
- sd=script_rid2sd(st);
+ sd=script->rid2sd(st);
type=script_getnum(st,2);
val=-1;
@@ -12579,7 +12423,7 @@ BUILDIN(getsavepoint)
TBL_PC* sd;
int type;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if (sd == NULL) {
script_pushint(st,0);
return true;
@@ -12656,7 +12500,7 @@ BUILDIN(getmapxy)
if( script_hasdata(st,6) )
sd=map->nick2sd(script_getstr(st,6));
else
- sd=script_rid2sd(st);
+ sd=script->rid2sd(st);
if (sd)
bl = &sd->bl;
@@ -12675,7 +12519,7 @@ BUILDIN(getmapxy)
if(script_hasdata(st,6))
sd=map->nick2sd(script_getstr(st,6));
else
- sd=script_rid2sd(st);
+ sd=script->rid2sd(st);
if (sd && sd->pd)
bl = &sd->pd->bl;
@@ -12686,7 +12530,7 @@ BUILDIN(getmapxy)
if(script_hasdata(st,6))
sd=map->nick2sd(script_getstr(st,6));
else
- sd=script_rid2sd(st);
+ sd=script->rid2sd(st);
if (sd && sd->hd)
bl = &sd->hd->bl;
@@ -12695,7 +12539,7 @@ BUILDIN(getmapxy)
if(script_hasdata(st,6))
sd=map->nick2sd(script_getstr(st,6));
else
- sd=script_rid2sd(st);
+ sd=script->rid2sd(st);
if (sd && sd->md)
bl = &sd->md->bl;
@@ -12704,7 +12548,7 @@ BUILDIN(getmapxy)
if(script_hasdata(st,6))
sd=map->nick2sd(script_getstr(st,6));
else
- sd=script_rid2sd(st);
+ sd=script->rid2sd(st);
if (sd && sd->ed)
bl = &sd->ed->bl;
@@ -12729,10 +12573,10 @@ BUILDIN(getmapxy)
prefix=*name;
if(not_server_variable(prefix))
- sd=script_rid2sd(st);
+ sd=script->rid2sd(st);
else
sd=NULL;
- set_reg(st,sd,num,name,(void*)mapname,script_getref(st,2));
+ script->set_reg(st,sd,num,name,(void*)mapname,script_getref(st,2));
//Set MapX
num=st->stack->stack_data[st->start+3].u.num;
@@ -12740,10 +12584,10 @@ BUILDIN(getmapxy)
prefix=*name;
if(not_server_variable(prefix))
- sd=script_rid2sd(st);
+ sd=script->rid2sd(st);
else
sd=NULL;
- set_reg(st,sd,num,name,(void*)__64BPTRSIZE(x),script_getref(st,3));
+ script->set_reg(st,sd,num,name,(void*)__64BPTRSIZE(x),script_getref(st,3));
//Set MapY
num=st->stack->stack_data[st->start+4].u.num;
@@ -12751,10 +12595,10 @@ BUILDIN(getmapxy)
prefix=*name;
if(not_server_variable(prefix))
- sd=script_rid2sd(st);
+ sd=script->rid2sd(st);
else
sd=NULL;
- set_reg(st,sd,num,name,(void*)__64BPTRSIZE(y),script_getref(st,4));
+ script->set_reg(st,sd,num,name,(void*)__64BPTRSIZE(y),script_getref(st,4));
//Return Success value
script_pushint(st,0);
@@ -12769,7 +12613,7 @@ BUILDIN(logmes)
const char *str;
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return false;
@@ -12786,7 +12630,7 @@ BUILDIN(summon)
struct mob_data *md;
int tick = timer->gettick();
- sd=script_rid2sd(st);
+ sd=script->rid2sd(st);
if (!sd) return true;
str =script_getstr(st,2);
@@ -12795,7 +12639,7 @@ BUILDIN(summon)
timeout=script_getnum(st,4);
if( script_hasdata(st,5) ){
event=script_getstr(st,5);
- check_event(st, event);
+ script->check_event(st, event);
}
clif->skill_poseffect(&sd->bl,AM_CALLHOMUN,1,sd->bl.x,sd->bl.y,tick);
@@ -12837,14 +12681,14 @@ BUILDIN(isequippedcnt)
int i, j, k, id = 1;
int ret = 0;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if (!sd) { //If the player is not attached it is a script error anyway... but better prevent the map server from crashing...
script_pushint(st,0);
return true;
}
for (i=0; id!=0; i++) {
- FETCH (i+2, id) else id = 0;
+ script_fetch(st,i+2, id) else id = 0;
if (id <= 0)
continue;
@@ -12892,7 +12736,7 @@ BUILDIN(isequipped)
//Original hash to reverse it when full check fails.
unsigned int setitem_hash = 0, setitem_hash2 = 0;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if (!sd) { //If the player is not attached it is a script error anyway... but better prevent the map server from crashing...
script_pushint(st,0);
@@ -12902,7 +12746,7 @@ BUILDIN(isequipped)
setitem_hash = sd->bonus.setitem_hash;
setitem_hash2 = sd->bonus.setitem_hash2;
for (i=0; id!=0; i++) {
- FETCH (i+2, id) else id = 0;
+ script_fetch(st,i+2, id) else id = 0;
if (id <= 0)
continue;
flag = 0;
@@ -12973,10 +12817,10 @@ BUILDIN(cardscnt) {
int ret = 0;
int index;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
for (i=0; id!=0; i++) {
- FETCH (i+2, id) else id = 0;
+ script_fetch(st,i+2, id) else id = 0;
if (id <= 0)
continue;
@@ -13009,7 +12853,7 @@ BUILDIN(cardscnt) {
*-------------------------------------------------------*/
BUILDIN(getrefine) {
TBL_PC *sd;
- if ((sd = script_rid2sd(st))!= NULL)
+ if ((sd = script->rid2sd(st))!= NULL)
script_pushint(st,sd->status.inventory[status->current_equip_item_index].refine);
else
script_pushint(st,0);
@@ -13038,10 +12882,10 @@ BUILDIN(unequip)
TBL_PC *sd;
num = script_getnum(st,2);
- sd = script_rid2sd(st);
- if( sd != NULL && num >= 1 && num <= ARRAYLENGTH(equip) )
+ sd = script->rid2sd(st);
+ if( sd != NULL && num >= 1 && num <= ARRAYLENGTH(script->equip) )
{
- i = pc->checkequip(sd,equip[num-1]);
+ i = pc->checkequip(sd,script->equip[num-1]);
if (i >= 0)
pc->unequipitem(sd,i,1|2);
}
@@ -13054,7 +12898,7 @@ BUILDIN(equip)
TBL_PC *sd;
struct item_data *item_data;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
nameid=script_getnum(st,2);
if((item_data = itemdb->exists(nameid)) == NULL)
@@ -13343,7 +13187,7 @@ BUILDIN(explode)
if( !data_isreference(data) )
{
ShowError("script:explode: not a variable\n");
- script_reportdata(data);
+ script->reportdata(data);
st->state = END;
return false;// not a variable
}
@@ -13355,7 +13199,7 @@ BUILDIN(explode)
if( not_array_variable(*name) )
{
ShowError("script:explode: illegal scope\n");
- script_reportdata(data);
+ script->reportdata(data);
st->state = END;
return false;// not supported
}
@@ -13363,14 +13207,14 @@ BUILDIN(explode)
if( !is_string_variable(name) )
{
ShowError("script:explode: not string array\n");
- script_reportdata(data);
+ script->reportdata(data);
st->state = END;
return false;// data type mismatch
}
if( not_server_variable(*name) )
{
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;// no player attached
}
@@ -13378,7 +13222,7 @@ BUILDIN(explode)
while(str[i] != '\0') {
if(str[i] == delimiter && start < SCRIPT_MAX_ARRAYSIZE-1) { //break at delimiter but ignore after reaching last array index
temp[j] = '\0';
- set_reg(st, sd, reference_uid(id, start++), name, (void*)temp, reference_getref(data));
+ script->set_reg(st, sd, reference_uid(id, start++), name, (void*)temp, reference_getref(data));
j = 0;
++i;
} else {
@@ -13387,7 +13231,7 @@ BUILDIN(explode)
}
//set last string
temp[j] = '\0';
- set_reg(st, sd, reference_uid(id, start), name, (void*)temp, reference_getref(data));
+ script->set_reg(st, sd, reference_uid(id, start), name, (void*)temp, reference_getref(data));
aFree(temp);
return true;
@@ -13412,7 +13256,7 @@ BUILDIN(implode)
if( !data_isreference(data) )
{
ShowError("script:implode: not a variable\n");
- script_reportdata(data);
+ script->reportdata(data);
st->state = END;
return false;// not a variable
}
@@ -13423,7 +13267,7 @@ BUILDIN(implode)
if( not_array_variable(*name) )
{
ShowError("script:implode: illegal scope\n");
- script_reportdata(data);
+ script->reportdata(data);
st->state = END;
return false;// not supported
}
@@ -13431,20 +13275,20 @@ BUILDIN(implode)
if( !is_string_variable(name) )
{
ShowError("script:implode: not string array\n");
- script_reportdata(data);
+ script->reportdata(data);
st->state = END;
return false;// data type mismatch
}
if( not_server_variable(*name) )
{
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;// no player attached
}
//count chars
- array_size = getarraysize(st, id, reference_getindex(data), is_string_variable(name), reference_getref(data)) - 1;
+ array_size = script->getarraysize(st, id, reference_getindex(data), is_string_variable(name), reference_getref(data)) - 1;
if(array_size == -1) //empty array check (AmsTaff)
{
@@ -13553,7 +13397,7 @@ BUILDIN(sprintf)
}
if(*p=='n'){ // %n
ShowWarning("buildin_sprintf: Format %%n not supported! Skipping...\n");
- script_reportsrc(st);
+ script->reportsrc(st);
q+=2;
continue;
}
@@ -13612,7 +13456,7 @@ BUILDIN(sprintf)
// Passed more, than needed
if(arg<argc){
ShowWarning("buildin_sprintf: Unused arguments passed.\n");
- script_reportsrc(st);
+ script->reportsrc(st);
}
script_pushstrcopy(st, StrBuf->Value(&final_buf));
@@ -13687,7 +13531,7 @@ BUILDIN(sscanf){
return false;
}
buf_p = reference_getname(data);
- if(not_server_variable(*buf_p) && (sd = script_rid2sd(st))==NULL){
+ if(not_server_variable(*buf_p) && (sd = script->rid2sd(st))==NULL){
script_pushint(st, -1);
if(buf) aFree(buf);
if(ref_str) aFree(ref_str);
@@ -13702,12 +13546,12 @@ BUILDIN(sscanf){
if(sscanf(str, buf, ref_str)==0){
break;
}
- set_reg(st, sd, reference_uid( reference_getid(data), reference_getindex(data) ), buf_p, (void *)(ref_str), reference_getref(data));
+ script->set_reg(st, sd, reference_uid( reference_getid(data), reference_getindex(data) ), buf_p, (void *)(ref_str), reference_getref(data));
} else { // Number
if(sscanf(str, buf, &ref_int)==0){
break;
}
- set_reg(st, sd, reference_uid( reference_getid(data), reference_getindex(data) ), buf_p, (void *)__64BPTRSIZE(ref_int), reference_getref(data));
+ script->set_reg(st, sd, reference_uid( reference_getid(data), reference_getindex(data) ), buf_p, (void *)__64BPTRSIZE(ref_int), reference_getref(data));
}
arg++;
@@ -13941,7 +13785,7 @@ BUILDIN(setnpcdisplay)
else
{
ShowError("script:setnpcdisplay: expected string or number\n");
- script_reportdata(data);
+ script->reportdata(data);
return false;
}
@@ -14054,7 +13898,7 @@ BUILDIN(setd)
if( not_server_variable(*varname) )
{
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
{
ShowError("script:setd: no player attached for player variable '%s'\n", buffer);
@@ -14088,9 +13932,9 @@ int buildin_query_sql_sub(struct script_state* st, Sql* handle)
if( data_isreference(data) ) { // it's a variable
name = reference_getname(data);
if( not_server_variable(*name) && sd == NULL ) { // requires a player
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL ) { // no player attached
- script_reportdata(data);
+ script->reportdata(data);
st->state = END;
return false;
}
@@ -14099,7 +13943,7 @@ int buildin_query_sql_sub(struct script_state* st, Sql* handle)
max_rows = 1;// not an array, limit to one row
} else {
ShowError("script:query_sql: not a variable\n");
- script_reportdata(data);
+ script->reportdata(data);
st->state = END;
return false;
}
@@ -14125,10 +13969,10 @@ int buildin_query_sql_sub(struct script_state* st, Sql* handle)
num_cols = SQL->NumColumns(handle);
if( num_vars < num_cols ) {
ShowWarning("script:query_sql: Too many columns, discarding last %u columns.\n", (unsigned int)(num_cols-num_vars));
- script_reportsrc(st);
+ script->reportsrc(st);
} else if( num_vars > num_cols ) {
ShowWarning("script:query_sql: Too many variables (%u extra).\n", (unsigned int)(num_vars-num_cols));
- script_reportsrc(st);
+ script->reportsrc(st);
}
// Store data
@@ -14149,7 +13993,7 @@ int buildin_query_sql_sub(struct script_state* st, Sql* handle)
}
if( i == max_rows && max_rows < SQL->NumRows(handle) ) {
ShowWarning("script:query_sql: Only %d/%u rows have been stored.\n", max_rows, (unsigned int)SQL->NumRows(handle));
- script_reportsrc(st);
+ script->reportsrc(st);
}
// Free data
@@ -14159,7 +14003,7 @@ int buildin_query_sql_sub(struct script_state* st, Sql* handle)
return true;
}
BUILDIN(query_sql) {
- return buildin_query_sql_sub(st, mmysql_handle);
+ return script->buildin_query_sql_sub(st, mmysql_handle);
}
BUILDIN(query_logsql) {
@@ -14168,7 +14012,7 @@ BUILDIN(query_logsql) {
script_pushint(st,-1);
return false;
}
- return buildin_query_sql_sub(st, logmysql_handle);
+ return script->buildin_query_sql_sub(st, logmysql_handle);
}
//Allows escaping of a given string.
@@ -14210,7 +14054,7 @@ BUILDIN(petstat)
TBL_PC *sd = NULL;
struct pet_data *pd;
int flag = script_getnum(st,2);
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if(!sd || !sd->status.pet_id || !sd->pd){
if(flag == 2)
script_pushconststr(st, "");
@@ -14238,7 +14082,7 @@ BUILDIN(callshop)
struct npc_data *nd;
const char *shopname;
int flag = 0;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if (!sd) {
script_pushint(st,0);
return true;
@@ -14522,7 +14366,7 @@ BUILDIN(checkvending) // check vending [Nab4]
if(script_hasdata(st,2))
sd = map->nick2sd(script_getstr(st,2));
else
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if(sd)
script_pushint(st, sd->state.autotrade ? 2 : sd->state.vending);
@@ -14540,7 +14384,7 @@ BUILDIN(checkchatting) {
if(script_hasdata(st,2))
sd = map->nick2sd(script_getstr(st,2));
else
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if(sd)
script_pushint(st,(sd->chatID != 0));
@@ -14556,7 +14400,7 @@ BUILDIN(checkidle) {
if (script_hasdata(st, 2))
sd = map->nick2sd(script_getstr(st, 2));
else
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if (sd)
script_pushint(st, DIFF_TICK(last_tick, sd->idletime));
@@ -14594,7 +14438,7 @@ BUILDIN(searchitem)
if( !data_isreference(data) )
{
ShowError("script:searchitem: not a variable\n");
- script_reportdata(data);
+ script->reportdata(data);
st->state = END;
return false;// not a variable
}
@@ -14605,14 +14449,14 @@ BUILDIN(searchitem)
if( not_array_variable(*name) )
{
ShowError("script:searchitem: illegal scope\n");
- script_reportdata(data);
+ script->reportdata(data);
st->state = END;
return false;// not supported
}
if( not_server_variable(*name) )
{
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;// no player attached
}
@@ -14620,7 +14464,7 @@ BUILDIN(searchitem)
if( is_string_variable(name) )
{// string array
ShowError("script:searchitem: not an integer array reference\n");
- script_reportdata(data);
+ script->reportdata(data);
st->state = END;
return false;// not supported
}
@@ -14628,7 +14472,7 @@ BUILDIN(searchitem)
for( i = 0; i < count; ++start, ++i )
{// Set array
void* v = (void*)__64BPTRSIZE((int)items[i]->nameid);
- set_reg(st, sd, reference_uid(id, start), name, v, reference_getref(data));
+ script->set_reg(st, sd, reference_uid(id, start), name, v, reference_getref(data));
}
script_pushint(st, count);
@@ -14672,7 +14516,7 @@ int axtoi(const char *hexStg)
BUILDIN(axtoi)
{
const char *hex = script_getstr(st,2);
- script_pushint(st,axtoi(hex));
+ script_pushint(st,script->axtoi(hex));
return true;
}
@@ -14710,7 +14554,7 @@ BUILDIN(pcblockmove) {
if(id)
sd = map->id2sd(id);
else
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if(sd)
sd->state.blockedmove = flag > 0;
@@ -14729,7 +14573,7 @@ BUILDIN(pcfollow) {
if(id)
sd = map->id2sd(id);
else
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if(sd)
pc->follow(sd, targetid);
@@ -14748,7 +14592,7 @@ BUILDIN(pcstopfollow)
if(id)
sd = map->id2sd(id);
else
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if(sd)
pc->stop_following(sd);
@@ -15040,7 +14884,7 @@ BUILDIN(sleep)
ticks = script_getnum(st,2);
// detach the player
- script_detach_rid(st);
+ script->detach_rid(st);
if( ticks <= 0 )
{// do nothing
@@ -15138,7 +14982,7 @@ BUILDIN(getvariableofnpc)
if( !data_isreference(data) )
{// Not a reference (aka varaible name)
ShowError("script:getvariableofnpc: not a variable\n");
- script_reportdata(data);
+ script->reportdata(data);
script_pushnil(st);
st->state = END;
return false;
@@ -15148,7 +14992,7 @@ BUILDIN(getvariableofnpc)
if( *name != '.' || name[1] == '@' )
{// not a npc variable
ShowError("script:getvariableofnpc: invalid scope (not npc variable)\n");
- script_reportdata(data);
+ script->reportdata(data);
script_pushnil(st);
st->state = END;
return false;
@@ -15212,7 +15056,7 @@ BUILDIN(openmail)
{
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
@@ -15225,7 +15069,7 @@ BUILDIN(openauction)
{
TBL_PC* sd;
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if( sd == NULL )
return true;
@@ -15294,7 +15138,7 @@ BUILDIN(mercenary_create)
struct map_session_data *sd;
int class_, contract_time;
- if( (sd = script_rid2sd(st)) == NULL || sd->md || sd->status.mer_id != 0 )
+ if( (sd = script->rid2sd(st)) == NULL || sd->md || sd->status.mer_id != 0 )
return true;
class_ = script_getnum(st,2);
@@ -15308,7 +15152,7 @@ BUILDIN(mercenary_create)
}
BUILDIN(mercenary_heal) {
- struct map_session_data *sd = script_rid2sd(st);
+ struct map_session_data *sd = script->rid2sd(st);
int hp, sp;
if( sd == NULL || sd->md == NULL )
@@ -15321,7 +15165,7 @@ BUILDIN(mercenary_heal) {
}
BUILDIN(mercenary_sc_start) {
- struct map_session_data *sd = script_rid2sd(st);
+ struct map_session_data *sd = script->rid2sd(st);
enum sc_type type;
int tick, val1;
@@ -15337,7 +15181,7 @@ BUILDIN(mercenary_sc_start) {
}
BUILDIN(mercenary_get_calls) {
- struct map_session_data *sd = script_rid2sd(st);
+ struct map_session_data *sd = script->rid2sd(st);
int guild_id;
if( sd == NULL )
@@ -15363,7 +15207,7 @@ BUILDIN(mercenary_get_calls) {
}
BUILDIN(mercenary_set_calls) {
- struct map_session_data *sd = script_rid2sd(st);
+ struct map_session_data *sd = script->rid2sd(st);
int guild_id, value, *calls;
if( sd == NULL )
@@ -15393,7 +15237,7 @@ BUILDIN(mercenary_set_calls) {
}
BUILDIN(mercenary_get_faith) {
- struct map_session_data *sd = script_rid2sd(st);
+ struct map_session_data *sd = script->rid2sd(st);
int guild_id;
if( sd == NULL )
@@ -15419,7 +15263,7 @@ BUILDIN(mercenary_get_faith) {
}
BUILDIN(mercenary_set_faith) {
- struct map_session_data *sd = script_rid2sd(st);
+ struct map_session_data *sd = script->rid2sd(st);
int guild_id, value, *calls;
if( sd == NULL )
@@ -15458,7 +15302,7 @@ BUILDIN(readbook)
struct map_session_data *sd;
int book_id, page;
- if( (sd = script_rid2sd(st)) == NULL )
+ if( (sd = script->rid2sd(st)) == NULL )
return true;
book_id = script_getnum(st,2);
@@ -15474,7 +15318,7 @@ BUILDIN(readbook)
BUILDIN(setquest)
{
- struct map_session_data *sd = script_rid2sd(st);
+ struct map_session_data *sd = script->rid2sd(st);
nullpo_ret(sd);
quest->add(sd, script_getnum(st, 2));
@@ -15483,7 +15327,7 @@ BUILDIN(setquest)
BUILDIN(erasequest)
{
- struct map_session_data *sd = script_rid2sd(st);
+ struct map_session_data *sd = script->rid2sd(st);
nullpo_ret(sd);
quest->delete(sd, script_getnum(st, 2));
@@ -15492,7 +15336,7 @@ BUILDIN(erasequest)
BUILDIN(completequest)
{
- struct map_session_data *sd = script_rid2sd(st);
+ struct map_session_data *sd = script->rid2sd(st);
nullpo_ret(sd);
quest->update_status(sd, script_getnum(st, 2), Q_COMPLETE);
@@ -15501,7 +15345,7 @@ BUILDIN(completequest)
BUILDIN(changequest)
{
- struct map_session_data *sd = script_rid2sd(st);
+ struct map_session_data *sd = script->rid2sd(st);
nullpo_ret(sd);
quest->change(sd, script_getnum(st, 2),script_getnum(st, 3));
@@ -15510,7 +15354,7 @@ BUILDIN(changequest)
BUILDIN(checkquest)
{
- struct map_session_data *sd = script_rid2sd(st);
+ struct map_session_data *sd = script->rid2sd(st);
quest_check_type type = HAVEQUEST;
nullpo_ret(sd);
@@ -15524,7 +15368,7 @@ BUILDIN(checkquest)
}
BUILDIN(showevent) {
- TBL_PC *sd = script_rid2sd(st);
+ TBL_PC *sd = script->rid2sd(st);
struct npc_data *nd = map->id2nd(st->oid);
int state, color;
@@ -15670,7 +15514,7 @@ BUILDIN(bg_monster)
str = script_getstr(st,6);
class_ = script_getnum(st,7);
if( script_hasdata(st,8) ) evt = script_getstr(st,8);
- check_event(st, evt);
+ script->check_event(st, evt);
script_pushint(st, mob->spawn_bg(mapname,x,y,str,class_,evt,bg_id));
return true;
}
@@ -15696,7 +15540,7 @@ BUILDIN(bg_monster_set_team) {
BUILDIN(bg_leave)
{
- struct map_session_data *sd = script_rid2sd(st);
+ struct map_session_data *sd = script->rid2sd(st);
if( sd == NULL || !sd->bg_id )
return true;
@@ -15962,7 +15806,7 @@ BUILDIN(instance_announce) {
return true;
for( i = 0; i < instance->list[instance_id].num_map; i++ )
- map->foreachinmap(buildin_announce_sub, instance->list[instance_id].map[i], BL_PC,
+ map->foreachinmap(script->buildin_announce_sub, instance->list[instance_id].map[i], BL_PC,
mes, strlen(mes)+1, flag&BC_COLOR_MASK, fontColor, fontType, fontSize, fontAlign, fontY);
return true;
@@ -16009,7 +15853,7 @@ BUILDIN(has_instance) {
instance_id = script_getnum(st, 3);
else if( st->instance_id >= 0 )
instance_id = st->instance_id;
- else if( (sd = script_rid2sd(st)) != NULL ) {
+ else if( (sd = script->rid2sd(st)) != NULL ) {
struct party_data *p;
int i = 0, j = 0;
if( sd->instances ) {
@@ -16055,7 +15899,7 @@ BUILDIN(has_instance) {
script_pushconststr(st, maplist[m].name);
return true;
}
-static int buildin_instance_warpall_sub(struct block_list *bl,va_list ap) {
+int buildin_instance_warpall_sub(struct block_list *bl,va_list ap) {
struct map_session_data *sd = ((TBL_PC*)bl);
int mapindex = va_arg(ap,int);
int x = va_arg(ap,int);
@@ -16088,7 +15932,7 @@ BUILDIN(instance_warpall) {
mapindex = map_id2index(m);
- map->foreachininstance(buildin_instance_warpall_sub, instance_id, BL_PC,mapindex,x,y);
+ map->foreachininstance(script->buildin_instance_warpall_sub, instance_id, BL_PC,mapindex,x,y);
return true;
}
@@ -16155,7 +15999,7 @@ BUILDIN(instance_check_party) {
*------------------------------------------*/
BUILDIN(setfont)
{
- struct map_session_data *sd = script_rid2sd(st);
+ struct map_session_data *sd = script->rid2sd(st);
int font = script_getnum(st,2);
if( sd == NULL )
return true;
@@ -16169,7 +16013,7 @@ BUILDIN(setfont)
return true;
}
-static int buildin_mobuseskill_sub(struct block_list *bl,va_list ap)
+int buildin_mobuseskill_sub(struct block_list *bl,va_list ap)
{
TBL_MOB* md = (TBL_MOB*)bl;
struct block_list *tbl;
@@ -16236,14 +16080,14 @@ BUILDIN(areamobuseskill) {
emotion = script_getnum(st,11);
target = script_getnum(st,12);
- map->foreachinrange(buildin_mobuseskill_sub, &center, range, BL_MOB, mobid, skill_id, skill_lv, casttime, cancel, emotion, target);
+ map->foreachinrange(script->buildin_mobuseskill_sub, &center, range, BL_MOB, mobid, skill_id, skill_lv, casttime, cancel, emotion, target);
return true;
}
BUILDIN(progressbar)
{
- struct map_session_data * sd = script_rid2sd(st);
+ struct map_session_data * sd = script->rid2sd(st);
const char * color;
unsigned int second;
@@ -16269,7 +16113,7 @@ BUILDIN(pushpc)
int cells, dx, dy;
struct map_session_data* sd;
- if((sd = script_rid2sd(st))==NULL)
+ if((sd = script->rid2sd(st))==NULL)
{
return true;
}
@@ -16280,7 +16124,7 @@ BUILDIN(pushpc)
if(dir>7)
{
ShowWarning("buildin_pushpc: Invalid direction %d specified.\n", dir);
- script_reportsrc(st);
+ script->reportsrc(st);
dir%= 8; // trim spin-over
}
@@ -16309,7 +16153,7 @@ BUILDIN(buyingstore)
{
struct map_session_data* sd;
- if( ( sd = script_rid2sd(st) ) == NULL ) {
+ if( ( sd = script->rid2sd(st) ) == NULL ) {
return true;
}
@@ -16326,7 +16170,7 @@ BUILDIN(searchstores)
unsigned int uses;
struct map_session_data* sd;
- if( ( sd = script_rid2sd(st) ) == NULL )
+ if( ( sd = script->rid2sd(st) ) == NULL )
{
return true;
}
@@ -16357,7 +16201,7 @@ BUILDIN(showdigit)
int value;
struct map_session_data* sd;
- if( ( sd = script_rid2sd(st) ) == NULL )
+ if( ( sd = script->rid2sd(st) ) == NULL )
{
return true;
}
@@ -16383,7 +16227,7 @@ BUILDIN(showdigit)
**/
BUILDIN(makerune) {
TBL_PC* sd;
- if( (sd = script_rid2sd(st)) == NULL )
+ if( (sd = script->rid2sd(st)) == NULL )
return true;
clif->skill_produce_mix_list(sd,RK_RUNEMASTERY,24);
sd->itemid = script_getnum(st,2);
@@ -16394,7 +16238,7 @@ BUILDIN(makerune) {
**/
BUILDIN(checkdragon) {
TBL_PC* sd;
- if( (sd = script_rid2sd(st)) == NULL )
+ if( (sd = script->rid2sd(st)) == NULL )
return true;
if( pc_isridingdragon(sd) )
script_pushint(st,1);
@@ -16416,7 +16260,7 @@ BUILDIN(setdragon) {
TBL_PC* sd;
int color = script_hasdata(st,2) ? script_getnum(st,2) : 0;
- if( (sd = script_rid2sd(st)) == NULL )
+ if( (sd = script->rid2sd(st)) == NULL )
return true;
if( !pc->checkskill(sd,RK_DRAGONTRAINING) || (sd->class_&MAPID_THIRDMASK) != MAPID_RUNE_KNIGHT )
script_pushint(st,0);//Doesn't have the skill or it's not a Rune Knight
@@ -16447,7 +16291,7 @@ BUILDIN(setdragon) {
**/
BUILDIN(ismounting) {
TBL_PC* sd;
- if( (sd = script_rid2sd(st)) == NULL )
+ if( (sd = script->rid2sd(st)) == NULL )
return true;
if( sd->sc.data[SC_ALL_RIDING] )
script_pushint(st,1);
@@ -16464,7 +16308,7 @@ BUILDIN(ismounting) {
**/
BUILDIN(setmounting) {
TBL_PC* sd;
- if( (sd = script_rid2sd(st)) == NULL )
+ if( (sd = script->rid2sd(st)) == NULL )
return true;
if( sd->sc.option&(OPTION_WUGRIDER|OPTION_RIDING|OPTION_DRAGON|OPTION_MADOGEAR) ){
clif->msgtable(sd->fd, 0X78b);
@@ -16513,7 +16357,7 @@ BUILDIN(getcharip) {
}
}
else
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
/* check for sd and IP */
if (!sd || !session[sd->fd]->client_addr)
@@ -16585,7 +16429,7 @@ BUILDIN(sit) {
sd = map->nick2sd(script_getstr(st, 2));
if (sd == NULL)
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if (!pc_issit(sd))
{
@@ -16603,7 +16447,7 @@ BUILDIN(stand) {
sd = map->nick2sd(script_getstr(st, 2));
if (sd == NULL)
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if (pc_issit(sd))
{
@@ -16621,7 +16465,7 @@ BUILDIN(issit) {
sd = map->nick2sd(script_getstr(st, 2));
if (sd == NULL)
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
if (pc_issit(sd))
script_pushint(st, 1);
@@ -16733,7 +16577,7 @@ BUILDIN(useatcmd) {
cmd = script_getstr(st,2);
if( st->rid ) {
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
fd = sd->fd;
} else {
// Use a dummy character.
@@ -16876,7 +16720,7 @@ BUILDIN(getrandgroupitem) {
/* cleanmap <map_name>;
* cleanarea <map_name>, <x0>, <y0>, <x1>, <y1>; */
-static int atcommand_cleanfloor_sub(struct block_list *bl, va_list ap) {
+int script_cleanfloor_sub(struct block_list *bl, va_list ap) {
nullpo_ret(bl);
map->clearflooritem(bl);
@@ -16894,14 +16738,14 @@ BUILDIN(cleanmap) {
return false;
if ((script_lastdata(st) - 2) < 4) {
- map->foreachinmap(atcommand_cleanfloor_sub, m, BL_ITEM);
+ map->foreachinmap(script->cleanfloor_sub, m, BL_ITEM);
} else {
x0 = script_getnum(st, 3);
y0 = script_getnum(st, 4);
x1 = script_getnum(st, 5);
y1 = script_getnum(st, 6);
if (x0 > 0 && y0 > 0 && x1 > 0 && y1 > 0) {
- map->foreachinarea(atcommand_cleanfloor_sub, m, x0, y0, x1, y1, BL_ITEM);
+ map->foreachinarea(script->cleanfloor_sub, m, x0, y0, x1, y1, BL_ITEM);
} else {
ShowError("cleanarea: invalid coordinate defined!\n");
return false;
@@ -16925,7 +16769,7 @@ BUILDIN(npcskill) {
skill_level = script_getnum(st, 3);
stat_point = script_getnum(st, 4);
npc_level = script_getnum(st, 5);
- sd = script_rid2sd(st);
+ sd = script->rid2sd(st);
nd = (struct npc_data *)map->id2bl(sd->npc_id);
if (stat_point > battle_config.max_third_parameter) {
@@ -17938,17 +17782,17 @@ void script_parse_builtin(void) {
while( *p == '?' ) ++p;
if( *p == '*' ) ++p;
if( *p != 0 ){
- ShowWarning("script_parse_builtin: ignoring function \"%s\" with invalid arg \"%s\".\n", BUILDIN[i].name, BUILDIN[i].arg);
- } else if( *skip_word(BUILDIN[i].name) != 0 ){
- ShowWarning("script_parse_builtin: ignoring function with invalid name \"%s\" (must be a word).\n", BUILDIN[i].name);
+ ShowWarning("parse_builtin: ignoring function \"%s\" with invalid arg \"%s\".\n", BUILDIN[i].name, BUILDIN[i].arg);
+ } else if( *script->skip_word(BUILDIN[i].name) != 0 ){
+ ShowWarning("parse_builtin: ignoring function with invalid name \"%s\" (must be a word).\n", BUILDIN[i].name);
} else {
int slen = strlen(BUILDIN[i].arg), offset = start + i;
n = script->add_str(BUILDIN[i].name);
- if (!strcmp(BUILDIN[i].name, "set")) buildin_set_ref = n;
- else if (!strcmp(BUILDIN[i].name, "callsub")) buildin_callsub_ref = n;
- else if (!strcmp(BUILDIN[i].name, "callfunc")) buildin_callfunc_ref = n;
- else if (!strcmp(BUILDIN[i].name, "getelementofarray") ) buildin_getelementofarray_ref = n;
+ if (!strcmp(BUILDIN[i].name, "set")) script->buildin_set_ref = n;
+ else if (!strcmp(BUILDIN[i].name, "callsub")) script->buildin_callsub_ref = n;
+ else if (!strcmp(BUILDIN[i].name, "callfunc")) script->buildin_callfunc_ref = n;
+ else if (!strcmp(BUILDIN[i].name, "getelementofarray") ) script->buildin_getelementofarray_ref = n;
if( script->str_data[n].func && script->str_data[n].func != BUILDIN[i].func )
continue;/* something replaced it, skip. */
@@ -17984,6 +17828,9 @@ void script_label_add(int key, int pos) {
}
void script_defaults(void) {
+ // aegis->athena slot position conversion table
+ unsigned int equip[SCRIPT_EQUIP_TABLE_SIZE] = {EQP_HEAD_TOP,EQP_ARMOR,EQP_HAND_L,EQP_HAND_R,EQP_GARMENT,EQP_SHOES,EQP_ACC_L,EQP_ACC_R,EQP_HEAD_MID,EQP_HEAD_LOW,EQP_COSTUME_HEAD_LOW,EQP_COSTUME_HEAD_MID,EQP_COSTUME_HEAD_TOP,EQP_COSTUME_GARMENT};
+
script = &script_s;
script->st_db = NULL;
@@ -18006,6 +17853,7 @@ void script_defaults(void) {
script->str_buf = NULL;
script->str_size = 0;
script->str_pos = 0;
+ memset(script->str_hash, 0, sizeof(script->str_hash));
script->word_buf = NULL;
script->word_size = 0;
@@ -18016,6 +17864,29 @@ void script_defaults(void) {
script->label_count = 0;
script->labels_size = 0;
+ script->buf = NULL;
+ script->pos = 0, script->size = 0;
+
+ script->parse_options = 0;
+ script->buildin_set_ref = 0;
+ script->buildin_callsub_ref = 0;
+ script->buildin_callfunc_ref = 0;
+ script->buildin_getelementofarray_ref = 0;
+
+ memset(script->error_jump,0,sizeof(script->error_jump));
+ script->error_msg = NULL;
+ script->error_pos = NULL;
+ script->error_report = 0;
+ script->parser_current_src = NULL;
+ script->parser_current_file = NULL;
+ script->parser_current_line = 0;
+
+ memset(&script->syntax,0,sizeof(script->syntax));
+
+ script->parse_syntax_for_flag = 0;
+
+ memcpy(script->equip, &equip, sizeof(script->equip));
+
memset(&script->config, 0, sizeof(script->config));
script->autobonus_db = NULL;
@@ -18078,6 +17949,77 @@ void script_defaults(void) {
script->queue_create = script_hqueue_create;
script->queue_clear = script_hqueue_clear;
+ script->parse_curly_close = parse_curly_close;
+ script->parse_syntax_close = parse_syntax_close;
+ script->parse_syntax_close_sub = parse_syntax_close_sub;
+ script->parse_syntax = parse_syntax;
+ script->get_com = get_com;
+ script->get_num = get_num;
+ script->op2name = script_op2name;
+ script->reportsrc = script_reportsrc;
+ script->reportdata = script_reportdata;
+ script->reportfunc = script_reportfunc;
+ script->disp_error_message2 = disp_error_message2;
+ script->disp_warning_message = disp_warning_message;
+ script->check_event = check_event;
+ script->calc_hash = calc_hash;
+ script->addb = add_scriptb;
+ script->addc = add_scriptc;
+ script->addi = add_scripti;
+ script->addl = add_scriptl;
+ script->set_label = set_label;
+ script->skip_word = skip_word;
+ script->add_word = add_word;
+ script->parse_callfunc = parse_callfunc;
+ script->parse_nextline = parse_nextline;
+ script->parse_variable = parse_variable;
+ script->parse_simpleexpr = parse_simpleexpr;
+ script->parse_expr = parse_expr;
+ script->parse_line = parse_line;
+ script->read_constdb = read_constdb;
+ script->print_line = script_print_line;
+ script->errorwarning_sub = script_errorwarning_sub;
+ script->set_reg = set_reg;
+ script->stack_expand = stack_expand;
+ script->push_retinfo = push_retinfo;
+ script->pop_val = pop_val;
+ script->op_3 = op_3;
+ script->op_2str = op_2str;
+ script->op_2num = op_2num;
+ script->op_2 = op_2;
+ script->op_1 = op_1;
+ script->check_buildin_argtype = script_check_buildin_argtype;
+ script->detach_state = script_detach_state;
+ script->db_free_code_sub = db_script_free_code_sub;
+ script->add_autobonus = script_add_autobonus;
+ script->menu_countoptions = menu_countoptions;
+ script->buildin_areawarp_sub = buildin_areawarp_sub;
+ script->buildin_areapercentheal_sub = buildin_areapercentheal_sub;
+ script->getarraysize = getarraysize;
+ script->buildin_delitem_delete = buildin_delitem_delete;
+ script->buildin_delitem_search = buildin_delitem_search;
+ script->buildin_killmonster_sub_strip = buildin_killmonster_sub_strip;
+ script->buildin_killmonster_sub = buildin_killmonster_sub;
+ script->buildin_killmonsterall_sub_strip = buildin_killmonsterall_sub_strip;
+ script->buildin_killmonsterall_sub = buildin_killmonsterall_sub;
+ script->buildin_announce_sub = buildin_announce_sub;
+ script->buildin_getareausers_sub = buildin_getareausers_sub;
+ script->buildin_getareadropitem_sub = buildin_getareadropitem_sub;
+ script->mapflag_pvp_sub = script_mapflag_pvp_sub;
+ script->buildin_pvpoff_sub = buildin_pvpoff_sub;
+ script->buildin_maprespawnguildid_sub_pc = buildin_maprespawnguildid_sub_pc;
+ script->buildin_maprespawnguildid_sub_mob = buildin_maprespawnguildid_sub_mob;
+ script->buildin_mobcount_sub = buildin_mobcount_sub;
+ script->playBGM_sub = playBGM_sub;
+ script->playBGM_foreachpc_sub = playBGM_foreachpc_sub;
+ script->soundeffect_sub = soundeffect_sub;
+ script->buildin_query_sql_sub = buildin_query_sql_sub;
+ script->axtoi = axtoi;
+ script->buildin_instance_warpall_sub = buildin_instance_warpall_sub;
+ script->buildin_mobuseskill_sub = buildin_mobuseskill_sub;
+ script->cleanfloor_sub = script_cleanfloor_sub;
+ script->run_func = run_func;
+
/* script_config base */
script->config.warn_func_mismatch_argtypes = 1;
script->config.warn_func_mismatch_paramnum = 1;
diff --git a/src/map/script.h b/src/map/script.h
index 97f9bdb8c..c00086ef9 100644
--- a/src/map/script.h
+++ b/src/map/script.h
@@ -1,11 +1,16 @@
-// Copyright (c) Athena Dev Teams - Licensed under GNU GPL
-// For more information, see LICENCE in the main folder
+// Copyright (c) Hercules Dev Team, licensed under GNU GPL.
+// See the LICENSE file
+// Portions Copyright (c) Athena Dev Teams
#ifndef _SCRIPT_H_
#define _SCRIPT_H_
+#include "../common/strlib.h" //StringBuf
#include "map.h" //EVENT_NAME_LENGTH
+#include <setjmp.h>
+#include <errno.h>
+
/**
* Declarations
**/
@@ -17,6 +22,130 @@ struct eri;
**/
#define NUM_WHISPER_VAR 10
+/// Maximum amount of elements in script arrays (soon getting ducked)
+#define SCRIPT_MAX_ARRAYSIZE 128
+
+#define SCRIPT_BLOCK_SIZE 512
+
+// Using a prime number for SCRIPT_HASH_SIZE should give better distributions
+#define SCRIPT_HASH_SIZE 1021
+
+// Specifies which string hashing method to use
+//#define SCRIPT_HASH_DJB2
+//#define SCRIPT_HASH_SDBM
+#define SCRIPT_HASH_ELF
+
+#define SCRIPT_EQUIP_TABLE_SIZE 14
+
+//#define SCRIPT_DEBUG_DISP
+//#define SCRIPT_DEBUG_DISASM
+//#define SCRIPT_DEBUG_HASH
+//#define SCRIPT_DEBUG_DUMP_STACK
+
+///////////////////////////////////////////////////////////////////////////////
+//## TODO possible enhancements: [FlavioJS]
+// - 'callfunc' supporting labels in the current npc "::LabelName"
+// - 'callfunc' supporting labels in other npcs "NpcName::LabelName"
+// - 'function FuncName;' function declarations reverting to global functions
+// if local label isn't found
+// - join callfunc and callsub's functionality
+// - remove dynamic allocation in add_word()
+// - remove GETVALUE / SETVALUE
+// - clean up the set_reg / set_val / setd_sub mess
+// - detect invalid label references at parse-time
+
+//
+// struct script_state* st;
+//
+
+/// Returns the script_data at the target index
+#define script_getdata(st,i) ( &((st)->stack->stack_data[(st)->start + (i)]) )
+/// Returns if the stack contains data at the target index
+#define script_hasdata(st,i) ( (st)->end > (st)->start + (i) )
+/// Returns the index of the last data in the stack
+#define script_lastdata(st) ( (st)->end - (st)->start - 1 )
+/// Pushes an int into the stack
+#define script_pushint(st,val) script->push_val((st)->stack, C_INT, (val),NULL)
+/// Pushes a string into the stack (script engine frees it automatically)
+#define script_pushstr(st,val) script->push_str((st)->stack, C_STR, (val))
+/// Pushes a copy of a string into the stack
+#define script_pushstrcopy(st,val) script->push_str((st)->stack, C_STR, aStrdup(val))
+/// Pushes a constant string into the stack (must never change or be freed)
+#define script_pushconststr(st,val) script->push_str((st)->stack, C_CONSTSTR, (val))
+/// Pushes a nil into the stack
+#define script_pushnil(st) script->push_val((st)->stack, C_NOP, 0,NULL)
+/// Pushes a copy of the data in the target index
+#define script_pushcopy(st,i) script->push_copy((st)->stack, (st)->start + (i))
+
+#define script_isstring(st,i) data_isstring(script_getdata(st,i))
+#define script_isint(st,i) data_isint(script_getdata(st,i))
+
+#define script_getnum(st,val) script->conv_num(st, script_getdata(st,val))
+#define script_getstr(st,val) script->conv_str(st, script_getdata(st,val))
+#define script_getref(st,val) ( script_getdata(st,val)->ref )
+
+// Note: "top" functions/defines use indexes relative to the top of the stack
+// -1 is the index of the data at the top
+
+/// Returns the script_data at the target index relative to the top of the stack
+#define script_getdatatop(st,i) ( &((st)->stack->stack_data[(st)->stack->sp + (i)]) )
+/// Pushes a copy of the data in the target index relative to the top of the stack
+#define script_pushcopytop(st,i) script->push_copy((st)->stack, (st)->stack->sp + (i))
+/// Removes the range of values [start,end[ relative to the top of the stack
+#define script_removetop(st,start,end) ( script->pop_stack((st), ((st)->stack->sp + (start)), (st)->stack->sp + (end)) )
+
+//
+// struct script_data* data;
+//
+
+/// Returns if the script data is a string
+#define data_isstring(data) ( (data)->type == C_STR || (data)->type == C_CONSTSTR )
+/// Returns if the script data is an int
+#define data_isint(data) ( (data)->type == C_INT )
+/// Returns if the script data is a reference
+#define data_isreference(data) ( (data)->type == C_NAME )
+/// Returns if the script data is a label
+#define data_islabel(data) ( (data)->type == C_POS )
+/// Returns if the script data is an internal script function label
+#define data_isfunclabel(data) ( (data)->type == C_USERFUNC_POS )
+
+/// Returns if this is a reference to a constant
+#define reference_toconstant(data) ( script->str_data[reference_getid(data)].type == C_INT )
+/// Returns if this a reference to a param
+#define reference_toparam(data) ( script->str_data[reference_getid(data)].type == C_PARAM )
+/// Returns if this a reference to a variable
+//##TODO confirm it's C_NAME [FlavioJS]
+#define reference_tovariable(data) ( script->str_data[reference_getid(data)].type == C_NAME )
+/// Returns the unique id of the reference (id and index)
+#define reference_getuid(data) ( (data)->u.num )
+/// Returns the id of the reference
+#define reference_getid(data) ( (int32)(reference_getuid(data) & 0x00ffffff) )
+/// Returns the array index of the reference
+#define reference_getindex(data) ( (int32)(((uint32)(reference_getuid(data) & 0xff000000)) >> 24) )
+/// Returns the name of the reference
+#define reference_getname(data) ( script->str_buf + script->str_data[reference_getid(data)].str )
+/// Returns the linked list of uid-value pairs of the reference (can be NULL)
+#define reference_getref(data) ( (data)->ref )
+/// Returns the value of the constant
+#define reference_getconstant(data) ( script->str_data[reference_getid(data)].val )
+/// Returns the type of param
+#define reference_getparamtype(data) ( script->str_data[reference_getid(data)].val )
+
+/// Composes the uid of a reference from the id and the index
+#define reference_uid(id,idx) ( (int32)((((uint32)(id)) & 0x00ffffff) | (((uint32)(idx)) << 24)) )
+
+#define not_server_variable(prefix) ( (prefix) != '$' && (prefix) != '.' && (prefix) != '\'')
+#define not_array_variable(prefix) ( (prefix) != '$' && (prefix) != '@' && (prefix) != '.' && (prefix) != '\'' )
+#define is_string_variable(name) ( (name)[strlen(name) - 1] == '$' )
+
+#define BUILDIN(x) bool buildin_ ## x (struct script_state* st)
+#define BUILDIN_A(x) buildin_ ## x
+
+#define script_fetch(st, n, t) \
+ if( script_hasdata(st,n) ) \
+ (t)=script_getnum(st,n);
+
+
/**
* Enumerations
**/
@@ -79,6 +208,88 @@ enum script_parse_options {
SCRIPT_RETURN_EMPTY_SCRIPT = 0x4// returns the script object instead of NULL for empty scripts
};
+enum { LABEL_NEXTLINE=1,LABEL_START };
+
+// for advanced scripting support ( nested if, switch, while, for, do-while, function, etc )
+// [Eoe / jA 1080, 1081, 1094, 1164]
+enum curly_type {
+ TYPE_NULL = 0,
+ TYPE_IF,
+ TYPE_SWITCH,
+ TYPE_WHILE,
+ TYPE_FOR,
+ TYPE_DO,
+ TYPE_USERFUNC,
+ TYPE_ARGLIST // function argument list
+};
+
+enum e_arglist {
+ ARGLIST_UNDEFINED = 0,
+ ARGLIST_NO_PAREN = 1,
+ ARGLIST_PAREN = 2,
+};
+
+/*==========================================
+ * (Only those needed) local declaration prototype
+ * - those could be used server-wide so that the scans are done once during processing and never again,
+ * - doing so would also improve map zone processing and storage [Ind]
+ *------------------------------------------*/
+
+enum {
+ MF_NOMEMO, //0
+ MF_NOTELEPORT,
+ MF_NOSAVE,
+ MF_NOBRANCH,
+ MF_NOPENALTY,
+ MF_NOZENYPENALTY,
+ MF_PVP,
+ MF_PVP_NOPARTY,
+ MF_PVP_NOGUILD,
+ MF_GVG,
+ MF_GVG_NOPARTY, //10
+ MF_NOTRADE,
+ MF_NOSKILL,
+ MF_NOWARP,
+ MF_PARTYLOCK,
+ MF_NOICEWALL,
+ MF_SNOW,
+ MF_FOG,
+ MF_SAKURA,
+ MF_LEAVES,
+ /* 21 - 22 free */
+ MF_CLOUDS = 23,
+ MF_CLOUDS2,
+ MF_FIREWORKS,
+ MF_GVG_CASTLE,
+ MF_GVG_DUNGEON,
+ MF_NIGHTENABLED,
+ MF_NOBASEEXP,
+ MF_NOJOBEXP, //30
+ MF_NOMOBLOOT,
+ MF_NOMVPLOOT,
+ MF_NORETURN,
+ MF_NOWARPTO,
+ MF_NIGHTMAREDROP,
+ MF_ZONE,
+ MF_NOCOMMAND,
+ MF_NODROP,
+ MF_JEXP,
+ MF_BEXP, //40
+ MF_NOVENDING,
+ MF_LOADEVENT,
+ MF_NOCHAT,
+ MF_NOEXPPENALTY,
+ MF_GUILDLOCK,
+ MF_TOWN,
+ MF_AUTOTRADE,
+ MF_ALLOWKS,
+ MF_MONSTER_NOTELEPORT,
+ MF_PVP_NOCALCRANK, //50
+ MF_BATTLEGROUND,
+ MF_RESET,
+ MF_NOTOMB
+};
+
/**
* Structures
**/
@@ -209,106 +420,21 @@ struct script_label_entry {
int key,pos;
};
-///////////////////////////////////////////////////////////////////////////////
-//## TODO possible enhancements: [FlavioJS]
-// - 'callfunc' supporting labels in the current npc "::LabelName"
-// - 'callfunc' supporting labels in other npcs "NpcName::LabelName"
-// - 'function FuncName;' function declarations reverting to global functions
-// if local label isn't found
-// - join callfunc and callsub's functionality
-// - remove dynamic allocation in add_word()
-// - remove GETVALUE / SETVALUE
-// - clean up the set_reg / set_val / setd_sub mess
-// - detect invalid label references at parse-time
-
-//
-// struct script_state* st;
-//
-
-/// Returns the script_data at the target index
-#define script_getdata(st,i) ( &((st)->stack->stack_data[(st)->start + (i)]) )
-/// Returns if the stack contains data at the target index
-#define script_hasdata(st,i) ( (st)->end > (st)->start + (i) )
-/// Returns the index of the last data in the stack
-#define script_lastdata(st) ( (st)->end - (st)->start - 1 )
-/// Pushes an int into the stack
-#define script_pushint(st,val) script->push_val((st)->stack, C_INT, (val),NULL)
-/// Pushes a string into the stack (script engine frees it automatically)
-#define script_pushstr(st,val) script->push_str((st)->stack, C_STR, (val))
-/// Pushes a copy of a string into the stack
-#define script_pushstrcopy(st,val) script->push_str((st)->stack, C_STR, aStrdup(val))
-/// Pushes a constant string into the stack (must never change or be freed)
-#define script_pushconststr(st,val) script->push_str((st)->stack, C_CONSTSTR, (val))
-/// Pushes a nil into the stack
-#define script_pushnil(st) script->push_val((st)->stack, C_NOP, 0,NULL)
-/// Pushes a copy of the data in the target index
-#define script_pushcopy(st,i) script->push_copy((st)->stack, (st)->start + (i))
-
-#define script_isstring(st,i) data_isstring(script_getdata(st,i))
-#define script_isint(st,i) data_isint(script_getdata(st,i))
-
-#define script_getnum(st,val) script->conv_num(st, script_getdata(st,val))
-#define script_getstr(st,val) script->conv_str(st, script_getdata(st,val))
-#define script_getref(st,val) ( script_getdata(st,val)->ref )
-
-// Note: "top" functions/defines use indexes relative to the top of the stack
-// -1 is the index of the data at the top
-
-/// Returns the script_data at the target index relative to the top of the stack
-#define script_getdatatop(st,i) ( &((st)->stack->stack_data[(st)->stack->sp + (i)]) )
-/// Pushes a copy of the data in the target index relative to the top of the stack
-#define script_pushcopytop(st,i) script->push_copy((st)->stack, (st)->stack->sp + (i))
-/// Removes the range of values [start,end[ relative to the top of the stack
-#define script_removetop(st,start,end) ( script->pop_stack((st), ((st)->stack->sp + (start)), (st)->stack->sp + (end)) )
-
-//
-// struct script_data* data;
-//
-
-/// Returns if the script data is a string
-#define data_isstring(data) ( (data)->type == C_STR || (data)->type == C_CONSTSTR )
-/// Returns if the script data is an int
-#define data_isint(data) ( (data)->type == C_INT )
-/// Returns if the script data is a reference
-#define data_isreference(data) ( (data)->type == C_NAME )
-/// Returns if the script data is a label
-#define data_islabel(data) ( (data)->type == C_POS )
-/// Returns if the script data is an internal script function label
-#define data_isfunclabel(data) ( (data)->type == C_USERFUNC_POS )
-
-/// Returns if this is a reference to a constant
-#define reference_toconstant(data) ( script->str_data[reference_getid(data)].type == C_INT )
-/// Returns if this a reference to a param
-#define reference_toparam(data) ( script->str_data[reference_getid(data)].type == C_PARAM )
-/// Returns if this a reference to a variable
-//##TODO confirm it's C_NAME [FlavioJS]
-#define reference_tovariable(data) ( script->str_data[reference_getid(data)].type == C_NAME )
-/// Returns the unique id of the reference (id and index)
-#define reference_getuid(data) ( (data)->u.num )
-/// Returns the id of the reference
-#define reference_getid(data) ( (int32)(reference_getuid(data) & 0x00ffffff) )
-/// Returns the array index of the reference
-#define reference_getindex(data) ( (int32)(((uint32)(reference_getuid(data) & 0xff000000)) >> 24) )
-/// Returns the name of the reference
-#define reference_getname(data) ( script->str_buf + script->str_data[reference_getid(data)].str )
-/// Returns the linked list of uid-value pairs of the reference (can be NULL)
-#define reference_getref(data) ( (data)->ref )
-/// Returns the value of the constant
-#define reference_getconstant(data) ( script->str_data[reference_getid(data)].val )
-/// Returns the type of param
-#define reference_getparamtype(data) ( script->str_data[reference_getid(data)].val )
-
-/// Composes the uid of a reference from the id and the index
-#define reference_uid(id,idx) ( (int32)((((uint32)(id)) & 0x00ffffff) | (((uint32)(idx)) << 24)) )
-
-#define not_server_variable(prefix) ( (prefix) != '$' && (prefix) != '.' && (prefix) != '\'')
-#define not_array_variable(prefix) ( (prefix) != '$' && (prefix) != '@' && (prefix) != '.' && (prefix) != '\'' )
-#define is_string_variable(name) ( (name)[strlen(name) - 1] == '$' )
-
-#define BUILDIN(x) bool buildin_ ## x (struct script_state* st)
-#define BUILDIN_A(x) buildin_ ## x
+struct script_syntax_data {
+ struct {
+ enum curly_type type;
+ int index;
+ int count;
+ int flag;
+ struct linkdb_node *case_label;
+ } curly[256]; // Information right parenthesis
+ int curly_count; // The number of right brackets
+ int index; // Number of the syntax used in the script
+};
-/* script.c interface (incomplete) */
+/**
+ * Interface
+ **/
struct script_interface {
/* */
DBMap *st_db;
@@ -332,6 +458,7 @@ struct script_interface {
char *str_buf;
int str_size; // size of the buffer
int str_pos; // next position to be assigned
+ int str_hash[SCRIPT_HASH_SIZE];
/* */
char *word_buf;
int word_size;
@@ -344,6 +471,32 @@ struct script_interface {
/* */
struct Script_Config config;
/* */
+ /// temporary buffer for passing around compiled bytecode
+ /// @see add_scriptb, set_label, parse_script
+ unsigned char* buf;
+ int pos, size;
+ /* */
+ struct script_syntax_data syntax;
+ /* */
+ int parse_options;
+ // important buildin function references for usage in scripts
+ int buildin_set_ref;
+ int buildin_callsub_ref;
+ int buildin_callfunc_ref;
+ int buildin_getelementofarray_ref;
+ /* */
+ jmp_buf error_jump;
+ char* error_msg;
+ const char* error_pos;
+ int error_report; // if the error should produce output
+ // Used by disp_warning_message
+ const char* parser_current_src;
+ const char* parser_current_file;
+ int parser_current_line;
+ int parse_syntax_for_flag;
+ // aegis->athena slot position conversion table
+ unsigned int equip[SCRIPT_EQUIP_TABLE_SIZE];
+ /* */
/* Caches compiled autoscript item code. */
/* Note: This is not cleared when reloading itemdb. */
DBMap* autobonus_db; // char* script -> char* bytecode
@@ -405,6 +558,77 @@ struct script_interface {
bool (*queue_remove) (int idx, int var);
int (*queue_create) (void);
void (*queue_clear) (int idx);
+ /* */
+ const char * (*parse_curly_close) (const char *p);
+ const char * (*parse_syntax_close) (const char *p);
+ const char * (*parse_syntax_close_sub) (const char *p, int *flag);
+ const char * (*parse_syntax) (const char *p);
+ c_op (*get_com) (unsigned char *scriptbuf, int *pos);
+ int (*get_num) (unsigned char *scriptbuf, int *pos);
+ const char* (*op2name) (int op);
+ void (*reportsrc) (struct script_state *st);
+ void (*reportdata) (struct script_data *data);
+ void (*reportfunc) (struct script_state *st);
+ void (*disp_error_message2) (const char *mes, const char *pos, int report);
+ void (*disp_warning_message) (const char *mes, const char *pos);
+ void (*check_event) (struct script_state *st, const char *evt);
+ unsigned int (*calc_hash) (const char *p);
+ void (*addb) (int a);
+ void (*addc) (int a);
+ void (*addi) (int a);
+ void (*addl) (int l);
+ void (*set_label) (int l, int pos, const char *script_pos);
+ const char* (*skip_word) (const char *p);
+ int (*add_word) (const char *p);
+ const char* (*parse_callfunc) (const char *p, int require_paren, int is_custom);
+ void (*parse_nextline) (bool first, const char *p);
+ const char* (*parse_variable) (const char *p);
+ const char* (*parse_simpleexpr) (const char *p);
+ const char* (*parse_expr) (const char *p);
+ const char* (*parse_line) (const char *p);
+ void (*read_constdb) (void);
+ const char* (*print_line) (StringBuf *buf, const char *p, const char *mark, int line);
+ void (*errorwarning_sub) (StringBuf *buf, const char *src, const char *file, int start_line, const char *error_msg, const char *error_pos);
+ int (*set_reg) (struct script_state *st, TBL_PC *sd, int num, const char *name, const void *value, struct DBMap **ref);
+ void (*stack_expand) (struct script_stack *stack);
+ struct script_data* (*push_retinfo) (struct script_stack *stack, struct script_retinfo *ri, DBMap **ref);
+ int (*pop_val) (struct script_state *st);
+ void (*op_3) (struct script_state *st, int op);
+ void (*op_2str) (struct script_state *st, int op, const char *s1, const char *s2);
+ void (*op_2num) (struct script_state *st, int op, int i1, int i2);
+ void (*op_2) (struct script_state *st, int op);
+ void (*op_1) (struct script_state *st, int op);
+ void (*check_buildin_argtype) (struct script_state *st, int func);
+ void (*detach_state) (struct script_state *st, bool dequeue_event);
+ int (*db_free_code_sub) (DBKey key, DBData *data, va_list ap);
+ void (*add_autobonus) (const char *autobonus);
+ int (*menu_countoptions) (const char *str, int max_count, int *total);
+ int (*buildin_areawarp_sub) (struct block_list *bl, va_list ap);
+ int (*buildin_areapercentheal_sub) (struct block_list *bl, va_list ap);
+ int32 (*getarraysize) (struct script_state *st, int32 id, int32 idx, int isstring, struct DBMap **ref);
+ void (*buildin_delitem_delete) (struct map_session_data *sd, int idx, int *amount, bool delete_items);
+ bool (*buildin_delitem_search) (struct map_session_data *sd, struct item *it, bool exact_match);
+ int (*buildin_killmonster_sub_strip) (struct block_list *bl, va_list ap);
+ int (*buildin_killmonster_sub) (struct block_list *bl, va_list ap);
+ int (*buildin_killmonsterall_sub_strip) (struct block_list *bl, va_list ap);
+ int (*buildin_killmonsterall_sub) (struct block_list *bl, va_list ap);
+ int (*buildin_announce_sub) (struct block_list *bl, va_list ap);
+ int (*buildin_getareausers_sub) (struct block_list *bl, va_list ap);
+ int (*buildin_getareadropitem_sub) (struct block_list *bl, va_list ap);
+ int (*mapflag_pvp_sub) (struct block_list *bl, va_list ap);
+ int (*buildin_pvpoff_sub) (struct block_list *bl, va_list ap);
+ int (*buildin_maprespawnguildid_sub_pc) (struct map_session_data *sd, va_list ap);
+ int (*buildin_maprespawnguildid_sub_mob) (struct block_list *bl, va_list ap);
+ int (*buildin_mobcount_sub) (struct block_list *bl, va_list ap);
+ int (*playBGM_sub) (struct block_list *bl, va_list ap);
+ int (*playBGM_foreachpc_sub) (struct map_session_data *sd, va_list args);
+ int (*soundeffect_sub) (struct block_list *bl, va_list ap);
+ int (*buildin_query_sql_sub) (struct script_state *st, Sql *handle);
+ int (*axtoi) (const char *hexStg);
+ int (*buildin_instance_warpall_sub) (struct block_list *bl, va_list ap);
+ int (*buildin_mobuseskill_sub) (struct block_list *bl, va_list ap);
+ int (*cleanfloor_sub) (struct block_list *bl, va_list ap);
+ int (*run_func) (struct script_state *st);
};
struct script_interface *script;