// Copyright (c) Hercules Dev Team, licensed under GNU GPL. // 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" #include "../common/nullpo.h" #include "../common/random.h" #include "../common/showmsg.h" #include "../common/socket.h" // usage: getcharip #include "../common/strlib.h" #include "../common/timer.h" #include "../common/utils.h" #include "map.h" #include "path.h" #include "clif.h" #include "chrif.h" #include "itemdb.h" #include "pc.h" #include "status.h" #include "storage.h" #include "mob.h" #include "npc.h" #include "pet.h" #include "mapreg.h" #include "homunculus.h" #include "instance.h" #include "mercenary.h" #include "intif.h" #include "skill.h" #include "status.h" #include "chat.h" #include "battle.h" #include "battleground.h" #include "party.h" #include "guild.h" #include "atcommand.h" #include "log.h" #include "unit.h" #include "pet.h" #include "mail.h" #include "script.h" #include "quest.h" #include "elemental.h" #include "../config/core.h" #include #include #include #include #ifndef WIN32 #include #endif #include #include #include #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) { 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) { 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 switch( op ) { RETURN_OP_NAME(C_NOP); RETURN_OP_NAME(C_POS); RETURN_OP_NAME(C_INT); RETURN_OP_NAME(C_PARAM); RETURN_OP_NAME(C_FUNC); RETURN_OP_NAME(C_STR); RETURN_OP_NAME(C_CONSTSTR); RETURN_OP_NAME(C_ARG); RETURN_OP_NAME(C_NAME); RETURN_OP_NAME(C_EOL); RETURN_OP_NAME(C_RETINFO); RETURN_OP_NAME(C_USERFUNC); RETURN_OP_NAME(C_USERFUNC_POS); // operators RETURN_OP_NAME(C_OP3); RETURN_OP_NAME(C_LOR); RETURN_OP_NAME(C_LAND); RETURN_OP_NAME(C_LE); RETURN_OP_NAME(C_LT); RETURN_OP_NAME(C_GE); RETURN_OP_NAME(C_GT); RETURN_OP_NAME(C_EQ); RETURN_OP_NAME(C_NE); RETURN_OP_NAME(C_XOR); RETURN_OP_NAME(C_OR); RETURN_OP_NAME(C_AND); RETURN_OP_NAME(C_ADD); RETURN_OP_NAME(C_SUB); RETURN_OP_NAME(C_MUL); RETURN_OP_NAME(C_DIV); RETURN_OP_NAME(C_MOD); RETURN_OP_NAME(C_NEG); RETURN_OP_NAME(C_LNOT); RETURN_OP_NAME(C_NOT); RETURN_OP_NAME(C_R_SHIFT); RETURN_OP_NAME(C_L_SHIFT); default: ShowDebug("script_op2name: unexpected op=%d\n", op); return "???"; } #undef RETURN_OP_NAME } #ifdef DEBUG_DUMP_STACK static void script_dump_stack(struct script_state* st) { int i; ShowMessage("\tstart = %d\n", st->start); ShowMessage("\tend = %d\n", st->end); ShowMessage("\tdefsp = %d\n", st->stack->defsp); ShowMessage("\tsp = %d\n", st->stack->sp); for( i = 0; i < st->stack->sp; ++i ) { struct script_data* data = &st->stack->stack_data[i]; ShowMessage("\t[%d] %s", i, script_op2name(data->type)); switch( data->type ) { case C_INT: case C_POS: ShowMessage(" %d\n", data->u.num); break; case C_STR: case C_CONSTSTR: ShowMessage(" \"%s\"\n", data->u.str); break; case C_NAME: ShowMessage(" \"%s\" (id=%d ref=%p subtype=%s)\n", reference_getname(data), data->u.num, data->ref, script_op2name(script->str_data[data->u.num].type)); break; case C_RETINFO: { struct script_retinfo* ri = data->u.ri; ShowMessage(" %p {var_function=%p, script=%p, pos=%d, nargs=%d, defsp=%d}\n", ri, ri->var_function, ri->script, ri->pos, ri->nargs, ri->defsp); } break; default: ShowMessage("\n"); break; } } } #endif /// Reports on the console the src of a script error. static void script_reportsrc(struct script_state *st) { struct block_list* bl; if( st->oid == 0 ) return; //Can't report source. bl = iMap->id2bl(st->oid); if( bl == NULL ) return; switch( bl->type ) { case BL_NPC: if( bl->m >= 0 ) ShowDebug("Source (NPC): %s at %s (%d,%d)\n", ((struct npc_data *)bl)->name, map[bl->m].name, bl->x, bl->y); else ShowDebug("Source (NPC): %s (invisible/not on a map)\n", ((struct npc_data *)bl)->name); break; default: if( bl->m >= 0 ) ShowDebug("Source (Non-NPC type %d): name %s at %s (%d,%d)\n", bl->type, iStatus->get_name(bl), map[bl->m].name, bl->x, bl->y); else ShowDebug("Source (Non-NPC type %d): name %s (invisible/not on a map)\n", bl->type, iStatus->get_name(bl)); break; } } /// Reports on the console information about the script data. static void script_reportdata(struct script_data* data) { if( data == NULL ) return; switch( data->type ) { case C_NOP:// no value ShowDebug("Data: nothing (nil)\n"); break; case C_INT:// number ShowDebug("Data: number value=%d\n", data->u.num); break; case C_STR: case C_CONSTSTR:// string if( data->u.str ) { ShowDebug("Data: string value=\"%s\"\n", data->u.str); } else { ShowDebug("Data: string value=NULL\n"); } break; case C_NAME:// reference if( reference_tovariable(data) ) {// variable const char* name = reference_getname(data); if( not_array_variable(*name) ) ShowDebug("Data: variable name='%s'\n", name); else ShowDebug("Data: variable name='%s' index=%d\n", name, reference_getindex(data)); } else if( reference_toconstant(data) ) {// constant ShowDebug("Data: constant name='%s' value=%d\n", reference_getname(data), reference_getconstant(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)); } break; case C_POS:// label ShowDebug("Data: label pos=%d\n", data->u.num); break; default: 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) { int i, params, id; struct script_data* data; if( !script_hasdata(st,0) ) {// no stack return; } data = script_getdata(st,0); if( !data_isreference(data) || script->str_data[reference_getid(data)].type != C_FUNC ) {// script currently not executing a built-in function or corrupt stack return; } id = reference_getid(data); params = script_lastdata(st)-1; if( params > 0 ) { ShowDebug("Function: %s (%d parameter%s):\n", script->get_str(id), params, ( params == 1 ) ? "" : "s"); for( i = 2; i <= script_lastdata(st); i++ ) { script_reportdata(script_getdata(st,i)); } } else { ShowDebug("Function: %s (no parameters)\n", script->get_str(id)); } } /*========================================== * Output error message *------------------------------------------*/ static 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 ); } #define disp_error_message(mes,pos) 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); } /// Checks event parameter validity static 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); } } /*========================================== * Hashes the input string *------------------------------------------*/ static unsigned int calc_hash(const char* p) { unsigned int h; #if defined(SCRIPT_HASH_DJB2) h = 5381; while( *p ) // hash*33 + c h = ( h << 5 ) + h + ((unsigned char)TOLOWER(*p++)); #elif defined(SCRIPT_HASH_SDBM) h = 0; while( *p ) // hash*65599 + c h = ( h << 6 ) + ( h << 16 ) - h + ((unsigned char)TOLOWER(*p++)); #elif defined(SCRIPT_HASH_ELF) // UNIX ELF hash h = 0; while( *p ){ unsigned int g; h = ( h << 4 ) + ((unsigned char)TOLOWER(*p++)); g = h & 0xF0000000; if( g ) { h ^= g >> 24; h &= ~g; } } #else // athena hash h = 0; while( *p ) h = ( h << 1 ) + ( h >> 3 ) + ( h >> 5 ) + ( h >> 8 ) + (unsigned char)TOLOWER(*p++); #endif return h % SCRIPT_HASH_SIZE; } /*========================================== * script->str_data manipulation functions *------------------------------------------*/ /// Looks up string using the provided id. const char* script_get_str(int id) { Assert( id >= LABEL_START && id < script->str_size ); return script->str_buf+script->str_data[id].str; } /// Returns the uid of the string, or -1. int script_search_str(const char* p) { int i; for( i = str_hash[calc_hash(p)]; i != 0; i = script->str_data[i].next ) if( strcasecmp(script->get_str(i),p) == 0 ) return i; return -1; } /// Stores a copy of the string and returns its id. /// If an identical string is already present, returns its id instead. int script_add_str(const char* p) { int i, h; int len; h = calc_hash(p); if( str_hash[h] == 0 ) {// empty bucket, add new node here 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 ) { if( strcasecmp(script->get_str(i),p) == 0 ) return i; // string already in list if( script->str_data[i].next == 0 ) break; // reached the end } // append node to end of list script->str_data[i].next = script->str_num; } // grow list if neccessary if( script->str_num >= script->str_data_size ) { script->str_data_size += 1280; RECREATE(script->str_data,struct str_data_struct,script->str_data_size); memset(script->str_data + (script->str_data_size - 1280), '\0', 1280); } len=(int)strlen(p); // grow string buffer if neccessary while( script->str_pos+len+1 >= script->str_size ) { script->str_size += 10240; RECREATE(script->str_buf,char,script->str_size); memset(script->str_buf + (script->str_size - 10240), '\0', 10240); } safestrncpy(script->str_buf+script->str_pos, p, len+1); script->str_data[script->str_num].type = C_NOP; script->str_data[script->str_num].str = script->str_pos; script->str_data[script->str_num].val = 0; script->str_data[script->str_num].next = 0; script->str_data[script->str_num].func = NULL; script->str_data[script->str_num].backpatch = -1; script->str_data[script->str_num].label = -1; script->str_pos += len+1; return script->str_num++; } /// Appends 1 byte to the script buffer. static void add_scriptb(int a) { if( script_pos+1 >= script_size ) { script_size += SCRIPT_BLOCK_SIZE; RECREATE(script_buf,unsigned char,script_size); } 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) { while( a >= 0x40 ) { add_scriptb((a&0x3f)|0x40); a = (a - 0x40) >> 6; } add_scriptb(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) { while( a >= 0x40 ) { add_scriptb((a&0x3f)|0xc0); a = (a - 0x40) >> 6; } add_scriptb(a|0x80); } /// Appends a script->str_data object (label/function/variable/integer) to the script buffer. /// /// @param l The id of the script->str_data entry // Maximum up to 16M static 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); 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); break; case C_INT: add_scripti(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); break; default: // assume C_NAME add_scriptc(C_NAME); add_scriptb(l); add_scriptb(l>>8); add_scriptb(l>>16); break; } } /*========================================== * Resolve the label *------------------------------------------*/ void set_label(int l,int pos, const char* script_pos) { int i,next; if(script->str_data[l].type==C_INT || script->str_data[l].type==C_PARAM || script->str_data[l].type==C_FUNC) { //Prevent overwriting constants values, parameters and built-in functions [Skotlex] disp_error_message("set_label: invalid label name",script_pos); return; } if(script->str_data[l].label!=-1){ disp_error_message("set_label: dup label ",script_pos); return; } 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); i=next; } } /// Skips spaces and/or comments. const char* script_skip_space(const char* p) { if( p == NULL ) return NULL; for(;;) { while( ISSPACE(*p) ) ++p; if( *p == '/' && p[1] == '/' ) {// line comment while(*p && *p!='\n') ++p; } else if( *p == '/' && p[1] == '*' ) {// block comment p += 2; for(;;) { if( *p == '\0' ) { 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] == '/' ) {// end of block comment p += 2; break; } ++p; } } else break; } return 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) { // prefix switch( *p ) { case '@':// temporary char variable ++p; break; case '#':// account variable p += ( p[1] == '#' ? 2 : 1 ); break; case '\'':// instance variable ++p; break; case '.':// npc variable p += ( p[1] == '@' ? 2 : 1 ); break; case '$':// global variable p += ( p[1] == '@' ? 2 : 1 ); break; } while( ISALNUM(*p) || *p == '_' || *p == '\'' ) ++p; // postfix if( *p == '$' )// string p++; return p; } /// Adds a word to script->str_data. /// @see skip_word /// @see script->add_str static int add_word(const char* p) { int len; int i; // Check for a word len = 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); // Duplicate the word if( len+1 > script->word_size ) RECREATE(script->word_buf, char, (script->word_size = (len+1))); memcpy(script->word_buf, p, len); script->word_buf[len] = 0; // add the word i = script->add_str(script->word_buf); return i; } /// Parses a function call. /// The argument list can have parenthesis or not. /// The number of arguments is checked. static const char* parse_callfunc(const char* p, int require_paren, int is_custom) { const char *p2; char *arg = NULL; int func; func = add_word(p); if( script->str_data[func].type == C_FUNC ){ char argT = 0; // buildin function add_scriptl(func); add_scriptc(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]; if( *arg == 0 ) disp_error_message("parse_callfunc: callsub has no arguments, please review its definition",p); if( *arg != '*' ) ++arg; // count func as argument } else { #ifdef SCRIPT_CALLFUNC_CHECK const char* name = script->get_str(func); if( !is_custom && strdb_get(script->userfunc_db, name) == NULL ) { #endif 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]; if( *arg != '*' ) ++ arg; } #endif } p = skip_word(p); p = script->skip_space(p); syntax.curly[syntax.curly_count].type = TYPE_ARGLIST; syntax.curly[syntax.curly_count].count = 0; if( *p == ';' ) {// ';' syntax.curly[syntax.curly_count].flag = ARGLIST_NO_PAREN; } else if( *p == '(' && *(p2=script->skip_space(p+1)) == ')' ) {// '(' ')' syntax.curly[syntax.curly_count].flag = ARGLIST_PAREN; p = p2; /* } else if( 0 && require_paren && *p != '(' ) {// syntax.curly[syntax.curly_count].flag = ARGLIST_NO_PAREN; */ } else {// if( require_paren ){ if( *p != '(' ) disp_error_message("need '('",p); ++p; // skip '(' syntax.curly[syntax.curly_count].flag = ARGLIST_PAREN; } else if( *p == '(' ){ syntax.curly[syntax.curly_count].flag = ARGLIST_UNDEFINED; } else { syntax.curly[syntax.curly_count].flag = ARGLIST_NO_PAREN; } ++syntax.curly_count; while( *arg ) { p2=script->parse_subexpr(p,-1); if( p == p2 ) break; // not an argument if( *arg != '*' ) ++arg; // next argument p=script->skip_space(p2); if( *arg == 0 || *p != ',' ) break; // no more arguments ++p; // skip comma } --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 ) disp_error_message("parse_callfunc: DEBUG last curly is not an argument list",p); if( syntax.curly[syntax.curly_count].flag == ARGLIST_PAREN ){ if( *p != ')' ) disp_error_message("parse_callfunc: expected ')' to close argument list",p); ++p; } add_scriptc(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) { if( !first ) { add_scriptc(C_EOL); // mark end of line for stack cleanup set_label(LABEL_NEXTLINE, script_pos, p); // fix up '-' labels } // initialize data for new '-' label fix up scheduling script->str_data[LABEL_NEXTLINE].type = C_NOP; script->str_data[LABEL_NEXTLINE].backpatch = -1; script->str_data[LABEL_NEXTLINE].label = -1; } /// Parse a variable assignment using the direct equals operator /// @param p script position where the function should run from /// @return NULL if not a variable assignment, the new position otherwise const char* parse_variable(const char* p) { int i, j, word; c_op type = C_NOP; const char *p2 = NULL; const char *var = p; // skip the variable where applicable p = skip_word(p); p = script->skip_space(p); if( p == NULL ) {// end of the line or invalid buffer return NULL; } if( *p == '[' ) {// array variable so process the array as appropriate for( p2 = p, i = 0, j = 1; p; ++ i ) { if( *p ++ == ']' && --(j) == 0 ) break; if( *p == '[' ) ++ j; } if( !(p = script->skip_space(p)) ) {// end of line or invalid characters remaining disp_error_message("Missing right expression or closing bracket for variable.", p); } } if( type == C_NOP && !( ( p[0] == '=' && p[1] != '=' && (type = C_EQ) ) // = || ( p[0] == '+' && p[1] == '=' && (type = C_ADD) ) // += || ( p[0] == '-' && p[1] == '=' && (type = C_SUB) ) // -= || ( p[0] == '^' && p[1] == '=' && (type = C_XOR) ) // ^= || ( p[0] == '|' && p[1] == '=' && (type = C_OR ) ) // |= || ( p[0] == '&' && p[1] == '=' && (type = C_AND) ) // &= || ( p[0] == '*' && p[1] == '=' && (type = C_MUL) ) // *= || ( p[0] == '/' && p[1] == '=' && (type = C_DIV) ) // /= || ( p[0] == '%' && p[1] == '=' && (type = C_MOD) ) // %= || ( p[0] == '~' && p[1] == '=' && (type = C_NOT) ) // ~= || ( p[0] == '+' && p[1] == '+' && (type = C_ADD_PP) ) // ++ || ( p[0] == '-' && p[1] == '-' && (type = C_SUB_PP) ) // -- || ( p[0] == '<' && p[1] == '<' && p[2] == '=' && (type = C_L_SHIFT) ) // <<= || ( p[0] == '>' && p[1] == '>' && p[2] == '=' && (type = C_R_SHIFT) ) // >>= ) ) {// failed to find a matching operator combination so invalid return NULL; } switch( type ) { case C_EQ: {// incremental modifier p = script->skip_space( &p[1] ); } break; case C_L_SHIFT: case C_R_SHIFT: {// left or right shift modifier p = script->skip_space( &p[3] ); } break; default: {// normal incremental command p = script->skip_space( &p[2] ); } } if( p == NULL ) {// end of line or invalid buffer return NULL; } // push the set function onto the stack add_scriptl(buildin_set_ref); add_scriptc(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; // increment the total curly count for the position in the script ++ syntax.curly_count; // parse the variable currently being modified word = 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 disp_error_message("Cannot modify a variable which has the same name as a function or label.", p); } if( p2 ) {// process the variable index const char* p3 = NULL; // push the getelementofarray method into the stack add_scriptl(buildin_getelementofarray_ref); add_scriptc(C_ARG); add_scriptl(word); // process the sub-expression for this assignment p3 = script->parse_subexpr(p2 + 1, 1); p3 = script->skip_space(p3); if( *p3 != ']' ) {// closing parenthesis is required for this script disp_error_message("Missing closing ']' parenthesis for the variable assignment.", p3); } // push the closing function stack operator onto the stack add_scriptc(C_FUNC); p3 ++; } else {// simply push the variable or value onto the stack add_scriptl(word); } if( type != C_EQ ) add_scriptc(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); } 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); } } // decrement the curly count for the position within the script -- syntax.curly_count; // close the script by appending the function operator add_scriptc(C_FUNC); // push the buffer from the method return p; } /*========================================== * Analysis section *------------------------------------------*/ const char* parse_simpleexpr(const char *p) { long long i; p=script->skip_space(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; 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( *p == ',' ){ syntax.curly[i].flag = ARGLIST_PAREN; return p; } else syntax.curly[i].flag = ARGLIST_NO_PAREN; } if( *p != ')' ) disp_error_message("parse_simpleexpr: unmatched ')'",p); ++p; } else if(ISDIGIT(*p) || ((*p=='-' || *p=='+') && ISDIGIT(p[1]))){ char *np; while(*p == '0' && ISDIGIT(p[1])) 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); } else if( i > INT_MAX ) { i = INT_MAX; disp_warning_message("parse_simpleexpr: overflow detected, capping value to INT_MAX",p); } add_scripti((int)i); p=np; } else if(*p=='"'){ add_scriptc(C_STR); p++; while( *p && *p != '"' ){ if( (unsigned char)p[-1] <= 0x7e && *p == '\\' ) { char buf[8]; size_t len = sv->skip_escaped_c(p) - p; size_t n = sv->unescape_c(buf, p, len); 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); continue; } else if( *p == '\n' ) disp_error_message("parse_simpleexpr: unexpected newline @ string",p); add_scriptb(*p++); } if(!*p) disp_error_message("parse_simpleexpr: unexpected end of file @ string",p); add_scriptb(0); p++; //'"' } else { int l; const char* pv; // label , register , function etc if(skip_word(p)==p) disp_error_message("parse_simpleexpr: unexpected character",p); l=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); #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); } } #endif if( (pv = parse_variable(p)) ) {// successfully processed a variable assignment return pv; } p=skip_word(p); if( *p == '[' ){ // array(name[i] => getelementofarray(name,i) ) add_scriptl(buildin_getelementofarray_ref); add_scriptc(C_ARG); add_scriptl(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); }else add_scriptl(l); } return p; } /*========================================== * Analysis of the expression *------------------------------------------*/ const char* script_parse_subexpr(const char* p,int limit) { int op,opl,len; const char* tmpp; p=script->skip_space(p); if( *p == '-' ){ tmpp = script->skip_space(p+1); if( *tmpp == ';' || *tmpp == ',' ){ add_scriptl(LABEL_NEXTLINE); p++; return p; } } if((op=C_NEG,*p=='-') || (op=C_LNOT,*p=='!') || (op=C_NOT,*p=='~')){ p=script->parse_subexpr(p+1,10); add_scriptc(op); } else p=parse_simpleexpr(p); p=script->skip_space(p); while(( (op=C_OP3,opl=0,len=1,*p=='?') || (op=C_ADD,opl=8,len=1,*p=='+') || (op=C_SUB,opl=8,len=1,*p=='-') || (op=C_MUL,opl=9,len=1,*p=='*') || (op=C_DIV,opl=9,len=1,*p=='/') || (op=C_MOD,opl=9,len=1,*p=='%') || (op=C_LAND,opl=2,len=2,*p=='&' && p[1]=='&') || (op=C_AND,opl=6,len=1,*p=='&') || (op=C_LOR,opl=1,len=2,*p=='|' && p[1]=='|') || (op=C_OR,opl=5,len=1,*p=='|') || (op=C_XOR,opl=4,len=1,*p=='^') || (op=C_EQ,opl=3,len=2,*p=='=' && p[1]=='=') || (op=C_NE,opl=3,len=2,*p=='!' && p[1]=='=') || (op=C_R_SHIFT,opl=7,len=2,*p=='>' && p[1]=='>') || (op=C_GE,opl=3,len=2,*p=='>' && p[1]=='=') || (op=C_GT,opl=3,len=1,*p=='>') || (op=C_L_SHIFT,opl=7,len=2,*p=='<' && p[1]=='<') || (op=C_LE,opl=3,len=2,*p=='<' && p[1]=='=') || (op=C_LT,opl=3,len=1,*p=='<')) && opl>limit){ p+=len; if(op == C_OP3) { p=script->parse_subexpr(p,-1); p=script->skip_space(p); if( *(p++) != ':') disp_error_message("parse_subexpr: need ':'", p-1); p=script->parse_subexpr(p,-1); } else { p=script->parse_subexpr(p,opl); } add_scriptc(op); p=script->skip_space(p); } return p; /* return first untreated operator */ } /*========================================== * Evaluation of the expression *------------------------------------------*/ const char* parse_expr(const char *p) { switch(*p){ case ')': case ';': case ':': case '[': case ']': case '}': disp_error_message("parse_expr: unexpected char",p); } p=script->parse_subexpr(p,-1); return p; } /*========================================== * Analysis of the line *------------------------------------------*/ const char* parse_line(const char* p) { const char* p2; p=script->skip_space(p); if(*p==';') { //Close decision for if(); for(); while(); p = parse_syntax_close(p + 1); return p; } if(*p==')' && 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++; return p + 1; } else if(p[0] == '}') { return parse_curly_close(p); } // Syntax-related processing p2 = parse_syntax(p); if(p2 != NULL) return p2; // attempt to process a variable assignment p2 = parse_variable(p); if( p2 != NULL ) {// variable assignment processed so leave the method return parse_syntax_close(p2 + 1); } p = parse_callfunc(p,0,0); p = script->skip_space(p); if(parse_syntax_for_flag) { if( *p != ')' ) disp_error_message("parse_line: need ')'",p); } else { if( *p != ';' ) disp_error_message("parse_line: need ';'",p); } //Binding decision for if(), for(), while() p = parse_syntax_close(p+1); return p; } // { ... } Closing process const char* parse_curly_close(const char* p) { if(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--; //Close decision if, for , while p = parse_syntax_close(p + 1); return p; } else if(syntax.curly[syntax.curly_count-1].type == TYPE_SWITCH) { //Closing switch() int pos = 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--; // 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--; // You are here labeled sprintf(label,"__SW%x_%x",syntax.curly[pos].index,syntax.curly[pos].count); l=script->add_str(label); set_label(l,script_pos, p); if(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--; } // Label end sprintf(label,"__SW%x_FIN",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--; //Closing decision if, for , while p = parse_syntax_close(p + 1); return p; } else { disp_error_message("parse_curly_close: unexpected string",p); return p + 1; } } // Syntax-related processing // break, case, continue, default, do, for, function, // if, switch, while ? will handle this internally. const char* parse_syntax(const char* p) { const char *p2 = skip_word(p); switch(*p) { case 'B': case 'b': if(p2 - p == 5 && !strncasecmp(p,"break",5)) { // break Processing char label[256]; int pos = syntax.curly_count - 1; while(pos >= 0) { if(syntax.curly[pos].type == TYPE_DO) { sprintf(label,"goto __DO%x_FIN;",syntax.curly[pos].index); break; } else if(syntax.curly[pos].type == TYPE_FOR) { sprintf(label,"goto __FR%x_FIN;",syntax.curly[pos].index); break; } else if(syntax.curly[pos].type == TYPE_WHILE) { sprintf(label,"goto __WL%x_FIN;",syntax.curly[pos].index); break; } else if(syntax.curly[pos].type == TYPE_SWITCH) { sprintf(label,"goto __SW%x_FIN;",syntax.curly[pos].index); break; } pos--; } 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--; } 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); return p; } break; case 'c': 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) { 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) { //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--; // You are here labeled sprintf(label,"__SW%x_%x",syntax.curly[pos].index,syntax.curly[pos].count); l=script->add_str(label); set_label(l,script_pos, p); } //Decision statement switch p = script->skip_space(p2); if(p == p2) { disp_error_message("parse_syntax: expect space ' '",p); } // check whether case label is integer or not v = strtol(p,&np,0); if(np == p) { //Check for constants p2 = 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); } else { //Numeric value if((*p == '-' || *p == '+') && ISDIGIT(p[1])) // pre-skip because '-' can not skip_word p++; p = skip_word(p); if(np != p) disp_error_message("parse_syntax: 'case' label is not an integer",np); } p = script->skip_space(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; // Bad I do not parse twice p2 = parse_line(label); parse_line(p2); syntax.curly_count--; if(syntax.curly[pos].count != 1) { // Label after the completion of FALLTHRU sprintf(label,"__SW%x_%xJ",syntax.curly[pos].index,syntax.curly[pos].count); l=script->add_str(label); set_label(l,script_pos,p); } // check duplication of case label [Rayce] if(linkdb_search(&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); 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--; 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; 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 break; } else if(syntax.curly[pos].type == TYPE_FOR) { sprintf(label,"goto __FR%x_NXT;",syntax.curly[pos].index); break; } else if(syntax.curly[pos].type == TYPE_WHILE) { sprintf(label,"goto __WL%x_NXT;",syntax.curly[pos].index); break; } pos--; } 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--; } 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); return p; } break; case 'd': 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) { disp_error_message("parse_syntax: unexpected 'default'",p); } else if(syntax.curly[pos].flag) { disp_error_message("parse_syntax: dup 'default'",p); } else { char label[256]; int l; // Put the label location p = script->skip_space(p2); if(*p != ':') { disp_error_message("parse_syntax: need ':'",p); } sprintf(label,"__SW%x_%x",syntax.curly[pos].index,syntax.curly[pos].count); l=script->add_str(label); 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--; // The default label sprintf(label,"__SW%x_DEF",syntax.curly[pos].index); l=script->add_str(label); set_label(l,script_pos,p); syntax.curly[syntax.curly_count - 1].flag = 1; syntax.curly[pos].count++; } return p + 1; } else if(p2 - p == 2 && !strncasecmp(p,"do",2)) { int l; 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; // Label of the (do) form here sprintf(label,"__DO%x_BGN",syntax.curly[syntax.curly_count].index); l=script->add_str(label); set_label(l,script_pos,p); syntax.curly_count++; return p; } break; case 'f': case 'F': 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++; p=script->skip_space(p2); if(*p != '(') disp_error_message("parse_syntax: need '('",p); p++; // Execute the initialization statement syntax.curly[syntax.curly_count++].type = TYPE_NULL; p=parse_line(p); syntax.curly_count--; // Form the start of label decision sprintf(label,"__FR%x_J",syntax.curly[pos].index); l=script->add_str(label); set_label(l,script_pos,p); p=script->skip_space(p); if(*p == ';') { // For (; Because the pattern of always true ;) ; } 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); p=script->skip_space(p); add_scriptl(script->add_str(label)); add_scriptc(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--; // Labels to form the next loop sprintf(label,"__FR%x_NXT",syntax.curly[pos].index); l=script->add_str(label); 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; // 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--; // Loop start labeling sprintf(label,"__FR%x_BGN",syntax.curly[pos].index); l=script->add_str(label); set_label(l,script_pos,p); return p; } else if( p2 - p == 8 && strncasecmp(p,"function",8) == 0 ) {// internal script function const char *func_name; func_name = script->skip_space(p2); p = 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); if( *p2 == ';' ) {// function ; // function declaration - just register the name int l; l = 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 ) ; // already registered else disp_error_message("parse_syntax:function: function name is invalid", func_name); // Close condition of if, for, while p = parse_syntax_close(p2 + 1); return p; } else if(*p2 == '{') {// function 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; // 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; // Set the position of the function (label) l=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); } else disp_error_message("parse_syntax:function: function name is invalid", func_name); return script->skip_space(p); } else { disp_error_message("expect ';' or '{' at function syntax",p); } } break; case 'i': case 'I': if(p2 - p == 2 && !strncasecmp(p,"if",2)) { // If process char label[256]; p=script->skip_space(p2); if(*p != '(') { //Prevent if this {} non-c 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); p=script->skip_space(p); add_scriptl(script->add_str(label)); add_scriptc(C_FUNC); return p; } break; case 's': case 'S': if(p2 - p == 6 && !strncasecmp(p,"switch",6)) { // Processing of switch () char label[256]; p=script->skip_space(p2); 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); p=script->skip_space(p); if(*p != '{') { disp_error_message("parse_syntax: need '{'",p); } add_scriptc(C_FUNC); return p + 1; } break; case 'w': case 'W': if(p2 - p == 5 && !strncasecmp(p,"while",5)) { int l; char label[256]; p=script->skip_space(p2); 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; // Form the start of label decision sprintf(label,"__WL%x_NXT",syntax.curly[syntax.curly_count].index); l=script->add_str(label); 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); p=script->skip_space(p); add_scriptl(script->add_str(label)); add_scriptc(C_FUNC); return p; } break; } return NULL; } const char* parse_syntax_close(const char *p) { // If (...) for (...) hoge (); as to make sure closed closed once again int flag; do { p = parse_syntax_close_sub(p,&flag); } while(flag); return p; } // Close judgment if, for, while, of do // flag == 1 : closed // flag == 0 : not closed const char* parse_syntax_close_sub(const char* p,int* flag) { char label[256]; int pos = syntax.curly_count - 1; int l; *flag = 1; if(syntax.curly_count <= 0) { *flag = 0; return p; } else if(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); // 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--; // Put the label of the location sprintf(label,"__IF%x_%x",syntax.curly[pos].index,syntax.curly[pos].count); l=script->add_str(label); set_label(l,script_pos,p); 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)) { // else or else - if p = script->skip_space(p2); p2 = 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); p=script->skip_space(p); add_scriptl(script->add_str(label)); add_scriptc(C_FUNC); *flag = 0; return p; } else { // else if(!syntax.curly[pos].flag) { syntax.curly[pos].flag = 1; *flag = 0; return p; } } } // Close if syntax.curly_count--; // Put the label of the final location sprintf(label,"__IF%x_FIN",syntax.curly[pos].index); l=script->add_str(label); set_label(l,script_pos,p); if(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) { int l; char label[256]; const char *p2; if(syntax.curly[pos].flag) { // (Come here continue) to form the label here sprintf(label,"__DO%x_NXT",syntax.curly[pos].index); l=script->add_str(label); 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); if(p2 - p != 5 || strncasecmp(p,"while",5)) disp_error_message("parse_syntax: need 'while'",p); p = script->skip_space(p2); if(*p != '(') { disp_error_message("need '('",p); } // do-block end is a new line 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); p=script->skip_space(p); add_scriptl(script->add_str(label)); add_scriptc(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--; // Form label of the end point conditions sprintf(label,"__DO%x_FIN",syntax.curly[pos].index); l=script->add_str(label); 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--; return p; } else if(syntax.curly[pos].type == TYPE_FOR) { // for-block end is a new line 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--; // End for labeling sprintf(label,"__FR%x_FIN",syntax.curly[pos].index); l=script->add_str(label); set_label(l,script_pos,p); syntax.curly_count--; return p; } else if(syntax.curly[pos].type == TYPE_WHILE) { // while-block end is a new line 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--; // End while labeling sprintf(label,"__WL%x_FIN",syntax.curly[pos].index); l=script->add_str(label); set_label(l,script_pos,p); syntax.curly_count--; return p; } else if(syntax.curly[syntax.curly_count-1].type == TYPE_USERFUNC) { int pos = 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--; // Put the label of the location sprintf(label,"__FN%x_FIN",syntax.curly[pos].index); l=script->add_str(label); set_label(l,script_pos,p); syntax.curly_count--; return p; } else { *flag = 0; return p; } } /// Retrieves the value of a constant. bool script_get_constant(const char* name, int* value) { int n = script->search_str(name); if( n == -1 || script->str_data[n].type != C_INT ) {// not found or not a constant return false; } value[0] = script->str_data[n].val; return true; } /// Creates new constant or parameter with given value. void script_set_constant(const char* name, int value, bool isparameter) { int n = script->add_str(name); if( script->str_data[n].type == C_NOP ) {// new script->str_data[n].type = isparameter ? C_PARAM : C_INT; script->str_data[n].val = value; } 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)); } } /* adds data to a existent constant in the database, inserted normally via parse */ void script_set_constant2(const char *name, int value, bool isparameter) { int n = script->add_str(name); if( ( script->str_data[n].type == C_NAME || script->str_data[n].type == C_PARAM ) && ( script->str_data[n].val != 0 || script->str_data[n].backpatch != -1 ) ) { // existing parameter or constant ShowNotice("Conflicting item/script var '%s', prioritising the script var\n",name); return; } if( script->str_data[n].type != C_NOP ) { script->str_data[n].func = NULL; script->str_data[n].backpatch = -1; script->str_data[n].label = -1; } script->str_data[n].type = isparameter ? C_PARAM : C_INT; script->str_data[n].val = value; } /* same as constant2 except it will override if necessary, used to clear conflicts during reload */ void script_set_constant_force(const char *name, int value, bool isparameter) { int n = script->add_str(name); if( script->str_data[n].type == C_PARAM ) return;/* the one type we don't mess with, reload doesn't affect it. */ if( script->str_data[n].type != C_NOP ) { script->str_data[n].type = C_NOP; script->str_data[n].val = 0; script->str_data[n].func = NULL; script->str_data[n].backpatch = -1; script->str_data[n].label = -1; } } /*========================================== * Reading constant databases * const.txt *------------------------------------------*/ static void read_constdb(void) { FILE *fp; char line[1024],name[1024],val[1024]; int type; sprintf(line, "%s/const.txt", iMap->db_path); fp=fopen(line, "r"); if(fp==NULL){ ShowError("can't read %s\n", line); return ; } while(fgets(line, sizeof(line), fp)) { if(line[0]=='/' && line[1]=='/') continue; 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); } } fclose(fp); } /*========================================== * Display emplacement line of script *------------------------------------------*/ static const char* script_print_line(StringBuf* buf, const char* p, const char* mark, int line) { int i; if( p == NULL || !p[0] ) return NULL; if( line < 0 ) StrBuf->Printf(buf, "*% 5d : ", -line); else StrBuf->Printf(buf, " % 5d : ", line); for(i=0;p[i] && p[i] != '\n';i++){ if(p + i != mark) StrBuf->Printf(buf, "%c", p[i]); else StrBuf->Printf(buf, "\'%c\'", p[i]); } StrBuf->AppendStr(buf, "\n"); return p+i+(p[i] == '\n' ? 1 : 0); } void script_errorwarning_sub(StringBuf *buf, const char* src, const char* file, int start_line, const char* error_msg, const char* error_pos) { // Find the line where the error occurred int j; int line = start_line; const char *p; const char *linestart[5] = { NULL, NULL, NULL, NULL, NULL }; for(p=src;p && *p;line++){ const char *lineend=strchr(p,'\n'); if(lineend==NULL || error_pos= 0 ) StrBuf->Printf(buf, "script error on %s line %d\n", file, line); else StrBuf->Printf(buf, "script error on %s item ID %d\n", file, -line); StrBuf->Printf(buf, " %s\n", error_msg); for(j = 0; j < 5; j++ ) { script_print_line(buf, linestart[j], NULL, line + j - 5); } 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 ); } } void script_error(const char* src, const char* file, int start_line, const char* error_msg, const char* error_pos) { StringBuf buf; StrBuf->Init(&buf); StrBuf->AppendStr(&buf, "\a\n"); script_errorwarning_sub(&buf, src, file, start_line, error_msg, error_pos); ShowError("%s", StrBuf->Value(&buf)); StrBuf->Destroy(&buf); } void script_warning(const char* src, const char* file, int start_line, const char* error_msg, const char* error_pos) { StringBuf buf; StrBuf->Init(&buf); script_errorwarning_sub(&buf, src, file, start_line, error_msg, error_pos); ShowWarning("%s", StrBuf->Value(&buf)); StrBuf->Destroy(&buf); } /*========================================== * Analysis of the script *------------------------------------------*/ struct script_code* parse_script(const char *src,const char *file,int line,int options) { const char *p,*tmpp; int i; struct script_code* code = NULL; char end; bool unresolved_names = false; parser_current_src = src; parser_current_file = file; parser_current_line = line; if( src == NULL ) return NULL;// empty script memset(&syntax,0,sizeof(syntax)); script_buf=(unsigned char *)aMalloc(SCRIPT_BLOCK_SIZE*sizeof(unsigned char)); script_pos=0; script_size=SCRIPT_BLOCK_SIZE; 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; if( setjmp( 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; for(i=LABEL_START;istr_num;i++) if(script->str_data[i].type == C_NOP) script->str_data[i].type = C_NAME; for(i=0; iskip_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; return NULL; } end = '\0'; } else {// requires brackets around the script if( *p != '{' ) disp_error_message("not found '{'",p); 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; return NULL; } end = '}'; } // clear references of labels, variables and internal functions for(i=LABEL_START;istr_num;i++){ if( script->str_data[i].type==C_POS || script->str_data[i].type==C_NAME || script->str_data[i].type==C_USERFUNC || script->str_data[i].type == C_USERFUNC_POS ){ script->str_data[i].type=C_NOP; script->str_data[i].backpatch=-1; script->str_data[i].label=-1; } } while( 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)); 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); p=tmpp+1; p=script->skip_space(p); continue; } // All other lumped p=parse_line(p); p=script->skip_space(p); parse_nextline(false, p); } add_scriptc(C_NOP); // trim code to size script_size = script_pos; RECREATE(script_buf,unsigned char,script_pos); // default unknown references to variables for(i=LABEL_START;istr_num;i++){ if(script->str_data[i].type==C_NOP){ int j,next; 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); j=next; } } else if( script->str_data[i].type == C_USERFUNC ) {// 'function name;' without follow-up code ShowError("parse_script: function '%s' declared but not defined.\n", script->str_buf+script->str_data[i].str); unresolved_names = true; } } if( unresolved_names ) { disp_error_message("parse_script: unresolved function references", p); } #ifdef DEBUG_DISP for(i=0;iget_str(j)); i += 3; break; case C_STR: j = strlen(script_buf + i); ShowMessage(" %s", script_buf + i); i += j+1; break; } ShowMessage(CL_CLL"\n"); } } #endif CREATE(code,struct script_code,1); code->script_buf = script_buf; code->script_size = script_size; code->script_vars = NULL; return code; } /// Returns the player attached to this script, identified by the rid. /// If there is no player attached, the script is terminated. TBL_PC *script_rid2sd(struct script_state *st) { TBL_PC *sd; if( !( sd = iMap->id2sd(st->rid) ) ){ ShowError("script_rid2sd: fatal error ! player not attached!\n"); script_reportfunc(st); script_reportsrc(st); st->state = END; } return sd; } /// Dereferences a variable/constant, replacing it with a copy of the value. /// /// @param st Script state /// @param data Variable/constant void get_val(struct script_state* st, struct script_data* data) { const char* name; char prefix; char postfix; TBL_PC* sd = NULL; if( !data_isreference(data) ) return;// not a variable/constant name = reference_getname(data); prefix = name[0]; postfix = name[strlen(name) - 1]; //##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); if( sd == NULL ) {// needs player attached if( postfix == '$' ) {// string variable ShowWarning("script_get_val: cannot access player variable '%s', defaulting to \"\"\n", name); data->type = C_CONSTSTR; data->u.str = ""; } else {// integer variable ShowWarning("script_get_val: cannot access player variable '%s', defaulting to 0\n", name); data->type = C_INT; data->u.num = 0; } return; } } if( postfix == '$' ) {// string variable switch( prefix ) { case '@': data->u.str = pc->readregstr(sd, data->u.num); break; case '$': data->u.str = mapreg_readregstr(data->u.num); break; case '#': if( name[1] == '#' ) data->u.str = pc_readaccountreg2str(sd, name);// global else data->u.str = pc_readaccountregstr(sd, name);// local break; case '.': { struct DBMap* n = data->ref ? *data->ref: name[1] == '@' ? st->stack->var_function:// instance/scope variable st->script->script_vars;// npc variable if( n ) data->u.str = (char*)idb_get(n,reference_getuid(data)); else data->u.str = NULL; } break; case '\'': if ( st->instance_id >= 0 ) { data->u.str = (char*)idb_get(instances[st->instance_id].vars,reference_getuid(data)); } else { ShowWarning("script_get_val: cannot access instance variable '%s', defaulting to \"\"\n", name); data->u.str = NULL; } break; default: data->u.str = pc_readglobalreg_str(sd, name); break; } if( data->u.str == NULL || data->u.str[0] == '\0' ) {// empty string data->type = C_CONSTSTR; data->u.str = ""; } else {// duplicate string data->type = C_STR; data->u.str = aStrdup(data->u.str); } } else {// integer variable data->type = C_INT; if( reference_toconstant(data) ) { data->u.num = reference_getconstant(data); } else if( reference_toparam(data) ) { data->u.num = pc->readparam(sd, reference_getparamtype(data)); } else switch( prefix ) { case '@': data->u.num = pc->readreg(sd, data->u.num); break; case '$': data->u.num = mapreg_readreg(data->u.num); break; case '#': if( name[1] == '#' ) data->u.num = pc_readaccountreg2(sd, name);// global else data->u.num = pc_readaccountreg(sd, name);// local break; case '.': { struct DBMap* n = data->ref ? *data->ref: name[1] == '@' ? st->stack->var_function:// instance/scope variable st->script->script_vars;// npc variable if( n ) data->u.num = (int)idb_iget(n,reference_getuid(data)); else data->u.num = 0; } break; case '\'': if( st->instance_id >= 0 ) data->u.num = (int)idb_iget(instances[st->instance_id].vars,reference_getuid(data)); else { ShowWarning("script_get_val: cannot access instance variable '%s', defaulting to 0\n", name); data->u.num = 0; } break; default: data->u.num = pc_readglobalreg(sd, name); break; } } return; } /// Retrieves the value of a reference identified by uid (variable, constant, param) /// The value is left in the top of the stack and needs to be removed manually. void* get_val2(struct script_state* st, int uid, struct DBMap** ref) { struct script_data* data; script->push_val(st->stack, C_NAME, uid, ref); data = script_getdatatop(st, -1); script->get_val(st, data); return (data->type == C_INT ? (void*)__64BPTRSIZE(data->u.num) : (void*)__64BPTRSIZE(data->u.str)); } /*========================================== * 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) { char prefix = name[0]; if( is_string_variable(name) ) {// string variable const char* str = (const char*)value; switch (prefix) { case '@': return pc->setregstr(sd, num, str); case '$': return mapreg_setregstr(num, str); case '#': return (name[1] == '#') ? pc_setaccountreg2str(sd, name, str) : pc_setaccountregstr(sd, name, str); case '.': { struct DBMap* n; n = (ref) ? *ref : (name[1] == '@') ? st->stack->var_function : st->script->script_vars; if( n ) { idb_remove(n, num); if (str[0]) idb_put(n, num, aStrdup(str)); } } return 1; case '\'': if( st->instance_id >= 0 ) { idb_remove(instances[st->instance_id].vars, num); if( str[0] ) idb_put(instances[st->instance_id].vars, num, aStrdup(str)); } return 1; default: return pc_setglobalreg_str(sd, name, str); } } else {// integer variable int val = (int)__64BPTRSIZE(value); if(script->str_data[num&0x00ffffff].type == C_PARAM) { if( pc->setparam(sd, script->str_data[num&0x00ffffff].val, val) == 0 ) { if( st != NULL ) { ShowError("script:set_reg: failed to set param '%s' to %d.\n", name, val); script_reportsrc(st); st->state = END; } return 0; } return 1; } switch (prefix) { case '@': return pc->setreg(sd, num, val); case '$': return mapreg_setreg(num, val); case '#': return (name[1] == '#') ? pc_setaccountreg2(sd, name, val) : pc_setaccountreg(sd, name, val); case '.': { struct DBMap* n; n = (ref) ? *ref : (name[1] == '@') ? st->stack->var_function : st->script->script_vars; if( n ) { idb_remove(n, num); if( val != 0 ) idb_iput(n, num, val); } } return 1; case '\'': if( st->instance_id >= 0 ) { idb_remove(instances[st->instance_id].vars, num); if( val != 0 ) idb_iput(instances[st->instance_id].vars, num, val); } return 1; default: return pc_setglobalreg(sd, name, val); } } } 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); } 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); } /// Converts the data to a string const char* conv_str(struct script_state* st, struct script_data* data) { char* p; script->get_val(st, data); if( data_isstring(data) ) {// nothing to convert } else if( data_isint(data) ) {// int -> string CREATE(p, char, ITEM_NAME_LENGTH); snprintf(p, ITEM_NAME_LENGTH, "%d", data->u.num); p[ITEM_NAME_LENGTH-1] = '\0'; data->type = C_STR; data->u.str = p; } else if( data_isreference(data) ) {// reference -> string //##TODO when does this happen (check script->get_val) [FlavioJS] data->type = C_CONSTSTR; data->u.str = reference_getname(data); } else {// unsupported data type ShowError("script:conv_str: cannot convert to string, defaulting to \"\"\n"); script_reportdata(data); script_reportsrc(st); data->type = C_CONSTSTR; data->u.str = ""; } return data->u.str; } /// Converts the data to an int int conv_num(struct script_state* st, struct script_data* data) { char* p; long num; script->get_val(st, data); if( data_isint(data) ) {// nothing to convert } else if( data_isstring(data) ) {// string -> int // the result does not overflow or underflow, it is capped instead // ex: 999999999999 is capped to INT_MAX (2147483647) p = data->u.str; errno = 0; num = strtol(data->u.str, NULL, 10);// change radix to 0 to support octal numbers "o377" and hex numbers "0xFF" if( errno == ERANGE #if LONG_MAX > INT_MAX || num < INT_MIN || num > INT_MAX #endif ) { if( num <= INT_MIN ) { num = INT_MIN; ShowError("script:conv_num: underflow detected, capping to %ld\n", num); } else//if( num >= INT_MAX ) { num = INT_MAX; ShowError("script:conv_num: overflow detected, capping to %ld\n", num); } script_reportdata(data); script_reportsrc(st); } if( data->type == C_STR ) aFree(p); data->type = C_INT; data->u.num = (int)num; } #if 0 // FIXME this function is being used to retrieve the position of labels and // probably other stuff [FlavioJS] else {// unsupported data type ShowError("script:conv_num: cannot convert to number, defaulting to 0\n"); script_reportdata(data); script_reportsrc(st); data->type = C_INT; data->u.num = 0; } #endif return data->u.num; } // // Stack operations // /// Increases the size of the stack void stack_expand(struct script_stack* stack) { stack->sp_max += 64; stack->stack_data = (struct script_data*)aRealloc(stack->stack_data, stack->sp_max * sizeof(stack->stack_data[0]) ); memset(stack->stack_data + (stack->sp_max - 64), 0, 64 * sizeof(stack->stack_data[0]) ); } /// 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); stack->stack_data[stack->sp].type = type; stack->stack_data[stack->sp].u.num = val; stack->stack_data[stack->sp].ref = ref; stack->sp++; return &stack->stack_data[stack->sp-1]; } /// Pushes a string into the stack struct script_data* push_str(struct script_stack* stack, enum c_op type, char* str) { if( stack->sp >= stack->sp_max ) 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; stack->sp++; return &stack->stack_data[stack->sp-1]; } /// Pushes a retinfo into the stack struct script_data* push_retinfo(struct script_stack* stack, struct script_retinfo* ri, DBMap **ref) { if( stack->sp >= stack->sp_max ) 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; stack->sp++; return &stack->stack_data[stack->sp-1]; } /// Pushes a copy of the target position into the stack struct script_data* push_copy(struct script_stack* stack, int pos) { switch( stack->stack_data[pos].type ) { case C_CONSTSTR: return script->push_str(stack, C_CONSTSTR, stack->stack_data[pos].u.str); break; case C_STR: return script->push_str(stack, C_STR, aStrdup(stack->stack_data[pos].u.str)); break; case C_RETINFO: ShowFatalError("script:push_copy: can't create copies of C_RETINFO. Exiting...\n"); exit(1); break; default: return script->push_val( stack,stack->stack_data[pos].type, stack->stack_data[pos].u.num, stack->stack_data[pos].ref ); break; } } /// Removes the values in indexes [start,end[ from the stack. /// Adjusts all stack pointers. void pop_stack(struct script_state* st, int start, int end) { struct script_stack* stack = st->stack; struct script_data* data; int i; if( start < 0 ) start = 0; if( end > stack->sp ) end = stack->sp; if( start >= end ) return;// nothing to pop // free stack elements for( i = start; i < end; i++ ) { data = &stack->stack_data[i]; if( data->type == C_STR ) aFree(data->u.str); if( data->type == C_RETINFO ) { struct script_retinfo* ri = data->u.ri; if( ri->var_function ) script->free_vars(ri->var_function); if( data->ref ) aFree(data->ref); aFree(ri); } data->type = C_NOP; } // move the rest of the elements if( stack->sp > end ) { memmove(&stack->stack_data[start], &stack->stack_data[end], sizeof(stack->stack_data[0])*(stack->sp - end)); for( i = start + stack->sp - end; i < stack->sp; ++i ) stack->stack_data[i].type = C_NOP; } // adjust stack pointers if( st->start > end ) st->start -= end - start; else if( st->start > start ) st->start = start; if( st->end > end ) st->end -= end - start; else if( st->end > start ) st->end = start; if( stack->defsp > end ) stack->defsp -= end - start; else if( stack->defsp > start ) stack->defsp = start; stack->sp -= end - start; } /// /// /// /*========================================== * Release script dependent variable, dependent variable of function *------------------------------------------*/ void script_free_vars(struct DBMap* storage) { if( storage ) {// destroy the storage construct containing the variables db_destroy(storage); } } void script_free_code(struct script_code* code) { script->free_vars( code->script_vars ); aFree( code->script_buf ); aFree( code ); } /// Creates a new script state. /// /// @param script Script code /// @param pos Position in the code /// @param rid Who is running the script (attached player) /// @param oid Where the code is being run (npc 'object') /// @return Script state struct script_state* script_alloc_state(struct script_code* rootscript, int pos, int rid, int oid) { struct script_state* st; st = ers_alloc(script->st_ers, struct script_state); st->stack = ers_alloc(script->stack_ers, struct script_stack); st->stack->sp = 0; st->stack->sp_max = 64; CREATE(st->stack->stack_data, struct script_data, st->stack->sp_max); st->stack->defsp = st->stack->sp; st->stack->var_function = idb_alloc(DB_OPT_RELEASE_DATA); st->state = RUN; st->script = rootscript; st->pos = pos; st->rid = rid; st->oid = oid; st->sleep.timer = INVALID_TIMER; st->npc_item_flag = battle_config.item_enabled_npc; if( !st->script->script_vars ) st->script->script_vars = idb_alloc(DB_OPT_RELEASE_DATA); st->id = script->next_id++; script->active_scripts++; idb_put(script->st_db, st->id, st); return st; } /// Frees a script state. /// /// @param st Script state void script_free_state(struct script_state* st) { if( idb_exists(script->st_db,st->id) ) { if(st->bk_st) {// backup was not restored ShowDebug("script_free_state: Previous script state lost (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); } if( st->sleep.timer != INVALID_TIMER ) iTimer->delete_timer(st->sleep.timer, script->run_timer); if( st->stack ) { script->free_vars(st->stack->var_function); script->pop_stack(st, 0, st->stack->sp); aFree(st->stack->stack_data); ers_free(script->stack_ers, st->stack); st->stack = NULL; } if( st->script && st->script->script_vars && !db_size(st->script->script_vars) ) { script->free_vars(st->script->script_vars); st->script->script_vars = NULL; } st->pos = -1; idb_remove(script->st_db, st->id); ers_free(script->st_ers, st); if( --script->active_scripts == 0 ) { script->next_id = 0; } } } // // Main execution unit // /*========================================== * Read command *------------------------------------------*/ c_op get_com(unsigned char *scriptbuf,int *pos) { int i = 0, j = 0; if(scriptbuf[*pos]>=0x80){ return C_INT; } while(scriptbuf[*pos]>=0x40){ i=scriptbuf[(*pos)++]<=0xc0){ i+=(scriptbuf[(*pos)++]&0x7f)<stack->sp<=0) return 0; st->stack->sp--; script->get_val(st,&(st->stack->stack_data[st->stack->sp])); if(st->stack->stack_data[st->stack->sp].type==C_INT) return st->stack->stack_data[st->stack->sp].u.num; return 0; } /// Ternary operators /// test ? if_true : if_false void op_3(struct script_state* st, int op) { struct script_data* data; int flag = 0; data = script_getdatatop(st, -3); script->get_val(st, data); if( data_isstring(data) ) flag = data->u.str[0];// "" -> false else if( data_isint(data) ) flag = data->u.num;// 0 -> false else { ShowError("script:op_3: invalid data for the ternary operator test\n"); script_reportdata(data); script_reportsrc(st); script_removetop(st, -3, 0); script_pushnil(st); return; } if( flag ) script_pushcopytop(st, -2); else script_pushcopytop(st, -1); script_removetop(st, -4, -1); } /// Binary string operators /// s1 EQ s2 -> i /// s1 NE s2 -> i /// s1 GT s2 -> i /// s1 GE s2 -> i /// s1 LT s2 -> i /// s1 LE s2 -> i /// s1 ADD s2 -> s void op_2str(struct script_state* st, int op, const char* s1, const char* s2) { int a = 0; switch(op){ case C_EQ: a = (strcmp(s1,s2) == 0); break; case C_NE: a = (strcmp(s1,s2) != 0); break; case C_GT: a = (strcmp(s1,s2) > 0); break; case C_GE: a = (strcmp(s1,s2) >= 0); break; case C_LT: a = (strcmp(s1,s2) < 0); break; case C_LE: a = (strcmp(s1,s2) <= 0); break; case C_ADD: { char* buf = (char *)aMalloc((strlen(s1)+strlen(s2)+1)*sizeof(char)); strcpy(buf, s1); strcat(buf, s2); script_pushstr(st, buf); return; } default: ShowError("script:op2_str: unexpected string operator %s\n", script_op2name(op)); script_reportsrc(st); script_pushnil(st); st->state = END; return; } script_pushint(st,a); } /// Binary number operators /// i OP i -> i void op_2num(struct script_state* st, int op, int i1, int i2) { int ret; double ret_double; switch( op ) { case C_AND: ret = i1 & i2; break; case C_OR: ret = i1 | i2; break; case C_XOR: ret = i1 ^ i2; break; case C_LAND: ret = (i1 && i2); break; case C_LOR: ret = (i1 || i2); break; case C_EQ: ret = (i1 == i2); break; case C_NE: ret = (i1 != i2); break; case C_GT: ret = (i1 > i2); break; case C_GE: ret = (i1 >= i2); break; case C_LT: ret = (i1 < i2); break; case C_LE: ret = (i1 <= i2); break; case C_R_SHIFT: ret = i1>>i2; break; case C_L_SHIFT: ret = i1<state = END; return; } else if( op == C_DIV ) ret = i1 / i2; else//if( op == C_MOD ) ret = i1 % i2; break; default: switch( op ) {// operators that can overflow/underflow case C_ADD: ret = i1 + i2; ret_double = (double)i1 + (double)i2; break; 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); 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); 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); ret = INT_MAX; } } script_pushint(st, ret); } /// Binary operators void op_2(struct script_state *st, int op) { struct script_data* left, leftref; struct script_data* right; leftref.type = C_NOP; left = script_getdatatop(st, -2); right = script_getdatatop(st, -1); if (st->op2ref) { if (data_isreference(left)) { leftref = *left; } st->op2ref = 0; } script->get_val(st, left); script->get_val(st, right); // automatic conversions switch( op ) { case C_ADD: if( data_isint(left) && data_isstring(right) ) {// convert int-string to string-string script->conv_str(st, left); } else if( data_isstring(left) && data_isint(right) ) {// convert string-int to string-string script->conv_str(st, right); } break; } if( data_isstring(left) && data_isstring(right) ) {// ss => op_2str 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) { if (left->type == C_STR) // don't free C_CONSTSTR aFree(left->u.str); *left = leftref; } } else if( data_isint(left) && data_isint(right) ) {// ii => op_2num int i1 = left->u.num; int i2 = right->u.num; script_removetop(st, leftref.type == C_NOP ? -2 : -1, 0); 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); script_removetop(st, -2, 0); script_pushnil(st); st->state = END; } } /// Unary operators /// NEG i -> i /// NOT i -> i /// LNOT i -> i void op_1(struct script_state* st, int op) { struct script_data* data; int i1; data = script_getdatatop(st, -1); script->get_val(st, data); 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); script_pushnil(st); st->state = END; return; } i1 = data->u.num; script_removetop(st, -1, 0); switch( op ) { case C_NEG: i1 = -i1; break; 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); script_pushnil(st); st->state = END; return; } script_pushint(st, i1); } /// Checks the type of all arguments passed to a built-in function. /// /// @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) { char type; int idx, invalid = 0; char* sf = script->buildin[script->str_data[func].val]; for( idx = 2; script_hasdata(st, idx); idx++ ) { struct script_data* data = script_getdata(st, idx); type = sf[idx-2]; 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)); invalid++; break; } else { const char* name = NULL; if( data_isreference(data) ) {// get name for variables to determine the type they refer to name = reference_getname(data); } switch( type ) { case 'v': 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); invalid++; } break; case 's': 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); invalid++; } break; case 'i': 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); 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); 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); invalid++; } break; } } } if(invalid) { ShowDebug("Function: %s\n", script->get_str(func)); script_reportsrc(st); } } /// Executes a buildin command. /// Stack: C_NAME() C_ARG ... int run_func(struct script_state *st) { struct script_data* data; int i,start_sp,end_sp,func; end_sp = st->stack->sp;// position after the last argument for( i = end_sp-1; i > 0 ; --i ) if( st->stack->stack_data[i].type == C_ARG ) break; if( i == 0 ) { ShowError("script:run_func: C_ARG not found. please report this!!!\n"); st->state = END; script_reportsrc(st); return 1; } start_sp = i-1;// C_NAME of the command st->start = start_sp; st->end = end_sp; data = &st->stack->stack_data[st->start]; if( data->type == C_NAME && script->str_data[data->u.num].type == C_FUNC ) func = data->u.num; else { ShowError("script:run_func: not a buildin command.\n"); script_reportdata(data); script_reportsrc(st); st->state = END; return 1; } if( script->config.warn_func_mismatch_argtypes ) { script_check_buildin_argtype(st, func); } if(script->str_data[func].func){ if (!(script->str_data[func].func(st))) //Report error 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); st->state = END; } // Stack's datum are used when re-running functions [Eoe] if( st->state == RERUNLINE ) return 0; script->pop_stack(st, st->start, st->end); if( st->state == RETFUNC ) {// return from a user-defined function struct script_retinfo* ri; int olddefsp = st->stack->defsp; int nargs; script->pop_stack(st, st->stack->defsp, st->start);// pop distractions from the stack 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); st->state = END; return 1; } script->free_vars( st->stack->var_function ); ri = st->stack->stack_data[st->stack->defsp-1].u.ri; nargs = ri->nargs; st->pos = ri->pos; st->script = ri->script; st->stack->var_function = ri->var_function; st->stack->defsp = ri->defsp; memset(ri, 0, sizeof(struct script_retinfo)); script->pop_stack(st, olddefsp-nargs-1, olddefsp);// pop arguments and retinfo st->state = GOTO; } return 0; } /*========================================== * script execution *------------------------------------------*/ void run_script(struct script_code *rootscript,int pos,int rid,int oid) { struct script_state *st; if( rootscript == NULL || pos < 0 ) return; // TODO In jAthena, this function can take over the pending script in the player. [FlavioJS] // It is unclear how that can be triggered, so it needs the be traced/checked in more detail. // NOTE At the time of this change, this function wasn't capable of taking over the script state because st->scriptroot was never set. st = script->alloc_state(rootscript, pos, rid, oid); script->run_main(st); } void script_stop_instances(struct script_code *code) { DBIterator *iter; struct script_state* st; if( !script->active_scripts ) return;//dont even bother. iter = db_iterator(script->st_db); for( st = dbi_first(iter); dbi_exists(iter); st = dbi_next(iter) ) { if( st->script == code ) { script->free_state(st); } } dbi_destroy(iter); } /*========================================== * Timer function for sleep *------------------------------------------*/ int run_script_timer(int tid, unsigned int tick, int id, intptr_t data) { struct script_state *st = idb_get(script->st_db,(int)data); if( st ) { TBL_PC *sd = iMap->id2sd(st->rid); if((sd && sd->status.char_id != id) || (st->rid && !sd)) { //Character mismatch. Cancel execution. st->rid = 0; st->state = END; } st->sleep.timer = INVALID_TIMER; if(st->state != RERUNLINE) st->sleep.tick = 0; script->run_main(st); } return 0; } /// Detaches script state from possibly attached character and restores it's previous script if any. /// /// @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) { struct map_session_data* sd; if(st->rid && (sd = iMap->id2sd(st->rid))!=NULL) { sd->st = st->bk_st; sd->npc_id = st->bk_npcid; sd->state.dialog = 0; if(st->bk_st) { //Remove tag for removal. st->bk_st = NULL; st->bk_npcid = 0; } else if(dequeue_event) { /** * For the Secure NPC Timeout option (check config/Secure.h) [RR] **/ #ifdef SECURE_NPCTIMEOUT /** * We're done with this NPC session, so we cancel the timer (if existent) and move on **/ if( sd->npc_idle_timer != INVALID_TIMER ) { iTimer->delete_timer(sd->npc_idle_timer,npc->secure_timeout_timer); sd->npc_idle_timer = INVALID_TIMER; } #endif npc->event_dequeue(sd); } } 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->free_state(st->bk_st); st->bk_st = NULL; } } /// Attaches script state to possibly attached character and backups it's previous script, if any. /// /// @param st Script state to attach. void script_attach_state(struct script_state* st) { struct map_session_data* sd; if(st->rid && (sd = iMap->id2sd(st->rid))!=NULL) { if(st!=sd->st) { if(st->bk_st) {// there is already a backup ShowDebug("script_free_state: Previous script state lost (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); } st->bk_st = sd->st; st->bk_npcid = sd->npc_id; } sd->st = st; sd->npc_id = st->oid; sd->npc_item_flag = st->npc_item_flag; // load default. /** * For the Secure NPC Timeout option (check config/Secure.h) [RR] **/ #ifdef SECURE_NPCTIMEOUT if( sd->npc_idle_timer == INVALID_TIMER ) sd->npc_idle_timer = iTimer->add_timer(iTimer->gettick() + (SECURE_NPCTIMEOUT_INTERVAL*1000),npc->secure_timeout_timer,sd->bl.id,0); sd->npc_idle_tick = iTimer->gettick(); #endif } } /*========================================== * The main part of the script execution *------------------------------------------*/ void run_script_main(struct script_state *st) { int cmdcount = script->config.check_cmdcount; int gotocount = script->config.check_gotocount; TBL_PC *sd; struct script_stack *stack = st->stack; struct npc_data *nd; script->attach_state(st); nd = iMap->id2nd(st->oid); if( nd && nd->bl.m >= 0 ) st->instance_id = map[nd->bl.m].instance_id; else st->instance_id = -1; if(st->state == RERUNLINE) { 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); switch(c){ case C_EOL: if( stack->defsp > stack->sp ) ShowError("script:run_script_main: unexpected stack position (defsp=%d sp=%d). please report this!!!\n", stack->defsp, stack->sp); else 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); break; case C_POS: case C_NAME: script->push_val(stack,c,GETVALUE(st->script->script_buf,st->pos),NULL); st->pos+=3; break; case C_ARG: script->push_val(stack,c,0,NULL); break; case C_STR: script->push_str(stack,C_CONSTSTR,(char*)(st->script->script_buf+st->pos)); while(st->script->script_buf[st->pos++]); break; case C_FUNC: 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); st->state=END; } } break; case C_REF: st->op2ref = 1; break; case C_NEG: case C_NOT: case C_LNOT: op_1(st ,c); break; case C_ADD: case C_SUB: case C_MUL: case C_DIV: case C_MOD: case C_EQ: case C_NE: case C_GT: case C_GE: case C_LT: case C_LE: case C_AND: case C_OR: case C_XOR: case C_LAND: case C_LOR: case C_R_SHIFT: case C_L_SHIFT: op_2(st, c); break; case C_OP3: op_3(st, c); break; case C_NOP: st->state=END; break; default: ShowError("unknown command : %d @ %d\n",c,st->pos); st->state=END; break; } if( !st->freeloop && cmdcount>0 && (--cmdcount)<=0 ){ ShowError("run_script: infinity loop !\n"); script_reportsrc(st); st->state=END; } } if(st->sleep.tick > 0) { //Restore previous script script_detach_state(st, false); //Delay execution sd = iMap->id2sd(st->rid); // Get sd since script might have attached someone while running. [Inkfish] st->sleep.charid = sd?sd->status.char_id:0; st->sleep.timer = iTimer->add_timer(iTimer->gettick()+st->sleep.tick, script->run_timer, st->sleep.charid, (intptr_t)st->id); } else if(st->state != END && st->rid){ //Resume later (st is already attached to player). if(st->bk_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); ShowDebug("Current script:\n"); script_reportsrc(st); script->free_state(st->bk_st); st->bk_st = NULL; } } else { //Dispose of script. if ((sd = iMap->id2sd(st->rid))!=NULL) { //Restore previous stack and save char. if(sd->state.using_fake_npc){ clif->clearunit_single(sd->npc_id, CLR_OUTSIGHT, sd->fd); sd->state.using_fake_npc = 0; } //Restore previous script if any. script_detach_state(st, true); if (sd->state.reg_dirty&2) intif->saveregistry(sd,2); if (sd->state.reg_dirty&1) intif->saveregistry(sd,1); } script->free_state(st); st = NULL; } } int script_config_read(char *cfgName) { int i; char line[1024],w1[1024],w2[1024]; FILE *fp; if( !( fp = fopen(cfgName,"r") ) ){ ShowError("File not found: %s\n", cfgName); return 1; } while(fgets(line, sizeof(line), fp)) { if(line[0] == '/' && line[1] == '/') continue; i=sscanf(line,"%[^:]: %[^\r\n]",w1,w2); if(i!=2) continue; if(strcmpi(w1,"warn_func_mismatch_paramnum")==0) { script->config.warn_func_mismatch_paramnum = config_switch(w2); } else if(strcmpi(w1,"check_cmdcount")==0) { script->config.check_cmdcount = config_switch(w2); } else if(strcmpi(w1,"check_gotocount")==0) { script->config.check_gotocount = config_switch(w2); } else if(strcmpi(w1,"input_min_value")==0) { script->config.input_min_value = config_switch(w2); } else if(strcmpi(w1,"input_max_value")==0) { script->config.input_max_value = config_switch(w2); } else if(strcmpi(w1,"warn_func_mismatch_argtypes")==0) { script->config.warn_func_mismatch_argtypes = config_switch(w2); } else if(strcmpi(w1,"import")==0){ script->config_read(w2); } else { ShowWarning("Unknown setting '%s' in file %s\n", w1, cfgName); } } fclose(fp); return 0; } /** * @see DBApply */ static int db_script_free_code_sub(DBKey key, DBData *data, va_list ap) { struct script_code *code = DB->data2ptr(data); if (code) script->free_code(code); return 0; } void script_run_autobonus(const char *autobonus, int id, int pos) { struct script_code *scriptroot = (struct script_code *)strdb_get(script->autobonus_db, autobonus); if( scriptroot ) { iStatus->current_equip_item_index = pos; script->run(scriptroot,0,id,0); } } void script_add_autobonus(const char *autobonus) { if( strdb_get(script->autobonus_db, autobonus) == NULL ) { struct script_code *scriptroot = script->parse(autobonus, "autobonus", 0, 0); if( scriptroot ) strdb_put(script->autobonus_db, autobonus, scriptroot); } } /// resets a temporary character array variable to given value void script_cleararray_pc(struct map_session_data* sd, const char* varname, void* value) { int key; uint8 idx; if( not_array_variable(varname[0]) || !not_server_variable(varname[0]) ) { ShowError("script_cleararray_pc: Variable '%s' has invalid scope (char_id=%d).\n", varname, sd->status.char_id); return; } key = script->add_str(varname); if( is_string_variable(varname) ) { for( idx = 0; idx < SCRIPT_MAX_ARRAYSIZE; idx++ ) { pc->setregstr(sd, reference_uid(key, idx), (const char*)value); } } else { for( idx = 0; idx < SCRIPT_MAX_ARRAYSIZE; idx++ ) { pc->setreg(sd, reference_uid(key, idx), (int)__64BPTRSIZE(value)); } } } /// sets a temporary character array variable element idx to given value /// @param refcache Pointer to an int variable, which keeps a copy of the reference to varname and must be initialized to 0. Can be NULL if only one element is set. void script_setarray_pc(struct map_session_data* sd, const char* varname, uint8 idx, void* value, int* refcache) { int key; if( not_array_variable(varname[0]) || !not_server_variable(varname[0]) ) { ShowError("script_setarray_pc: Variable '%s' has invalid scope (char_id=%d).\n", varname, sd->status.char_id); return; } if( idx >= SCRIPT_MAX_ARRAYSIZE ) { ShowError("script_setarray_pc: Variable '%s' has invalid index '%d' (char_id=%d).\n", varname, (int)idx, sd->status.char_id); return; } key = ( refcache && refcache[0] ) ? refcache[0] : script->add_str(varname); if( is_string_variable(varname) ) { pc->setregstr(sd, reference_uid(key, idx), (const char*)value); } else { pc->setreg(sd, reference_uid(key, idx), (int)__64BPTRSIZE(value)); } if( refcache ) {// save to avoid repeated script->add_str calls refcache[0] = key; } } /*========================================== * Destructor *------------------------------------------*/ void do_final_script(void) { int i; DBIterator *iter; struct script_state *st; #ifdef DEBUG_HASH if (battle_config.etc_log) { FILE *fp = fopen("hash_dump.txt","wt"); if(fp) { int count[SCRIPT_HASH_SIZE]; int count2[SCRIPT_HASH_SIZE]; // number of buckets with a certain number of items int n=0; int min=INT_MAX,max=0,zero=0; double mean=0.0f; double median=0.0f; ShowNotice("Dumping script str hash information to hash_dump.txt\n"); memset(count, 0, sizeof(count)); fprintf(fp,"num : hash : data_name\n"); fprintf(fp,"---------------------------------------------------------------\n"); for(i=LABEL_START; istr_num; i++) { unsigned int h = calc_hash(script->get_str(i)); fprintf(fp,"%04d : %4u : %s\n",i,h, script->get_str(i)); ++count[h]; } fprintf(fp,"--------------------\n\n"); memset(count2, 0, sizeof(count2)); for(i=0; i count[i]) min = count[i]; // minimun count of collision if(max < count[i]) max = count[i]; // maximun count of collision if(count[i] == 0) zero++; ++count2[count[i]]; } fprintf(fp,"\n--------------------\n items : buckets\n--------------------\n"); for( i=min; i <= max; ++i ){ fprintf(fp," %5d : %7d\n",i,count2[i]); mean += 1.0f*i*count2[i]/SCRIPT_HASH_SIZE; // Note: this will always result in / } for( i=min; i <= max; ++i ){ n += count2[i]; if( n*2 >= SCRIPT_HASH_SIZE ) { if( SCRIPT_HASH_SIZE%2 == 0 && SCRIPT_HASH_SIZE/2 == n ) median = (i+i+1)/2.0f; else median = i; break; } } fprintf(fp,"--------------------\n min = %d, max = %d, zero = %d\n mean = %lf, median = %lf\n",min,max,zero,mean,median); fclose(fp); } } #endif iter = db_iterator(script->st_db); for( st = dbi_first(iter); dbi_exists(iter); st = dbi_next(iter) ) { script->free_state(st); } dbi_destroy(iter); 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); if (script->str_data) aFree(script->str_data); if (script->str_buf) aFree(script->str_buf); for( i = 0; i < atcommand->binding_count; i++ ) { aFree(atcommand->binding[i]); } if( atcommand->binding_count != 0 ) aFree(atcommand->binding); for( i = 0; i < script->buildin_count; i++) { if( script->buildin[i] ) { aFree(script->buildin[i]); script->buildin[i] = NULL; } } aFree(script->buildin); if( script->hqs ) { for( i = 0; i < script->hqs; i++ ) { if( script->hq[i].item != NULL ) aFree(script->hq[i].item); } } if( script->hqis ) { for( i = 0; i < script->hqis; i++ ) { if( script->hqi[i].item != NULL ) aFree(script->hqi[i].item); } } if( script->hq != NULL ) aFree(script->hq); if( script->hqi != NULL ) aFree(script->hqi); if( script->word_buf != NULL ) aFree(script->word_buf); ers_destroy(script->st_ers); ers_destroy(script->stack_ers); db_destroy(script->st_db); if( script->labels != NULL ) aFree(script->labels); } /*========================================== * Initialization *------------------------------------------*/ void do_init_script(void) { script->st_db = idb_alloc(DB_OPT_BASE); script->userfunc_db = strdb_alloc(DB_OPT_DUP_KEY,0); script->autobonus_db = strdb_alloc(DB_OPT_DUP_KEY,0); script->st_ers = ers_new(sizeof(struct script_state), "script.c::st_ers", ERS_OPT_NONE); script->stack_ers = ers_new(sizeof(struct script_stack), "script.c::script_stack", ERS_OPT_NONE); ers_chunk_size(script->st_ers, 10); ers_chunk_size(script->stack_ers, 10); script->parse_builtin(); read_constdb(); mapreg_init(); } int script_reload(void) { int i; DBIterator *iter; struct script_state *st; iter = db_iterator(script->st_db); for( st = dbi_first(iter); dbi_exists(iter); st = dbi_next(iter) ) { script->free_state(st); } dbi_destroy(iter); script->userfunc_db->clear(script->userfunc_db, db_script_free_code_sub); script->label_count = 0; for( i = 0; i < atcommand->binding_count; i++ ) { aFree(atcommand->binding[i]); } if( atcommand->binding_count != 0 ) aFree(atcommand->binding); atcommand->binding_count = 0; db_clear(script->st_db); mapreg_reload(); itemdb->force_name_constants(); return 0; } //----------------------------------------------------------------------------- // buildin functions // #define BUILDIN_DEF(x,args) { buildin_ ## x , #x , args } #define BUILDIN_DEF2(x,x2,args) { buildin_ ## x , x2 , args } ///////////////////////////////////////////////////////////////////// // NPC interaction // /// Appends a message to the npc dialog. /// If a dialog doesn't exist yet, one is created. /// /// mes ""; BUILDIN(mes) { TBL_PC* sd = script_rid2sd(st); if( sd == NULL ) return true; if( !script_hasdata(st, 3) ) {// only a single line detected in the script clif->scriptmes(sd, st->oid, script_getstr(st, 2)); } else {// parse multiple lines as they exist int i; for( i = 2; script_hasdata(st, i); i++ ) { // send the message to the client clif->scriptmes(sd, st->oid, script_getstr(st, i)); } } return true; } /// Displays the button 'next' in the npc dialog. /// The dialog text is cleared and the script continues when the button is pressed. /// /// next; BUILDIN(next) { TBL_PC* sd; sd = script_rid2sd(st); if( sd == NULL ) return true; #ifdef SECURE_NPCTIMEOUT sd->npc_idle_type = NPCT_WAIT; #endif st->state = STOP; clif->scriptnext(sd, st->oid); return true; } /// Ends the script and displays the button 'close' on the npc dialog. /// The dialog is closed when the button is pressed. /// /// close; BUILDIN(close) { TBL_PC* sd; sd = script_rid2sd(st); if( sd == NULL ) return true; st->state = sd->state.dialog == 1 ? CLOSE : END; clif->scriptclose(sd, st->oid); return true; } /// Displays the button 'close' on the npc dialog. /// The dialog is closed and the script continues when the button is pressed. /// /// close2; BUILDIN(close2) { TBL_PC* sd; sd = script_rid2sd(st); if( sd == NULL ) return true; if( sd->state.dialog == 1 ) st->state = STOP; else { ShowWarning("misuse of 'close2'! trying to use it without prior dialog! skipping...\n"); script_reportsrc(st); } clif->scriptclose(sd, st->oid); return true; } /// 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 count = 0; int bogus_total; if( total == NULL ) total = &bogus_total; ++(*total); // initial empty options while( *str == ':' ) { ++str; ++(*total); } // count menu options while( *str != '\0' ) { ++count; --max_count; if( max_count == 0 ) break; while( *str != ':' && *str != '\0' ) ++str; while( *str == ':' ) { ++str; ++(*total); } } return count; } /// Displays a menu with options and goes to the target label. /// The script is stopped if cancel is pressed. /// Options with no text are not displayed in the client. /// /// Options can be grouped together, separated by the character ':' in the text: /// ex: menu "A:B:C",L_target; /// All these options go to the specified target label. /// /// The index of the selected option is put in the variable @menu. /// Indexes start with 1 and are consistent with grouped and empty options. /// ex: menu "A::B",-,"",L_Impossible,"C",-; /// // displays "A", "B" and "C", corresponding to indexes 1, 3 and 5 /// /// NOTE: the client closes the npc dialog when cancel is pressed /// /// menu "",{,"",,...}; BUILDIN(menu) { int i; const char* text; TBL_PC* sd; sd = script_rid2sd(st); if( sd == NULL ) return true; #ifdef SECURE_NPCTIMEOUT sd->npc_idle_type = NPCT_MENU; #endif // TODO detect multiple scripts waiting for input at the same time, and what to do when that happens if( sd->state.menu_or_input == 0 ) { struct StringBuf buf; struct script_data* data; if( script_lastdata(st) % 2 == 0 ) {// argument count is not even (1st argument is at index 2) ShowError("script:menu: illegal number of arguments (%d).\n", (script_lastdata(st) - 1)); st->state = END; return false; } StrBuf->Init(&buf); sd->npc_menu = 0; for( i = 2; i < script_lastdata(st); i += 2 ) { // menu options text = script_getstr(st, i); // target label data = script_getdata(st, i+1); if( !data_islabel(data) ) {// 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); st->state = END; return false; } // append option(s) if( text[0] == '\0' ) continue;// empty string, ignore if( sd->npc_menu > 0 ) StrBuf->AppendStr(&buf, ":"); StrBuf->AppendStr(&buf, text); sd->npc_menu += menu_countoptions(text, 0, NULL); } st->state = RERUNLINE; sd->state.menu_or_input = 1; /** * menus beyond this length crash the client (see bugreport:6402) **/ if( StrBuf->Length(&buf) >= 2047 ) { struct npc_data * nd = iMap->id2nd(st->oid); char* menu; CREATE(menu, char, 2048); safestrncpy(menu, StrBuf->Value(&buf), 2047); ShowWarning("NPC Menu too long! (source:%s / length:%d)\n",nd?nd->name:"Unknown",StrBuf->Length(&buf)); clif->scriptmenu(sd, st->oid, menu); aFree(menu); } else clif->scriptmenu(sd, st->oid, StrBuf->Value(&buf)); StrBuf->Destroy(&buf); 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); } } else if( sd->npc_menu == 0xff ) {// Cancel was pressed sd->state.menu_or_input = 0; st->state = END; } else {// goto target label int menu = 0; sd->state.menu_or_input = 0; if( sd->npc_menu <= 0 ) { ShowDebug("script:menu: unexpected selection (%d)\n", sd->npc_menu); st->state = END; return false; } // get target label for( i = 2; i < script_lastdata(st); i += 2 ) { text = script_getstr(st, i); sd->npc_menu -= menu_countoptions(text, sd->npc_menu, &menu); if( sd->npc_menu <= 0 ) break;// entry found } if( sd->npc_menu > 0 ) {// Invalid selection ShowDebug("script:menu: selection is out of range (%d pairs are missing?) - please report this\n", sd->npc_menu); st->state = END; return false; } 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)); st->state = END; return false; } pc->setreg(sd, script->add_str("@menu"), menu); st->pos = script_getnum(st, i + 1); st->state = GOTO; } return true; } /// Displays a menu with options and returns the selected option. /// Behaves like 'menu' without the target labels. /// /// select({,,...}) -> /// /// @see menu BUILDIN(select) { int i; const char* text; TBL_PC* sd; sd = script_rid2sd(st); if( sd == NULL ) return true; #ifdef SECURE_NPCTIMEOUT sd->npc_idle_type = NPCT_MENU; #endif if( sd->state.menu_or_input == 0 ) { struct StringBuf buf; StrBuf->Init(&buf); sd->npc_menu = 0; for( i = 2; i <= script_lastdata(st); ++i ) { text = script_getstr(st, i); if( sd->npc_menu > 0 ) StrBuf->AppendStr(&buf, ":"); StrBuf->AppendStr(&buf, text); sd->npc_menu += menu_countoptions(text, 0, NULL); } st->state = RERUNLINE; sd->state.menu_or_input = 1; /** * menus beyond this length crash the client (see bugreport:6402) **/ if( StrBuf->Length(&buf) >= 2047 ) { struct npc_data * nd = iMap->id2nd(st->oid); char* menu; CREATE(menu, char, 2048); safestrncpy(menu, StrBuf->Value(&buf), 2047); ShowWarning("NPC Menu too long! (source:%s / length:%d)\n",nd?nd->name:"Unknown",StrBuf->Length(&buf)); clif->scriptmenu(sd, st->oid, menu); aFree(menu); } else clif->scriptmenu(sd, st->oid, StrBuf->Value(&buf)); StrBuf->Destroy(&buf); if( sd->npc_menu >= 0xff ) { ShowWarning("buildin_select: Too many options specified (current=%d, max=254).\n", sd->npc_menu); script_reportsrc(st); } } else if( sd->npc_menu == 0xff ) {// Cancel was pressed sd->state.menu_or_input = 0; st->state = END; } else {// return selected option int menu = 0; 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); if( sd->npc_menu <= 0 ) break;// entry found } pc->setreg(sd, script->add_str("@menu"), menu); script_pushint(st, menu); st->state = RUN; } return true; } /// Displays a menu with options and returns the selected option. /// Behaves like 'menu' without the target labels, except when cancel is /// pressed. /// When cancel is pressed, the script continues and 255 is returned. /// /// prompt({,,...}) -> /// /// @see menu BUILDIN(prompt) { int i; const char *text; TBL_PC* sd; sd = script_rid2sd(st); if( sd == NULL ) return true; #ifdef SECURE_NPCTIMEOUT sd->npc_idle_type = NPCT_MENU; #endif if( sd->state.menu_or_input == 0 ) { struct StringBuf buf; StrBuf->Init(&buf); sd->npc_menu = 0; for( i = 2; i <= script_lastdata(st); ++i ) { text = script_getstr(st, i); if( sd->npc_menu > 0 ) StrBuf->AppendStr(&buf, ":"); StrBuf->AppendStr(&buf, text); sd->npc_menu += menu_countoptions(text, 0, NULL); } st->state = RERUNLINE; sd->state.menu_or_input = 1; /** * menus beyond this length crash the client (see bugreport:6402) **/ if( StrBuf->Length(&buf) >= 2047 ) { struct npc_data * nd = iMap->id2nd(st->oid); char* menu; CREATE(menu, char, 2048); safestrncpy(menu, StrBuf->Value(&buf), 2047); ShowWarning("NPC Menu too long! (source:%s / length:%d)\n",nd?nd->name:"Unknown",StrBuf->Length(&buf)); clif->scriptmenu(sd, st->oid, menu); aFree(menu); } else clif->scriptmenu(sd, st->oid, StrBuf->Value(&buf)); StrBuf->Destroy(&buf); if( sd->npc_menu >= 0xff ) { ShowWarning("buildin_prompt: Too many options specified (current=%d, max=254).\n", sd->npc_menu); script_reportsrc(st); } } else if( sd->npc_menu == 0xff ) {// Cancel was pressed sd->state.menu_or_input = 0; pc->setreg(sd, script->add_str("@menu"), 0xff); script_pushint(st, 0xff); st->state = RUN; } else {// return selected option int menu = 0; 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); if( sd->npc_menu <= 0 ) break;// entry found } pc->setreg(sd, script->add_str("@menu"), menu); script_pushint(st, menu); st->state = RUN; } return true; } ///////////////////////////////////////////////////////////////////// // ... // /// Jumps to the target script label. /// /// goto