// Copyright (c) Athena Dev Teams - Licensed under GNU GPL // For more information, see LICENCE in the main folder //#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 #include #include #include #ifndef WIN32 #include #endif #include #include #include #ifdef BETA_THREAD_TEST #include "../common/atomic.h" #include "../common/spinlock.h" #include "../common/thread.h" #include "../common/mutex.h" #endif /////////////////////////////////////////////////////////////////////////////// //## TODO possible enhancements: [FlavioJS] // - 'callfunc' supporting labels in the current npc "::LabelName" // - 'callfunc' supporting labels in other npcs "NpcName::LabelName" // - 'function FuncName;' function declarations reverting to global functions // if local label isn't found // - join callfunc and callsub's functionality // - remove dynamic allocation in add_word() // - remove GETVALUE / SETVALUE // - clean up the set_reg / set_val / setd_sub mess // - detect invalid label references at parse-time // // struct script_state* st; // /// Returns the script_data at the target index #define script_getdata(st,i) ( &((st)->stack->stack_data[(st)->start + (i)]) ) /// Returns if the stack contains data at the target index #define script_hasdata(st,i) ( (st)->end > (st)->start + (i) ) /// Returns the index of the last data in the stack #define script_lastdata(st) ( (st)->end - (st)->start - 1 ) /// Pushes an int into the stack #define script_pushint(st,val) push_val((st)->stack, C_INT, (val)) /// Pushes a string into the stack (script engine frees it automatically) #define script_pushstr(st,val) push_str((st)->stack, C_STR, (val)) /// Pushes a copy of a string into the stack #define script_pushstrcopy(st,val) push_str((st)->stack, C_STR, aStrdup(val)) /// Pushes a constant string into the stack (must never change or be freed) #define script_pushconststr(st,val) push_str((st)->stack, C_CONSTSTR, (val)) /// Pushes a nil into the stack #define script_pushnil(st) push_val((st)->stack, C_NOP, 0) /// Pushes a copy of the data in the target index #define script_pushcopy(st,i) push_copy((st)->stack, (st)->start + (i)) #define script_isstring(st,i) data_isstring(script_getdata(st,i)) #define script_isint(st,i) data_isint(script_getdata(st,i)) #define script_getnum(st,val) conv_num(st, script_getdata(st,val)) #define script_getstr(st,val) conv_str(st, script_getdata(st,val)) #define script_getref(st,val) ( script_getdata(st,val)->ref ) // Note: "top" functions/defines use indexes relative to the top of the stack // -1 is the index of the data at the top /// Returns the script_data at the target index relative to the top of the stack #define script_getdatatop(st,i) ( &((st)->stack->stack_data[(st)->stack->sp + (i)]) ) /// Pushes a copy of the data in the target index relative to the top of the stack #define script_pushcopytop(st,i) push_copy((st)->stack, (st)->stack->sp + (i)) /// Removes the range of values [start,end[ relative to the top of the stack #define script_removetop(st,start,end) ( pop_stack((st), ((st)->stack->sp + (start)), (st)->stack->sp + (end)) ) // // struct script_data* data; // /// Returns if the script data is a string #define data_isstring(data) ( (data)->type == C_STR || (data)->type == C_CONSTSTR ) /// Returns if the script data is an int #define data_isint(data) ( (data)->type == C_INT ) /// Returns if the script data is a reference #define data_isreference(data) ( (data)->type == C_NAME ) /// Returns if the script data is a label #define data_islabel(data) ( (data)->type == C_POS ) /// Returns if the script data is an internal script function label #define data_isfunclabel(data) ( (data)->type == C_USERFUNC_POS ) /// Returns if this is a reference to a constant #define reference_toconstant(data) ( str_data[reference_getid(data)].type == C_INT ) /// Returns if this a reference to a param #define reference_toparam(data) ( str_data[reference_getid(data)].type == C_PARAM ) /// Returns if this a reference to a variable //##TODO confirm it's C_NAME [FlavioJS] #define reference_tovariable(data) ( str_data[reference_getid(data)].type == C_NAME ) /// Returns the unique id of the reference (id and index) #define reference_getuid(data) ( (data)->u.num ) /// Returns the id of the reference #define reference_getid(data) ( (int32)(reference_getuid(data) & 0x00ffffff) ) /// Returns the array index of the reference #define reference_getindex(data) ( (int32)(((uint32)(reference_getuid(data) & 0xff000000)) >> 24) ) /// Returns the name of the reference #define reference_getname(data) ( str_buf + str_data[reference_getid(data)].str ) /// Returns the linked list of uid-value pairs of the reference (can be NULL) #define reference_getref(data) ( (data)->ref ) /// Returns the value of the constant #define reference_getconstant(data) ( str_data[reference_getid(data)].val ) /// Returns the type of param #define reference_getparamtype(data) ( str_data[reference_getid(data)].val ) /// Composes the uid of a reference from the id and the index #define reference_uid(id,idx) ( (int32)((((uint32)(id)) & 0x00ffffff) | (((uint32)(idx)) << 24)) ) #define not_server_variable(prefix) ( (prefix) != '$' && (prefix) != '.' && (prefix) != '\'') #define not_array_variable(prefix) ( (prefix) != '$' && (prefix) != '@' && (prefix) != '.' && (prefix) != '\'' ) #define is_string_variable(name) ( (name)[strlen(name) - 1] == '$' ) #define 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); } // String buffer structures. // str_data stores string information static struct str_data_struct { enum c_op type; int str; int backpatch; int label; int (*func)(struct script_state *st); int val; int next; } *str_data = NULL; static int str_data_size = 0; // size of the data static int str_num = LABEL_START; // next id to be assigned // str_buf holds the strings themselves static char *str_buf; static int str_size = 0; // size of the buffer static int str_pos = 0; // next position to be assigned // 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 DBMap *scriptlabel_db=NULL; // const char* label_name -> int script_pos static DBMap *userfunc_db=NULL; // const char* func_name -> struct script_code* static int parse_options=0; DBMap *script_get_label_db(void) { return scriptlabel_db; } DBMap *script_get_userfunc_db(void) { return userfunc_db; } // 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; // Caches compiled autoscript item code. // Note: This is not cleared when reloading itemdb. static DBMap *autobonus_db=NULL; // char* script -> char* bytecode struct Script_Config script_config = { 1, // warn_func_mismatch_argtypes 1, 65535, 2048, //warn_func_mismatch_paramnum/check_cmdcount/check_gotocount 0, INT_MAX, // input_min_value/input_max_value "OnPCDieEvent", //die_event_name "OnPCKillEvent", //kill_pc_event_name "OnNPCKillEvent", //kill_mob_event_name "OnPCLoginEvent", //login_event_name "OnPCLogoutEvent", //logout_event_name "OnPCLoadMapEvent", //loadmap_event_name "OnPCBaseLvUpEvent", //baselvup_event_name "OnPCJobLvUpEvent", //joblvup_event_name "OnTouch_", //ontouch_name (runs on first visible char to enter area, picks another char if the first char leaves) "OnTouch", //ontouch2_name (run whenever a char walks into the OnTouch area) }; static jmp_buf error_jump; static char *error_msg; static const char *error_pos; static int error_report; // if the error should produce output // 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 current_equip_item_index; //for New CARDS Scripts. It contains Inventory Index of the EQUIP_SCRIPT caller item. [Lupus] int potion_flag=0; //For use on Alchemist improved potions/Potion Pitcher. [Skotlex] int potion_hp=0, potion_per_hp=0, potion_sp=0, potion_per_sp=0; int potion_target=0; c_op get_com(unsigned char *script,int *pos); int get_num(unsigned char *script,int *pos); typedef struct script_function { int (*func)(struct script_state *st); const char *name; const char *arg; } script_function; extern script_function buildin_func[]; static struct linkdb_node *sleep_db;// int oid -> struct script_state* #ifdef BETA_THREAD_TEST /** * MySQL Query Slave **/ static SPIN_LOCK queryThreadLock; static rAthread queryThread = NULL; static ramutex queryThreadMutex = NULL; static racond queryThreadCond = NULL; static volatile int32 queryThreadTerminate = 0; struct queryThreadEntry { bool ok; bool type; /* main db or log db? */ struct script_state *st; }; /* Ladies and Gentleman the Manager! */ struct { struct queryThreadEntry **entry;/* array of structs */ int count; int timer;/* used to receive processed entries */ } queryThreadData; #endif /*========================================== * (Only those needed) local declaration prototype *------------------------------------------*/ const char *parse_subexpr(const char *p,int limit); int run_func(struct script_state *st); 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, /** * No longer available, keeping here just in case it's back someday. [Ind] **/ //MF_RAIN, //20 // 21 free MF_NOGO = 22, MF_CLOUDS, 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_RESTRICTED, 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 }; 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(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 = map_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, status_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, status_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!!! - str_data.type=%s\n", script_op2name(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) || 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", 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", 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) /// 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; } /*========================================== * str_data manipulation functions *------------------------------------------*/ /// Looks up string using the provided id. const char *get_str(int id) { Assert(id >= LABEL_START && id < str_size); return str_buf+str_data[id].str; } /// Returns the uid of the string, or -1. static int search_str(const char *p) { int i; for (i = str_hash[calc_hash(p)]; i != 0; i = str_data[i].next) if (strcasecmp(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 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] = str_num; } else { // scan for end of list, or occurence of identical string for (i = str_hash[h]; ; i = str_data[i].next) { if (strcasecmp(get_str(i),p) == 0) return i; // string already in list if (str_data[i].next == 0) break; // reached the end } // append node to end of list str_data[i].next = str_num; } // grow list if neccessary if (str_num >= str_data_size) { str_data_size += 128; RECREATE(str_data,struct str_data_struct,str_data_size); memset(str_data + (str_data_size - 128), '\0', 128); } len=(int)strlen(p); // grow string buffer if neccessary while (str_pos+len+1 >= str_size) { str_size += 256; RECREATE(str_buf,char,str_size); memset(str_buf + (str_size - 256), '\0', 256); } safestrncpy(str_buf+str_pos, p, len+1); str_data[str_num].type = C_NOP; str_data[str_num].str = str_pos; str_data[str_num].next = 0; str_data[str_num].func = NULL; str_data[str_num].backpatch = -1; str_data[str_num].label = -1; str_pos += len+1; return 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 str_data object (label/function/variable/integer) to the script buffer. /// /// @param l The id of the str_data entry // Maximum up to 16M static void add_scriptl(int l) { int backpatch = str_data[l].backpatch; switch (str_data[l].type) { case C_POS: case C_USERFUNC_POS: add_scriptc(C_POS); add_scriptb(str_data[l].label); add_scriptb(str_data[l].label>>8); add_scriptb(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); str_data[l].backpatch = script_pos; add_scriptb(backpatch); add_scriptb(backpatch>>8); add_scriptb(backpatch>>16); break; case C_INT: add_scripti(abs(str_data[l].val)); if (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 (str_data[l].type==C_INT || str_data[l].type==C_PARAM || 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 (str_data[l].label!=-1) { disp_error_message("set_label: dup label ",script_pos); return; } str_data[l].type=(str_data[l].type == C_USERFUNC ? C_USERFUNC_POS : C_POS); str_data[l].label=pos; for (i=str_data[l].backpatch; i>=0 && i!=0x00ffffff;) { next=GETVALUE(script_buf,i); script_buf[i-1]=(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 *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') return p;//disp_error_message("script:skip_space: end of file while parsing block comment. expected "CL_BOLD"*/"CL_NORM, 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 alfanumeric 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; // postfix if (*p == '$') // string p++; return p; } /// Adds a word to str_data. /// @see skip_word /// @see add_str static int add_word(const char *p) { char *word; 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 alfanumeric characters, and valid variable prefixes/postfixes.", p); // Duplicate the word word = (char *)aMalloc(len+1); memcpy(word, p, len); word[len] = 0; // add the word i = add_str(word); aFree(word); 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; const char *arg=NULL; int func; func = add_word(p); if (str_data[func].type == C_FUNC) { // buildin function add_scriptl(func); add_scriptc(C_ARG); arg = buildin_func[str_data[func].val].arg; } else if (str_data[func].type == C_USERFUNC || str_data[func].type == C_USERFUNC_POS) { // script defined function add_scriptl(buildin_callsub_ref); add_scriptc(C_ARG); add_scriptl(func); arg = buildin_func[str_data[buildin_callsub_ref].val].arg; if (*arg == 0) disp_error_message("parse_callfunc: callsub has no arguments, please review it's definition",p); if (*arg != '*') ++arg; // count func as argument } else { #ifdef SCRIPT_CALLFUNC_CHECK const char *name = get_str(func); if (!is_custom && strdb_get(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 = buildin_func[str_data[buildin_callfunc_ref].val].arg; if (*arg != '*') ++ arg; } #endif } p = skip_word(p); p = 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=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=parse_subexpr(p,-1); if (p == p2) break; // not an argument if (*arg != '*') ++arg; // next argument p=skip_space(p2); if (*arg == 0 || *p != ',') break; // no more arguments ++p; // skip comma } --syntax.curly_count; } if (*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 str_data[LABEL_NEXTLINE].type = C_NOP; str_data[LABEL_NEXTLINE].backpatch = -1; 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 = 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 = 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 = skip_space(&p[1]); } break; case C_L_SHIFT: case C_R_SHIFT: {// left or right shift modifier p = skip_space(&p[3]); } break; default: {// normal incremental command p = 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 (str_data[word].type == C_FUNC || str_data[word].type == C_USERFUNC || 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 = parse_subexpr(p2 + 1, 1); p3 = 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 = 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) { int i; p=skip_space(p); if (*p==';' || *p==',') disp_error_message("parse_simpleexpr: unexpected expr end",p); if (*p=='(') { if ((i=syntax.curly_count-1) >= 0 && syntax.curly[i].type == TYPE_ARGLIST) ++syntax.curly[i].count; p=parse_subexpr(p+1,-1); p=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: unmatch ')'",p); ++p; } else if (ISDIGIT(*p) || ((*p=='-' || *p=='+') && ISDIGIT(p[1]))) { char *np; while (*p == '0' && ISDIGIT(p[1])) p++; i=strtoul(p,&np,0); add_scripti(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 = 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 eof @ 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 (str_data[l].type == C_FUNC || str_data[l].type == C_USERFUNC || str_data[l].type == C_USERFUNC_POS) return parse_callfunc(p,1,0); #ifdef SCRIPT_CALLFUNC_CHECK else { const char *name = get_str(l); if (strdb_get(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=parse_subexpr(p+1,-1); p=skip_space(p); if (*p != ']') disp_error_message("parse_simpleexpr: unmatch ']'",p); ++p; add_scriptc(C_FUNC); } else add_scriptl(l); } return p; } /*========================================== * Analysis of the expression *------------------------------------------*/ const char *parse_subexpr(const char *p,int limit) { int op,opl,len; const char *tmpp; p=skip_space(p); if (*p == '-') { tmpp = 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=parse_subexpr(p+1,10); add_scriptc(op); } else p=parse_simpleexpr(p); p=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=parse_subexpr(p,-1); p=skip_space(p); if (*(p++) != ':') disp_error_message("parse_subexpr: need ':'", p-1); p=parse_subexpr(p,-1); } else { p=parse_subexpr(p,opl); } add_scriptc(op); p=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=parse_subexpr(p,-1); return p; } /*========================================== * Analysis of the line *------------------------------------------*/ const char *parse_line(const char *p) { const char *p2; p=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 = 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 = 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=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=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 = 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=add_str(label); set_label(l,script_pos, p); } //Decision statement switch p = 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 not 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 not integer",np); } p = 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=add_str(label); set_label(l,script_pos,p); } // check duplication of case label [Rayce] if (linkdb_search(&syntax.curly[pos].case_label, (void *)__64BPRTSIZE(v)) != NULL) disp_error_message("parse_syntax: dup 'case'",p); linkdb_insert(&syntax.curly[pos].case_label, (void *)__64BPRTSIZE(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 = 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 = 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=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=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=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=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=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=add_str(label); set_label(l,script_pos,p); p=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(add_str("jump_zero")); add_scriptc(C_ARG); p=parse_expr(p); p=skip_space(p); add_scriptl(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=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=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 = 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 = skip_space(p); if (*p2 == ';') { // function ; // function declaration - just register the name int l; l = add_word(func_name); if (str_data[l].type == C_NOP) // register only, if the name was not used by something else str_data[l].type = C_USERFUNC; else if (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 (str_data[l].type == C_NOP || str_data[l].type == C_USERFUNC) { // register only, if the name was not used by something else str_data[l].type = C_USERFUNC; set_label(l, script_pos, p); if (parse_options&SCRIPT_USE_LABEL_DB) strdb_iput(scriptlabel_db, get_str(l), script_pos); } else disp_error_message("parse_syntax:function: function name is invalid", func_name); return 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=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(add_str("jump_zero")); add_scriptc(C_ARG); p=parse_expr(p); p=skip_space(p); add_scriptl(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=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(add_str("set")); add_scriptc(C_ARG); add_scriptl(add_str(label)); p=parse_expr(p); p=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=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=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(add_str("jump_zero")); add_scriptc(C_ARG); p=parse_expr(p); p=skip_space(p); add_scriptl(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=add_str(label); set_label(l,script_pos,p); syntax.curly[pos].count++; p = skip_space(p); p2 = skip_word(p); if (!syntax.curly[pos].flag && p2 - p == 4 && !strncasecmp(p,"else",4)) { // else or else - if p = skip_space(p2); p2 = skip_word(p); if (p2 - p == 2 && !strncasecmp(p,"if",2)) { // else - if p=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(add_str("jump_zero")); add_scriptc(C_ARG); p=parse_expr(p); p=skip_space(p); add_scriptl(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=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=add_str(label); set_label(l,script_pos,p); } // Skip to the end point if the condition is false p = skip_space(p); p2 = skip_word(p); if (p2 - p != 5 || strncasecmp(p,"while",5)) disp_error_message("parse_syntax: need 'while'",p); p = 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(add_str("jump_zero")); add_scriptc(C_ARG); p=parse_expr(p); p=skip_space(p); add_scriptl(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=add_str(label); set_label(l,script_pos,p); p = 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=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=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=add_str(label); set_label(l,script_pos,p); syntax.curly_count--; return p; } else { *flag = 0; return p; } } /*========================================== * Added built-in functions *------------------------------------------*/ static void add_buildin_func(void) { int i,n; const char *p; for (i = 0; buildin_func[i].func; i++) { // arg must follow the pattern: (v|s|i|r|l)*\?*\*? // 'v' - value (either string or int or reference) // 's' - string // 'i' - int // 'r' - reference (of a variable) // 'l' - label // '?' - one optional parameter // '*' - unknown number of optional parameters p = buildin_func[i].arg; while (*p == 'v' || *p == 's' || *p == 'i' || *p == 'r' || *p == 'l') ++p; while (*p == '?') ++p; if (*p == '*') ++p; if (*p != 0) { ShowWarning("add_buildin_func: ignoring function \"%s\" with invalid arg \"%s\".\n", buildin_func[i].name, buildin_func[i].arg); } else if (*skip_word(buildin_func[i].name) != 0) { ShowWarning("add_buildin_func: ignoring function with invalid name \"%s\" (must be a word).\n", buildin_func[i].name); } else { n = add_str(buildin_func[i].name); str_data[n].type = C_FUNC; str_data[n].val = i; str_data[n].func = buildin_func[i].func; if (!strcmp(buildin_func[i].name, "set")) buildin_set_ref = n; else if (!strcmp(buildin_func[i].name, "callsub")) buildin_callsub_ref = n; else if (!strcmp(buildin_func[i].name, "callfunc")) buildin_callfunc_ref = n; else if (!strcmp(buildin_func[i].name, "getelementofarray")) buildin_getelementofarray_ref = n; } } } /// Retrieves the value of a constant. bool script_get_constant(const char *name, int *value) { int n = search_str(name); if (n == -1 || str_data[n].type != C_INT) { // not found or not a constant return false; } value[0] = 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 = add_str(name); if (str_data[n].type == C_NOP) { // new str_data[n].type = isparameter ? C_PARAM : C_INT; str_data[n].val = value; } else if (str_data[n].type == C_PARAM || 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", (str_data[n].type == C_PARAM) ? "parameter" : "constant", name, 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(str_data[n].type)); } } /*========================================== * 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", 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) StringBuf_Printf(buf, "*% 5d : ", -line); else StringBuf_Printf(buf, " % 5d : ", line); for (i=0; p[i] && p[i] != '\n'; i++) { if (p + i != mark) StringBuf_Printf(buf, "%c", p[i]); else StringBuf_Printf(buf, "\'%c\'", p[i]); } StringBuf_AppendStr(buf, "\n"); return p+i+(p[i] == '\n' ? 1 : 0); } void script_error(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 }; StringBuf buf; for (p=src; p && *p; line++) { const char *lineend=strchr(p,'\n'); if (lineend==NULL || error_pos=0 && j!=0x00ffffff;) { next=GETVALUE(script_buf,j); SETVALUE(script_buf,j,i); j=next; } } else if (str_data[i].type == C_USERFUNC) { // 'function name;' without follow-up code ShowError("parse_script: function '%s' declared but not defined.\n", str_buf+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; iscript_buf = script_buf; code->script_size = script_size; code->script_vars = idb_alloc(DB_OPT_RELEASE_DATA); 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=map_id2sd(st->rid); if (!sd) { 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) { data->u.str = (char *)idb_get(instance[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) data->u.num = (int)idb_iget(instance[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; } struct script_data *push_val2(struct script_stack *stack, enum c_op type, int val, struct DBMap **ref); /// 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; push_val2(st->stack, C_NAME, uid, ref); data = script_getdatatop(st, -1); get_val(st, data); return (data->type == C_INT ? (void *)__64BPRTSIZE(data->u.num) : (void *)__64BPRTSIZE(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) { idb_remove(instance[st->instance_id].vars, num); if (str[0]) idb_put(instance[st->instance_id].vars, num, aStrdup(str)); } return 1; default: return pc_setglobalreg_str(sd, name, str); } } else { // integer variable int val = (int)__64BPRTSIZE(value); if (str_data[num&0x00ffffff].type == C_PARAM) { if (pc_setparam(sd, 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) { idb_remove(instance[st->instance_id].vars, num); if (val != 0) idb_iput(instance[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(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(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; 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 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; 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 #define push_val(stack,type,val) push_val2(stack, type, val, NULL) /// Pushes a value into the stack (with reference) struct script_data *push_val2(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 push_str(stack, C_CONSTSTR, stack->stack_data[pos].u.str); break; case C_STR: return 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 push_val2( 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 *script, int pos, int rid, int oid) { struct script_state *st; CREATE(st, struct script_state, 1); st->stack = (struct script_stack *)aMalloc(sizeof(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 = script; //st->scriptroot = script; st->pos = pos; st->rid = rid; st->oid = oid; st->sleep.timer = INVALID_TIMER; return st; } /// Frees a script state. /// /// @param st Script state void script_free_state(struct script_state *st) { 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) delete_timer(st->sleep.timer, run_script_timer); script_free_vars(st->stack->var_function); pop_stack(st, 0, st->stack->sp); aFree(st->stack->stack_data); aFree(st->stack); st->stack = NULL; st->pos = -1; aFree(st); } // // Main execution unit // /*========================================== * Read command *------------------------------------------*/ c_op get_com(unsigned char *script,int *pos) { int i = 0, j = 0; if (script[*pos]>=0x80) { return C_INT; } while (script[*pos]>=0x40) { i=script[(*pos)++]<=0xc0) { i+=(script[(*pos)++]&0x7f)<stack->sp<=0) return 0; st->stack->sp--; 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); 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; } get_val(st, left); get_val(st, right); // automatic conversions switch (op) { case C_ADD: if (data_isint(left) && data_isstring(right)) { // convert int-string to string-string conv_str(st, left); } else if (data_isstring(left) && data_isint(right)) { // convert string-int to string-string 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) { 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); 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; script_function *sf = &buildin_func[str_data[func].val]; for (idx = 2; script_hasdata(st, idx); idx++) { struct script_data *data = script_getdata(st, idx); type = sf->arg[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", 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 && 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 (str_data[func].func) { if (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", get_str(func), func, script_op2name(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; 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; 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)); 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); run_script_main(st); } void script_stop_sleeptimers(int id) { struct script_state *st; for (;;) { st = (struct script_state *)linkdb_erase(&sleep_db,(void *)__64BPRTSIZE(id)); if (st == NULL) break; // no more sleep timers script_free_state(st); } } /*========================================== * Delete the specified node from sleep_db *------------------------------------------*/ struct linkdb_node *script_erase_sleepdb(struct linkdb_node *n) { struct linkdb_node *retnode; if (n == NULL) return NULL; if (n->prev == NULL) sleep_db = n->next; else n->prev->next = n->next; if (n->next) n->next->prev = n->prev; retnode = n->next; aFree(n); return retnode; // The following; return retnode } /*========================================== * Timer function for sleep *------------------------------------------*/ int run_script_timer(int tid, unsigned int tick, int id, intptr_t data) { struct script_state *st = (struct script_state *)data; struct linkdb_node *node = (struct linkdb_node *)sleep_db; TBL_PC *sd = map_id2sd(st->rid); if ((sd && sd->status.char_id != id) || (st->rid && !sd)) { //Character mismatch. Cancel execution. st->rid = 0; st->state = END; } while (node && st->sleep.timer != INVALID_TIMER) { if ((int)__64BPRTSIZE(node->key) == st->oid && ((struct script_state *)node->data)->sleep.timer == st->sleep.timer) { script_erase_sleepdb(node); st->sleep.timer = INVALID_TIMER; break; } node = node->next; } if (st->state != RERUNLINE) st->sleep.tick = 0; run_script_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 = map_id2sd(st->rid))!=NULL) { sd->st = st->bk_st; sd->npc_id = st->bk_npcid; /** * For the Secure NPC Timeout option (check config/Secure.h) [RR] **/ #if 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) { delete_timer(sd->npc_idle_timer,npc_rr_secure_timeout_timer); sd->npc_idle_timer = INVALID_TIMER; } #endif if (st->bk_st) { //Remove tag for removal. st->bk_st = NULL; st->bk_npcid = 0; } else if (dequeue_event) { 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. static void script_attach_state(struct script_state *st) { struct map_session_data *sd; if (st->rid && (sd = map_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; /** * For the Secure NPC Timeout option (check config/Secure.h) [RR] **/ #if SECURE_NPCTIMEOUT if (sd->npc_idle_timer == INVALID_TIMER) sd->npc_idle_timer = add_timer(gettick() + (SECURE_NPCTIMEOUT_INTERVAL*1000),npc_rr_secure_timeout_timer,sd->bl.id,0); sd->npc_idle_tick = 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 = map_id2nd(st->oid); if (nd && map[nd->bl.m].instance_id > 0) st->instance_id = map[nd->bl.m].instance_id; 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 pop_stack(st, stack->defsp, stack->sp);// pop unused stack data. (unused return value) break; case C_INT: push_val(stack,C_INT,get_num(st->script->script_buf,&st->pos)); break; case C_POS: case C_NAME: push_val(stack,c,GETVALUE(st->script->script_buf,st->pos)); st->pos+=3; break; case C_ARG: push_val(stack,c,0); break; case C_STR: 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 = map_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 = add_timer(gettick()+st->sleep.tick, run_script_timer, st->sleep.charid, (intptr_t)st); linkdb_insert(&sleep_db, (void *)__64BPRTSIZE(st->oid), st); } 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 = map_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; fp=fopen(cfgName,"r"); if (fp==NULL) { 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 *script = (struct script_code *)strdb_get(autobonus_db, autobonus); if (script) { current_equip_item_index = pos; run_script(script,0,id,0); } } void script_add_autobonus(const char *autobonus) { if (strdb_get(autobonus_db, autobonus) == NULL) { struct script_code *script = parse_script(autobonus, "autobonus", 0, 0); if (script) strdb_put(autobonus_db, autobonus, script); } } /// 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 = 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)__64BPRTSIZE(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] : 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)__64BPRTSIZE(value)); } if (refcache) { // save to avoid repeated add_str calls refcache[0] = key; } } #ifdef BETA_THREAD_TEST int buildin_query_sql_sub(struct script_state *st, Sql *handle); /* used to receive items the queryThread has already processed */ int queryThread_timer(int tid, unsigned int tick, int id, intptr_t data) { int i, cursor = 0; bool allOk = true; EnterSpinLock(&queryThreadLock); for (i = 0; i < queryThreadData.count; i++) { struct queryThreadEntry *entry = queryThreadData.entry[i]; if (!entry->ok) { allOk = false; continue; } run_script_main(entry->st); entry->st = NULL;/* empty entries */ aFree(entry); queryThreadData.entry[i] = NULL; } if (allOk) { /* cancel the repeating timer -- it'll re-create itself when necessary, dont need to remain looping */ delete_timer(queryThreadData.timer, queryThread_timer); queryThreadData.timer = INVALID_TIMER; } /* now lets clear the mess. */ for (i = 0; i < queryThreadData.count; i++) { struct queryThreadEntry *entry = queryThreadData.entry[i]; if (entry == NULL) continue;/* entry on hold */ /* move */ memmove(&queryThreadData.entry[cursor], &queryThreadData.entry[i], sizeof(struct queryThreadEntry *)); cursor++; } queryThreadData.count = cursor; LeaveSpinLock(&queryThreadLock); return 0; } void queryThread_add(struct script_state *st, bool type) { int idx = 0; struct queryThreadEntry *entry = NULL; EnterSpinLock(&queryThreadLock); if (queryThreadData.count++ != 0) RECREATE(queryThreadData.entry, struct queryThreadEntry * , queryThreadData.count); idx = queryThreadData.count-1; CREATE(queryThreadData.entry[idx],struct queryThreadEntry,1); entry = queryThreadData.entry[idx]; entry->st = st; entry->ok = false; entry->type = type; if (queryThreadData.timer == INVALID_TIMER) { /* start the receiver timer */ queryThreadData.timer = add_timer_interval(gettick() + 100, queryThread_timer, 0, 0, 100); } LeaveSpinLock(&queryThreadLock); /* unlock the queryThread */ racond_signal(queryThreadCond); } /* adds a new log to the queue */ void queryThread_log(char *entry, int length) { int idx = logThreadData.count; EnterSpinLock(&queryThreadLock); if (logThreadData.count++ != 0) RECREATE(logThreadData.entry, char * , logThreadData.count); CREATE(logThreadData.entry[idx], char, length + 1); safestrncpy(logThreadData.entry[idx], entry, length + 1); LeaveSpinLock(&queryThreadLock); /* unlock the queryThread */ racond_signal(queryThreadCond); } /* queryThread_main */ static void *queryThread_main(void *x) { Sql *queryThread_handle = Sql_Malloc(); int i; if (SQL_ERROR == Sql_Connect(queryThread_handle, map_server_id, map_server_pw, map_server_ip, map_server_port, map_server_db)) exit(EXIT_FAILURE); if (strlen(default_codepage) > 0) if (SQL_ERROR == Sql_SetEncoding(queryThread_handle, default_codepage)) Sql_ShowDebug(queryThread_handle); if (log_config.sql_logs) { logmysql_handle = Sql_Malloc(); if (SQL_ERROR == Sql_Connect(logmysql_handle, log_db_id, log_db_pw, log_db_ip, log_db_port, log_db_db)) exit(EXIT_FAILURE); if (strlen(default_codepage) > 0) if (SQL_ERROR == Sql_SetEncoding(logmysql_handle, default_codepage)) Sql_ShowDebug(logmysql_handle); } while (1) { if (queryThreadTerminate > 0) break; EnterSpinLock(&queryThreadLock); /* mess with queryThreadData within the lock */ for (i = 0; i < queryThreadData.count; i++) { struct queryThreadEntry *entry = queryThreadData.entry[i]; if (entry->ok) continue; else if (!entry->st || !entry->st->stack) { entry->ok = true;/* dispose */ continue; } buildin_query_sql_sub(entry->st, entry->type ? logmysql_handle : queryThread_handle); entry->ok = true;/* we're done with this */ } /* also check for any logs in need to be sent */ if (log_config.sql_logs) { for (i = 0; i < logThreadData.count; i++) { if (SQL_ERROR == Sql_Query(logmysql_handle, logThreadData.entry[i])) Sql_ShowDebug(logmysql_handle); aFree(logThreadData.entry[i]); } logThreadData.count = 0; } LeaveSpinLock(&queryThreadLock); ramutex_lock(queryThreadMutex); racond_wait(queryThreadCond, queryThreadMutex, -1); ramutex_unlock(queryThreadMutex); } Sql_Free(queryThread_handle); if (log_config.sql_logs) { Sql_Free(logmysql_handle); } return NULL; } #endif /*========================================== * Destructor *------------------------------------------*/ int do_final_script() { int i; #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; 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 mapreg_final(); db_destroy(scriptlabel_db); userfunc_db->destroy(userfunc_db, db_script_free_code_sub); autobonus_db->destroy(autobonus_db, db_script_free_code_sub); if (sleep_db) { struct linkdb_node *n = (struct linkdb_node *)sleep_db; while (n) { struct script_state *st = (struct script_state *)n->data; script_free_state(st); n = n->next; } linkdb_final(&sleep_db); } if (str_data) aFree(str_data); if (str_buf) aFree(str_buf); for (i = 0; i < atcmd_binding_count; i++) { aFree(atcmd_binding[i]); } if (atcmd_binding_count != 0) aFree(atcmd_binding); #ifdef BETA_THREAD_TEST /* QueryThread */ InterlockedIncrement(&queryThreadTerminate); racond_signal(queryThreadCond); rathread_wait(queryThread, NULL); // Destroy cond var and mutex. racond_destroy(queryThreadCond); ramutex_destroy(queryThreadMutex); /* Clear missing vars */ for (i = 0; i < queryThreadData.count; i++) { aFree(queryThreadData.entry[i]); } aFree(queryThreadData.entry); for (i = 0; i < logThreadData.count; i++) { aFree(logThreadData.entry[i]); } aFree(logThreadData.entry); #endif return 0; } /*========================================== * Initialization *------------------------------------------*/ int do_init_script() { userfunc_db=strdb_alloc(DB_OPT_DUP_KEY,0); scriptlabel_db=strdb_alloc(DB_OPT_DUP_KEY,50); autobonus_db = strdb_alloc(DB_OPT_DUP_KEY,0); mapreg_init(); #ifdef BETA_THREAD_TEST CREATE(queryThreadData.entry, struct queryThreadEntry *, 1); queryThreadData.count = 0; CREATE(logThreadData.entry, char *, 1); logThreadData.count = 0; /* QueryThread Start */ InitializeSpinLock(&queryThreadLock); queryThreadData.timer = INVALID_TIMER; queryThreadTerminate = 0; queryThreadMutex = ramutex_create(); queryThreadCond = racond_create(); queryThread = rathread_create(queryThread_main, NULL); if (queryThread == NULL) { ShowFatalError("do_init_script: cannot spawn Query Thread.\n"); exit(EXIT_FAILURE); } add_timer_func_list(queryThread_timer, "queryThread_timer"); #endif return 0; } int script_reload() { int i; #ifdef BETA_THREAD_TEST /* we're reloading so any queries undergoing should be...exterminated. */ EnterSpinLock(&queryThreadLock); for (i = 0; i < queryThreadData.count; i++) { aFree(queryThreadData.entry[i]); } queryThreadData.count = 0; if (queryThreadData.timer != INVALID_TIMER) { delete_timer(queryThreadData.timer, queryThread_timer); queryThreadData.timer = INVALID_TIMER; } LeaveSpinLock(&queryThreadLock); #endif userfunc_db->clear(userfunc_db, db_script_free_code_sub); db_clear(scriptlabel_db); // @commands (script based) // Clear bindings for (i = 0; i < atcmd_binding_count; i++) { aFree(atcmd_binding[i]); } if (atcmd_binding_count != 0) aFree(atcmd_binding); atcmd_binding_count = 0; if (sleep_db) { struct linkdb_node *n = (struct linkdb_node *)sleep_db; while (n) { struct script_state *st = (struct script_state *)n->data; script_free_state(st); n = n->next; } linkdb_final(&sleep_db); } mapreg_reload(); return 0; } //----------------------------------------------------------------------------- // buildin functions // #define BUILDIN_DEF(x,args) { buildin_ ## x , #x , args } #define BUILDIN_DEF2(x,x2,args) { buildin_ ## x , x2 , args } #define BUILDIN_FUNC(x) int buildin_ ## x (struct script_state* st) ///////////////////////////////////////////////////////////////////// // NPC interaction // /// Appends a message to the npc dialog. /// If a dialog doesn't exist yet, one is created. /// /// mes ""; BUILDIN_FUNC(mes) { TBL_PC *sd = script_rid2sd(st); if (sd == NULL) return 0; 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 0; } /// Displays the button 'next' in the npc dialog. /// The dialog text is cleared and the script continues when the button is pressed. /// /// next; BUILDIN_FUNC(next) { TBL_PC *sd; sd = script_rid2sd(st); if (sd == NULL) return 0; st->state = STOP; clif_scriptnext(sd, st->oid); return 0; } /// Ends the script and displays the button 'close' on the npc dialog. /// The dialog is closed when the button is pressed. /// /// close; BUILDIN_FUNC(close) { TBL_PC *sd; sd = script_rid2sd(st); if (sd == NULL) return 0; st->state = END; clif_scriptclose(sd, st->oid); return 0; } /// Displays the button 'close' on the npc dialog. /// The dialog is closed and the script continues when the button is pressed. /// /// close2; BUILDIN_FUNC(close2) { TBL_PC *sd; sd = script_rid2sd(st); if (sd == NULL) return 0; st->state = STOP; clif_scriptclose(sd, st->oid); return 0; } /// 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_FUNC(menu) { int i; const char *text; TBL_PC *sd; sd = script_rid2sd(st); if (sd == NULL) return 0; // 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 1; } StringBuf_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 StringBuf_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 1; } // append option(s) if (text[0] == '\0') continue;// empty string, ignore if (sd->npc_menu > 0) StringBuf_AppendStr(&buf, ":"); StringBuf_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 (StringBuf_Length(&buf) >= 2047) { struct npc_data *nd = map_id2nd(st->oid); char *menu; CREATE(menu, char, 2048); safestrncpy(menu, StringBuf_Value(&buf), 2047); ShowWarning("NPC Menu too long! (source:%s / length:%d)\n",nd?nd->name:"Unknown",StringBuf_Length(&buf)); clif_scriptmenu(sd, st->oid, menu); aFree(menu); } else clif_scriptmenu(sd, st->oid, StringBuf_Value(&buf)); StringBuf_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 1; } // 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 1; } 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 1; } pc_setreg(sd, add_str("@menu"), menu); st->pos = script_getnum(st, i + 1); st->state = GOTO; } return 0; } /// Displays a menu with options and returns the selected option. /// Behaves like 'menu' without the target labels. /// /// select({,,...}) -> /// /// @see menu BUILDIN_FUNC(select) { int i; const char *text; TBL_PC *sd; sd = script_rid2sd(st); if (sd == NULL) return 0; if (sd->state.menu_or_input == 0) { struct StringBuf buf; StringBuf_Init(&buf); sd->npc_menu = 0; for (i = 2; i <= script_lastdata(st); ++i) { text = script_getstr(st, i); if (sd->npc_menu > 0) StringBuf_AppendStr(&buf, ":"); StringBuf_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 (StringBuf_Length(&buf) >= 2047) { struct npc_data *nd = map_id2nd(st->oid); char *menu; CREATE(menu, char, 2048); safestrncpy(menu, StringBuf_Value(&buf), 2047); ShowWarning("NPC Menu too long! (source:%s / length:%d)\n",nd?nd->name:"Unknown",StringBuf_Length(&buf)); clif_scriptmenu(sd, st->oid, menu); aFree(menu); } else clif_scriptmenu(sd, st->oid, StringBuf_Value(&buf)); StringBuf_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, add_str("@menu"), menu); script_pushint(st, menu); st->state = RUN; } return 0; } /// 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_FUNC(prompt) { int i; const char *text; TBL_PC *sd; sd = script_rid2sd(st); if (sd == NULL) return 0; if (sd->state.menu_or_input == 0) { struct StringBuf buf; StringBuf_Init(&buf); sd->npc_menu = 0; for (i = 2; i <= script_lastdata(st); ++i) { text = script_getstr(st, i); if (sd->npc_menu > 0) StringBuf_AppendStr(&buf, ":"); StringBuf_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 (StringBuf_Length(&buf) >= 2047) { struct npc_data *nd = map_id2nd(st->oid); char *menu; CREATE(menu, char, 2048); safestrncpy(menu, StringBuf_Value(&buf), 2047); ShowWarning("NPC Menu too long! (source:%s / length:%d)\n",nd?nd->name:"Unknown",StringBuf_Length(&buf)); clif_scriptmenu(sd, st->oid, menu); aFree(menu); } else clif_scriptmenu(sd, st->oid, StringBuf_Value(&buf)); StringBuf_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, 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, add_str("@menu"), menu); script_pushint(st, menu); st->state = RUN; } return 0; } ///////////////////////////////////////////////////////////////////// // ... // /// Jumps to the target script label. /// /// goto