// 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/lock.h" #include "../common/nullpo.h" #include "../common/showmsg.h" #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 #include #include #include #ifndef WIN32 #include #endif #include #include #include /////////////////////////////////////////////////////////////////////////////// //## 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; #define GETVALUE(buf,i) ((int)MakeDWord(MakeWord((buf)[i],(buf)[i+1]),MakeWord((buf)[i+2],0))) #define SETVALUE(buf,i,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(){ return scriptlabel_db; } DBMap* script_get_userfunc_db(){ return userfunc_db; } // 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]; // 右カッコの情報 int curly_count; // 右カッコの数 int index; // スクリプト内で使用した構文の数 } 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* /*========================================== * ローカルプロトタイプ宣言 (必要な物のみ) *------------------------------------------*/ 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, 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 }; 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)); } } /*========================================== * エラーメッセージ出力 *------------------------------------------*/ 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") ) { if( npc_event_isspecial(evt) ) { ; // portable small/large monsters or other attributes } else { 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 // 最大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: // ラベルの可能性があるのでbackpatch用データ埋め込み 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; } } /*========================================== * ラベルを解決する *------------------------------------------*/ 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 = 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) { 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 int callsub = search_str("callsub"); add_scriptl(callsub); add_scriptc(C_ARG); add_scriptl(func); arg = buildin_func[str_data[callsub].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 disp_error_message("parse_line: expect command, missing function name or calling undeclared function",p); 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; } /*========================================== * 項の解析 *------------------------------------------*/ 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; 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; // 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); p=skip_word(p); if( *p == '[' ){ // array(name[i] => getelementofarray(name,i) ) add_scriptl(search_str("getelementofarray")); 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; } /*========================================== * 式の解析 *------------------------------------------*/ 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; } } tmpp=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 */ } /*========================================== * 式の評価 *------------------------------------------*/ 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; } /*========================================== * 行の解析 *------------------------------------------*/ const char* parse_line(const char* p) { const char* p2; p=skip_space(p); if(*p==';') { // 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); } // 構文関連の処理 p2 = parse_syntax(p); if(p2 != NULL) return p2; p = parse_callfunc(p,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); } // if, for , while の閉じ判定 p = parse_syntax_close(p+1); return p; } // { ... } の閉じ処理 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--; // if, for , while の閉じ判定 p = parse_syntax_close(p + 1); return p; } else if(syntax.curly[syntax.curly_count-1].type == TYPE_SWITCH) { // switch() 閉じ判定 int pos = syntax.curly_count-1; char label[256]; int l; // 一時変数を消す sprintf(label,"set $@__SW%x_VAL,0;",syntax.curly[pos].index); syntax.curly[syntax.curly_count++].type = TYPE_NULL; parse_line(label); syntax.curly_count--; // 無条件で終了ポインタに移動 sprintf(label,"goto __SW%x_FIN;",syntax.curly[pos].index); syntax.curly[syntax.curly_count++].type = TYPE_NULL; parse_line(label); syntax.curly_count--; // 現在地のラベルを付ける 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) { // default が存在する sprintf(label,"goto __SW%x_DEF;",syntax.curly[pos].index); syntax.curly[syntax.curly_count++].type = TYPE_NULL; parse_line(label); syntax.curly_count--; } // 終了ラベルを付ける sprintf(label,"__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--; // if, for , while の閉じ判定 p = parse_syntax_close(p + 1); return p; } else { disp_error_message("parse_curly_close: unexpected string",p); return p + 1; } } // 構文関連の処理 // break, case, continue, default, do, for, function, // if, switch, while をこの内部で処理します。 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 の処理 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); // if, for , while の閉じ判定 p = parse_syntax_close(p + 1); return p; } break; case 'c': case 'C': if(p2 - p == 4 && !strncasecmp(p,"case",4)) { // 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) { // FALLTHRU 用のジャンプ sprintf(label,"goto __SW%x_%xJ;",syntax.curly[pos].index,syntax.curly[pos].count); syntax.curly[syntax.curly_count++].type = TYPE_NULL; parse_line(label); syntax.curly_count--; // 現在地のラベルを付ける sprintf(label,"__SW%x_%x",syntax.curly[pos].index,syntax.curly[pos].count); l=add_str(label); set_label(l,script_pos, p); } // 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; // ２回parse しないとダメ p2 = parse_line(label); parse_line(p2); syntax.curly_count--; if(syntax.curly[pos].count != 1) { // 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*)v) != NULL) disp_error_message("parse_syntax: dup 'case'",p); linkdb_insert(&syntax.curly[pos].case_label, (void*)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)) { // 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; // 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); // 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 の処理 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; // 現在地のラベルを付ける 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); // 無条件で次のリンクに飛ばす 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--; // default のラベルを付ける 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; // 現在地のラベル形成する 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++; // 初期化文を実行する syntax.curly[syntax.curly_count++].type = TYPE_NULL; p=parse_line(p); syntax.curly_count--; // 条件判断開始のラベル形成する 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(;;) のパターンなので必ず真 ; } else { // 条件が偽なら終了地点に飛ばす 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++; // ループ開始に飛ばす sprintf(label,"goto __FR%x_BGN;",syntax.curly[pos].index); syntax.curly[syntax.curly_count++].type = TYPE_NULL; parse_line(label); syntax.curly_count--; // 次のループへのラベル形成する sprintf(label,"__FR%x_NXT",syntax.curly[pos].index); l=add_str(label); set_label(l,script_pos,p); // 次のループに入る時の処理 // for 最後の ')' を ';' として扱うフラグ 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; // 条件判定処理に飛ばす sprintf(label,"goto __FR%x_J;",syntax.curly[pos].index); syntax.curly[syntax.curly_count++].type = TYPE_NULL; parse_line(label); syntax.curly_count--; // ループ開始のラベル付け sprintf(label,"__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); // 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_put(scriptlabel_db, get_str(l), (void*)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() の処理 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)) { // 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; // 条件判断開始のラベル形成する sprintf(label,"__WL%x_NXT",syntax.curly[syntax.curly_count].index); l=add_str(label); set_label(l,script_pos,p); // 条件が偽なら終了地点に飛ばす 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(); のように、１度閉じられたら再度閉じられるか確認する int flag; do { p = parse_syntax_close_sub(p,&flag); } while(flag); return p; } // if, for , while , do の閉じ判定 // flag == 1 : 閉じられた // flag == 0 : 閉じられない 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); // if 最終場所へ飛ばす sprintf(label,"goto __IF%x_FIN;",syntax.curly[pos].index); syntax.curly[syntax.curly_count++].type = TYPE_NULL; parse_line(label); syntax.curly_count--; // 現在地のラベルを付ける sprintf(label,"__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; } } } // if 閉じ syntax.curly_count--; // 最終地のラベルを付ける 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) { // このifに対するelseじゃないのでポインタの位置は同じ 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) { // 現在地のラベル形成する(continue でここに来る) sprintf(label,"__DO%x_NXT",syntax.curly[pos].index); l=add_str(label); set_label(l,script_pos,p); } // 条件が偽なら終了地点に飛ばす 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); // 開始地点に飛ばす sprintf(label,"goto __DO%x_BGN;",syntax.curly[pos].index); syntax.curly[syntax.curly_count++].type = TYPE_NULL; parse_line(label); syntax.curly_count--; // 条件終了地点のラベル形成する sprintf(label,"__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); // 次のループに飛ばす sprintf(label,"goto __FR%x_NXT;",syntax.curly[pos].index); syntax.curly[syntax.curly_count++].type = TYPE_NULL; parse_line(label); syntax.curly_count--; // for 終了のラベル付け 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); // 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--; // while 終了のラベル付け 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; // 戻す sprintf(label,"return;"); syntax.curly[syntax.curly_count++].type = TYPE_NULL; parse_line(label); syntax.curly_count--; // 現在地のラベルを付ける 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; } } /*========================================== * 組み込み関数の追加 *------------------------------------------*/ 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; } } } /// 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)); } } /*========================================== * 定数データベースの読み込み *------------------------------------------*/ 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); } /*========================================== * エラー表示 *------------------------------------------*/ 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) { // エラーが発生した行を求める 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_posclear(scriptlabel_db, NULL); parse_options = options; if( setjmp( error_jump ) != 0 ) { //Restore program state when script has problems. [from jA] int i; const int size = ARRAYLENGTH(syntax.curly); if( error_report ) script_error(src,file,line,error_msg,error_pos); aFree( error_msg ); aFree( script_buf ); script_pos = 0; script_size = 0; script_buf = NULL; for(i=LABEL_START;i=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 = NULL; return code; } /// Returns the player attached to this script, identified by the rid. /// If there is no player attached, the script is terminated. TBL_PC *script_rid2sd(struct script_state *st) { TBL_PC *sd=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 linkdb_node** n = data->ref ? data->ref: name[1] == '@' ? st->stack->var_function:// instance/scope variable &st->script->script_vars;// npc variable data->u.str = (char*)linkdb_search(n, (void*)reference_getuid(data)); } break; case '\'': { struct linkdb_node** n = NULL; if( st->instance_id ) n = &instance[st->instance_id].svar; data->u.str = (char*)linkdb_search(n, (void*)reference_getuid(data)); } 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 linkdb_node** n = data->ref ? data->ref: name[1] == '@' ? st->stack->var_function:// instance/scope variable &st->script->script_vars;// npc variable data->u.num = (int)linkdb_search(n, (void*)reference_getuid(data)); } break; case '\'': { struct linkdb_node** n = NULL; if( st->instance_id ) n = &instance[st->instance_id].ivar; data->u.num = (int)linkdb_search(n, (void*)reference_getuid(data)); } 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 linkdb_node** 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 linkdb_node** 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*)data->u.num : (void*)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 linkdb_node** 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 '.': { char* p; struct linkdb_node** n; n = (ref) ? ref : (name[1] == '@') ? st->stack->var_function : &st->script->script_vars; p = (char*)linkdb_erase(n, (void*)num); if (p) aFree(p); if (str[0]) linkdb_insert(n, (void*)num, aStrdup(str)); } return 1; case '\'': { char *p; struct linkdb_node** n = NULL; if( st->instance_id ) n = &instance[st->instance_id].svar; p = (char*)linkdb_erase(n, (void*)num); if (p) aFree(p); if( str[0] ) linkdb_insert(n, (void*)num, aStrdup(str)); } return 1; default: return pc_setglobalreg_str(sd, name, str); } } else {// integer variable int val = (int)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 linkdb_node** n; n = (ref) ? ref : (name[1] == '@') ? st->stack->var_function : &st->script->script_vars; if (val == 0) linkdb_erase(n, (void*)num); else linkdb_replace(n, (void*)num, (void*)val); } return 1; case '\'': { struct linkdb_node** n = NULL; if( st->instance_id ) n = &instance[st->instance_id].ivar; if( val == 0 ) linkdb_erase(n, (void*)num); else linkdb_replace(n, (void*)num, (void*)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 linkdb_node **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 linkdb_node** 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) { 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 = NULL; 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); aFree(ri->var_function); } 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; } /// /// /// /*========================================== * スクリプト依存変数、関数依存変数の解放 *------------------------------------------*/ void script_free_vars(struct linkdb_node **node) { struct linkdb_node* n = *node; while( n != NULL) { const char* name = get_str((int)(n->key)&0x00ffffff); if( is_string_variable(name) ) aFree(n->data); // 文字型変数なので、データ削除 n = n->next; } linkdb_final( node ); } 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; CREATE(st->stack->var_function, struct linkdb_node*, 1); 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); aFree(st->stack->var_function); pop_stack(st, 0, st->stack->sp); aFree(st->stack->stack_data); aFree(st->stack); st->pos = -1; aFree(st); } // // 実行部main // /*========================================== * コマンドの読み取り *------------------------------------------*/ 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 *)aMallocA((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; struct script_data* right; left = script_getdatatop(st, -2); right = script_getdatatop(st, -1); 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, -3, -1);// pop the two values before the top one } else if( data_isint(left) && data_isint(right) ) {// ii => op_2num int i1 = left->u.num; int i2 = right->u.num; script_removetop(st, -2, 0); op_2num(st, op, i1, i2); } 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.\n"); 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.\n", idx-1); script_reportdata(data); invalid++; } break; case 'l': if( !data_islabel(data) && !data_isfunclabel(data) ) {// label ShowWarning("Unexpected type for argument %d. Expected label.\n", idx-1); 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 ); aFree(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*)id); if( st == NULL ) break; // no more sleep timers script_free_state(st); } } /*========================================== * 指定ノードを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; // 次のノードを返す } /*========================================== * 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)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; 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; } } /*========================================== * スクリプトの実行メイン部分 *------------------------------------------*/ 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( gotocount>0 && (--gotocount)<=0 ){ ShowError("run_script: infinity loop !\n"); script_reportsrc(st); st->state=END; } } 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( 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*)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); } } fclose(fp); return 0; } static int do_final_userfunc_sub (DBKey key,void *data,va_list ap) { struct script_code *code = (struct script_code *)data; if(code){ script_free_vars( &code->script_vars ); aFree( code->script_buf ); aFree( code ); } return 0; } static int do_final_autobonus_sub (DBKey key,void *data,va_list ap) { struct script_code *script = (struct script_code *)data; if( script ) script_free_code(script); 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)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)value); } if( refcache ) {// save to avoid repeated add_str calls refcache[0] = key; } } /*========================================== * 終了 *------------------------------------------*/ int do_final_script() { #ifdef DEBUG_HASH if (battle_config.etc_log) { FILE *fp = fopen("hash_dump.txt","wt"); if(fp) { int i,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(); scriptlabel_db->destroy(scriptlabel_db,NULL); userfunc_db->destroy(userfunc_db,do_final_userfunc_sub); autobonus_db->destroy(autobonus_db, do_final_autobonus_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); return 0; } /*========================================== * 初期化 *------------------------------------------*/ int do_init_script() { userfunc_db=strdb_alloc(DB_OPT_DUP_KEY,0); scriptlabel_db=strdb_alloc((DBOptions)(DB_OPT_DUP_KEY|DB_OPT_ALLOW_NULL_DATA),50); autobonus_db = strdb_alloc(DB_OPT_DUP_KEY,0); mapreg_init(); return 0; } int script_reload() { userfunc_db->clear(userfunc_db,do_final_userfunc_sub); scriptlabel_db->clear(scriptlabel_db, NULL); 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; clif_scriptmes(sd, st->oid, script_getstr(st, 2)); 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; 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; 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; 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