void init_image__xpm( ) { ADD_FUNCTION( "_xpm_write_rows", f__xpm_write_rows, tFunc(tObj tObj tInt tArr(tStr) tArr(tStr), tInt), 0); ADD_FUNCTION( "_xpm_trim_rows", f__xpm_trim_rows, tFunc(tArr(tStr),tArr(tStr)), 0); }
void cairo_mod_init_path(void) { /*! @decl constant CAIRO_PATH_MOVE_TO *! @decl constant CAIRO_PATH_LINE_TO *! @decl constant CAIRO_PATH_CURVE_TO *! @decl constant CAIRO_PATH_CLOSE_PATH *! *! The various types of path elements in an Cairo path */ ADD_INT_CONSTANT("CAIRO_PATH_MOVE_TO", CAIRO_PATH_MOVE_TO, 0); ADD_INT_CONSTANT("CAIRO_PATH_LINE_TO", CAIRO_PATH_LINE_TO, 0); ADD_INT_CONSTANT("CAIRO_PATH_CURVE_TO", CAIRO_PATH_CURVE_TO, 0); ADD_INT_CONSTANT("CAIRO_PATH_CLOSE_PATH", CAIRO_PATH_CLOSE_PATH, 0); /* Cairo.Path */ start_new_program(); { ADD_STORAGE(struct cairo_mod_path); ADD_FUNCTION("_get_iterator", f_path_get_iterator, tFunc(tVoid,tObj), ID_PUBLIC); set_init_callback(init_cairo_mod_path); set_exit_callback(exit_cairo_mod_path); } add_program_constant("Path", cairo_mod_path_program = end_program(), 0); /* Cairo.PathElement */ start_new_program(); { ADD_STORAGE(struct cairo_mod_path_element); ADD_FUNCTION("get_type", f_path_element_get_type, tFunc(tNone,tInt), ID_PUBLIC); ADD_FUNCTION("get_point", f_path_element_get_point, tFunc(tInt, tMapping), ID_PUBLIC); ADD_FUNCTION("_sprintf", f_path_element_sprintf, tFunc(tInt tMapping, tStr), ID_STATIC); set_init_callback(init_cairo_mod_path_element); set_exit_callback(exit_cairo_mod_path_element); } add_program_constant("PathElement", cairo_mod_path_element_program = end_program(), 0); /* Cairo.PathIterator */ start_new_program(); { ADD_STORAGE(struct cairo_mod_path_iterator); ADD_FUNCTION("`!", f_path_iterator_not_operator, tFunc(tVoid,tInt), ID_PUBLIC); ADD_FUNCTION("`+=", f_path_iterator_add_self, tFunc(tInt,tObj), ID_PUBLIC); ADD_FUNCTION("index", f_path_iterator_index, tFunc(tNone,tObj), ID_PUBLIC); ADD_FUNCTION("value", f_path_iterator_value, tFunc(tNone,tObj), ID_PUBLIC); ADD_FUNCTION("first", f_path_iterator_first, tFunc(tNone,tInt), ID_PUBLIC); ADD_FUNCTION("next", f_path_iterator_next, tFunc(tNone,tObj), ID_PUBLIC); set_init_callback(init_cairo_mod_path_iterator); set_exit_callback(exit_cairo_mod_path_iterator); } add_program_constant("PathIterator", cairo_mod_path_iterator_program = end_program(), 0); }
/** * Add native methods to the SSL object. * [0] - SSL Object */ duk_ret_t ModuleSSL(duk_context *ctx) { ADD_FUNCTION("create_dukf_ssl_context", js_ssl_create_dukf_ssl_context, 2); ADD_FUNCTION("debugThreshold", js_ssl_debug_set_threshold, 1); ADD_FUNCTION("free_dukf_ssl_context", js_ssl_free_dukf_ssl_context, 1); ADD_FUNCTION("read", js_ssl_read, 2); ADD_FUNCTION("write", js_ssl_write, 2); return 0; } // ModuleSSL
void init_image_xbm(void) { ADD_FUNCTION( "_decode", image_xbm__decode, tFunc(tStr tOr(tVoid,tMapping),tMap(tStr,tObj)), 0); ADD_FUNCTION( "decode", image_xbm_decode, tFunc(tStr,tObj), 0); ADD_FUNCTION( "encode", image_xbm_encode, tFunc(tObj tOr(tVoid,tMapping),tStr), 0); param_name=make_shared_string("name"); param_fg=make_shared_string("fg"); param_bg=make_shared_string("bg"); param_invert=make_shared_string("invert"); }
void init_context() { set_init_callback(ctx_init); set_exit_callback(ctx_exit); ADD_STORAGE(js_context); ADD_FUNCTION("create", ctx_create, tFunc(tOr(tVoid, tInt) tOr(tVoid, tInt), tVoid), 0); ADD_FUNCTION("evaluate", ctx_evaluate, tFunc(tString tOr(tVoid, tInt), tOr(tMapping, tInt)), 0); ADD_FUNCTION("set_id", ctx_set_id, tFunc(tObj, tVoid), 0); }
int _init_xml_sax(void) { start_new_program(); ADD_STORAGE(sax_storage); set_init_callback(init_sax); set_exit_callback(exit_sax); ADD_FUNCTION("create", f_create, tFunc(tOr(tString, tObj) tObj tOr(tMapping, tVoid) tOr(tMixed, tVoid) tOr(tInt, tVoid), tVoid), 0); ADD_FUNCTION("parse", f_parse_xml, tFunc(tVoid, tInt), 0); ADD_FUNCTION("getLineNumber", f_getLineNumber, tFunc(tVoid, tInt), 0); ADD_FUNCTION("getColumnNumber", f_getColumnNumber, tFunc(tVoid, tInt), 0); xml_program = end_program(); add_program_constant("SAX", xml_program, 0); start_new_program(); ADD_STORAGE(sax_storage); set_init_callback(init_sax); set_exit_callback(exit_sax); ADD_FUNCTION("create", f_create, tFunc(tOr(tString, tObj) tObj tOr(tMapping, tVoid) tOr(tMixed, tVoid) tOr(tInt, tVoid), tVoid), 0); ADD_FUNCTION("parse", f_parse_html, tFunc(tOr(tString,tVoid), tInt), 0); ADD_FUNCTION("getLineNumber", f_getLineNumber, tFunc(tVoid, tInt), 0); ADD_FUNCTION("getColumnNumber", f_getColumnNumber, tFunc(tVoid, tInt), 0); html_program = end_program(); add_program_constant("HTML", html_program, 0); return 1; }
void pike_module_init(void) { #ifdef PEXTS_VERSION pexts_init(); #endif struct svalue sv; /* Starting a new class */ start_new_program(); /* Agrega espacio para los datos internos */ low_add_storage(sizeof(struct mcast_storage) - sizeof(struct udp_storage), ALIGNOF(struct mcast_storage),0); /* Hereda Stdio.UDP */ /* NOTA IMPORTANTE * Aparentemente no se puede heredar un objeto * escrito en Pike desde aquí... luego, heredo * el objeto básico (nativo) */ /* Resuelve el objeto (encuentra el archivo) */ push_text("files.UDP"); SAFE_APPLY_MASTER("resolv",1); if(Pike_sp[-1].type != T_FUNCTION) Pike_error("Error in resolving of Stdio.UDP!\n"); /* Obtiene el programa */ stdio_udp = program_from_function(&Pike_sp[-1]); pop_n_elems(1); /* Hereda */ sv.type = T_PROGRAM; sv.subtype = 0; sv.u.program = stdio_udp; do_inherit( &sv, 0, 0); /* Agrega los métodos */ ADD_FUNCTION("join",mcast_join,tFunc(tStr,tVoid),0); ADD_FUNCTION("leave",mcast_leave,tFunc(tStr,tVoid),0); ADD_FUNCTION("setLoopback",mcast_loopback,tFunc(tInt,tVoid),0); ADD_FUNCTION("setTTL",mcast_setTTL,tFunc(tInt,tVoid),0); ADD_FUNCTION("setInterface",mcast_setif,tFunc(tStr,tVoid),0); /* Llama a "init_mcast" antes de crear los objetos */ set_init_callback(init_mcast); end_class("MultiCastUDP",0); }
void pike_module_init() { ADD_FUNCTION("crypt_md5", f_crypt_md5, tOr(tFunc(tStr,tStr), tFunc(tStr tStr,tStr)), 0); }
void source_pikestream_init( ) { start_new_program(); ADD_STORAGE( struct callback_prog ); ADD_FUNCTION("`()", f_got_data, tFunc(tInt tStr,tVoid),0); callback_program = end_program(); }
/* Init the module */ void pike_module_init(void) { #ifdef PEXTS_VERSION pexts_init(); #endif start_new_program(); ADD_STORAGE( PCRE_Regexp ); ADD_FUNCTION( "create", f_pcre_create, tFunc(tOr(tStr,tVoid) tOr(tStr,tVoid), tVoid), 0); ADD_FUNCTION("match", f_pcre_match, tFunc(tStr tOr(tStr,tVoid), tInt), 0); ADD_FUNCTION("split", f_pcre_split, tFunc(tStr tOr(tStr,tVoid), tArr(tStr)), 0); set_init_callback(init_regexp); set_exit_callback(free_regexp); end_class("Regexp", 0); add_integer_constant("version", 2, 0); }
/* Initialized the sender */ void init_nbio(void) { start_new_program(); ADD_STORAGE( nbio_storage ); set_init_callback(alloc_nb_struct); set_exit_callback(free_nb_struct); ADD_FUNCTION("start", f_nbio_start, tFunc(tVoid, tVoid), 0); ADD_FUNCTION("nbio_status", f_nbio_status, tFunc(tVoid, tArray), 0); ADD_FUNCTION("input", f_input, tFunc(tObj tOr(tInt, tVoid), tVoid), 0); ADD_FUNCTION("write", f_write, tFunc(tStr, tVoid), 0); ADD_FUNCTION("output", f_output, tFunc(tObj, tVoid), 0); ADD_FUNCTION("_output_write_cb", f__output_write_cb, tFunc(tInt, tVoid), 0); ADD_FUNCTION("_input_read_cb", f__input_read_cb, tFunc(tInt tStr, tVoid), 0); ADD_FUNCTION("_input_close_cb", f__input_close_cb, tFunc(tInt, tVoid), 0); ADD_FUNCTION("set_done_callback", f_set_done_callback, tFunc(tOr(tVoid,tFunc(tMix, tMix)) tOr(tVoid,tMix),tVoid),0); ADD_FUNCTION("bytes_sent", f_bytes_sent, tFunc(tNone,tInt), 0); nbio_program = end_program(); add_program_constant("nbio", nbio_program, 0); output_write_cb_off = find_identifier("_output_write_cb", nbio_program); input_read_cb_off = find_identifier("_input_read_cb", nbio_program); input_close_cb_off = find_identifier("_input_close_cb", nbio_program); }
void pike_module_init(void) { #ifdef PEXTS_VERSION pexts_init(); #endif /* Compression program */ start_new_program(); ADD_STORAGE(bz_stream); set_init_callback(init_deflate); set_exit_callback(exit_deflate); ADD_FUNCTION("create", f_deflate_create, tFunc( tOr(tVoid, tInt), tVoid), 0); ADD_FUNCTION("deflate", f_deflate_deflate, tFunc(tString tOr(tInt, tVoid), tString), 0); ADD_FUNCTION("compress_file", f_deflate_file, tFunc(tString tOr(tString, tVoid), tVoid), 0); deflate_program = end_program(); add_program_constant("deflate", deflate_program, 0); /* Decompression program */ start_new_program(); ADD_STORAGE(bz_stream); ADD_FUNCTION("create", f_inflate_create, tFunc(tOr(tInt, tVoid), tVoid), 0); ADD_FUNCTION("inflate", f_inflate_inflate, tFunc(tString, tString), 0); set_init_callback(init_inflate); set_exit_callback(exit_inflate); inflate_program = end_program(); add_program_constant("inflate", inflate_program, 0); }
void mhash_init_mhash_program(void) { start_new_program(); ADD_STORAGE( mhash_storage ); ADD_FUNCTION("create", f_hash_create, tFunc(tOr(tInt,tVoid),tVoid), 0); ADD_FUNCTION("update", f_hash_feed, tFunc(tStr,tObj), 0 ); ADD_FUNCTION("feed", f_hash_feed, tFunc(tStr,tObj), 0 ); ADD_FUNCTION("digest", f_hash_digest, tFunc(tVoid,tStr), 0); ADD_FUNCTION("query_name", f_hash_query_name, tFunc(tVoid,tStr), 0 ); ADD_FUNCTION("reset", f_hash_reset, tFunc(tVoid,tVoid), 0 ); ADD_FUNCTION("set_type", f_hash_set_type, tFunc(tInt,tVoid), 0 ); set_init_callback(init_hash_storage); set_exit_callback(free_hash_storage); end_class("Hash", 0); }
void init_parser_rcs(void) { ADD_FUNCTION("tokenize",f_tokenize,tFunc(tStr,tArray),0); }
IFACE_MON_N2PEAK4_A_NAME = A_NAME_FUNCTION( COND_MON_N2PEAK4_A_NAME ); IFACE_MON_N2PEAK4DT_A_NAME = A_NAME_FUNCTION( COND_MON_N2PEAK4DT_A_NAME ); IFACE_MON_N2PEAK4TM_A_NAME = A_NAME_FUNCTION( COND_MON_N2PEAK4TM_A_NAME ); IFACE_MON_N2PEAK5_A_NAME = A_NAME_FUNCTION( COND_MON_N2PEAK5_A_NAME ); IFACE_MON_N2PEAK5DT_A_NAME = A_NAME_FUNCTION( COND_MON_N2PEAK5DT_A_NAME ); IFACE_MON_N2PEAK5TM_A_NAME = A_NAME_FUNCTION( COND_MON_N2PEAK5TM_A_NAME ); IFACE_MON_NOX_RAW_A_NAME = A_NAME_FUNCTION( 999_0 ); IFACE_MON_O2_RAW_A_NAME = A_NAME_FUNCTION( 999_0 ); IFACE_MON_OP_HRSG_A_NAME = A_NAME_FUNCTION( COND_MON_OP_HRSG_A_NAME ); IFACE_MON_OSPD_COUNT_A_NAME = A_NAME_FUNCTION( COND_MON_OSPD_COUNT_A_NAME ); IFACE_MON_PEAKT3_HR_A_NAME = A_NAME_FUNCTION( COND_MON_PEAKT3_HR_A_NAME ); IFACE_MON_PEAKT48_HR_A_NAME = A_NAME_FUNCTION( COND_MON_PEAKT48_HR_A_NAME ); IFACE_MON_PKPDF_BC_A_NAME = A_NAME_FUNCTION( COND_MON_PKPDF_BC_A_NAME ); IFACE_MON_PKPDF_OTHR_A_NAME = A_NAME_FUNCTION( COND_MON_PKPDF_OTHR_A_NAME ); IFACE_MON_PKT48_BC2A_A_NAME = A_NAME_FUNCTION( COND_MON_PKT48_BC2A_A_NAME ); IFACE_MON_S2IFORACO_A_NAME = A_NAME_FUNCTION( COND_MON_S2IFORACO_A_NAME ); IFACE_MON_SIOTHER_A_NAME = A_NAME_FUNCTION( COND_MON_SIOTHER_A_NAME ); IFACE_MON_SPRINTHRS_A_NAME = A_NAME_FUNCTION( IFACE_MON_SPRINT_TM_ADD ); IFACE_MON_SPRINT_TM_ADD = ADD_FUNCTION( 0 , SPRINT_HSPR_HRS_A_NAME , SPRINT_LSPR_HRS_A_NAME ); IFACE_MON_SPRNTFLOW_A_NAME = A_NAME_FUNCTION( TOTALIZER_FT62231HI_A_NAME ); IFACE_MON_SPRTFLOWLO_A_NAME = A_NAME_FUNCTION( TOTALIZER_FT62231LO_A_NAME ); IFACE_MON_STARTSG_A_NAME = A_NAME_FUNCTION( COND_MON_STARTSG_A_NAME ); IFACE_MON_TFLP10S_A_NAME = A_NAME_FUNCTION( COND_MON_TFLP10S_A_NAME ); IFACE_MON_TFLP15S_A_NAME = A_NAME_FUNCTION( COND_MON_TFLP15S_A_NAME ); IFACE_MON_TPEAK_HRG_A_NAME = A_NAME_FUNCTION( COND_MON_TPEAK_HRG_A_NAME ); IFACE_MON_TRFBBVIB_A_NAME = A_NAME_FUNCTION( NEVADA_XE6877A_CALCULATE ); IFACE_MON_TRFN25VIB_A_NAME = A_NAME_FUNCTION( 999_0 ); IFACE_MON_TRFN2VIB_A_NAME = A_NAME_FUNCTION( 999_0 ); IFACE_MON_TRIPSG_A_NAME = A_NAME_FUNCTION( COND_MON_TRIPSD_A_NAME ); IFACE_MON_UHC_RAW_A_NAME = A_NAME_FUNCTION( SIMMS_UHC_A_NAME );
static bool InitParamMap() { paramMap.clear(); paramMap["next"] = DataElement(READONLY_TYPE); paramMap["pairs"] = DataElement(READONLY_TYPE); // dummy FeatureDef for address lookups const FeatureDef fd; const char* start = ADDRESS(fd); ADD_FUNCTION("model", fd, ModelTable); ADD_FUNCTION("collisionVolume", fd.collisionVolume, ColVolTable); ADD_FUNCTION("modelname", fd, ModelName); ADD_FUNCTION("height", fd, ModelHeight); ADD_FUNCTION("radius", fd, ModelRadius); ADD_FUNCTION("drawTypeString", fd, ModelDrawType); ADD_FUNCTION("customParams", fd.customParams, CustomParamsTable); ADD_INT("id", fd.id); ADD_INT("deathFeatureID", fd.deathFeatureDefID); ADD_STRING("name", fd.name); ADD_STRING("tooltip", fd.description); ADD_FLOAT("metal", fd.metal); ADD_FLOAT("energy", fd.energy); ADD_FLOAT("maxHealth", fd.health); ADD_FLOAT("reclaimTime", fd.reclaimTime); ADD_FLOAT("mass", fd.mass); ADD_INT("xsize", fd.xsize); ADD_INT("zsize", fd.zsize); ADD_INT("drawType", fd.drawType); ADD_BOOL("upright", fd.upright); ADD_BOOL("destructable", fd.destructable); ADD_BOOL("reclaimable", fd.reclaimable); ADD_BOOL("autoreclaim", fd.autoreclaim); ADD_BOOL("blocking", fd.collidable); ADD_BOOL("burnable", fd.burnable); ADD_BOOL("floating", fd.floating); ADD_BOOL("geoThermal", fd.geoThermal); ADD_BOOL("noSelect", fd.selectable); ADD_INT("resurrectable", fd.resurrectable); ADD_INT("smokeTime", fd.smokeTime); ADD_DEPRECATED_LUADEF_KEY("minx"); ADD_DEPRECATED_LUADEF_KEY("miny"); ADD_DEPRECATED_LUADEF_KEY("minz"); ADD_DEPRECATED_LUADEF_KEY("midx"); ADD_DEPRECATED_LUADEF_KEY("midy"); ADD_DEPRECATED_LUADEF_KEY("midz"); ADD_DEPRECATED_LUADEF_KEY("maxx"); ADD_DEPRECATED_LUADEF_KEY("maxy"); ADD_DEPRECATED_LUADEF_KEY("maxz"); ADD_DEPRECATED_LUADEF_KEY("deathFeature"); return true; }
COND_MON_GLBDCMINPK_T_TO_HMS = T_TO_HMS_FUNCTION( "MIN" , 0 , COND_MON_GLBDCSECVB_A_TO_T ); COND_MON_GLBDCMINPK_T_TO_HMS = T_TO_HMS_FUNCTION( "SEC" , 0 , COND_MON_GLBDCSECVB_A_TO_T ); COND_MON_GLBDCMINPK_T_TO_HMS = T_TO_HMS_FUNCTION( "MICROSEC" , 0 , COND_MON_GLBDCSECVB_A_TO_T ); COND_MON_GLBDCSECVB_A_TO_T = A_TO_T_FUNCTION( COND_MON_GLUBDC_2_S_MULTIPLY ); COND_MON_GLBDPMPTMR_A_NAME = A_NAME_FUNCTION( COND_MON_NV_LOG_OUT_139 ); COND_MON_GLUBAMINPK_T_TO_HMS = T_TO_HMS_FUNCTION( "YEAR" , 0 , COND_MON_GLUBASECVB_A_TO_T ); COND_MON_GLUBAMINPK_T_TO_HMS = T_TO_HMS_FUNCTION( "MONTH" , 0 , COND_MON_GLUBASECVB_A_TO_T ); COND_MON_GLUBAMINPK_T_TO_HMS = T_TO_HMS_FUNCTION( "DAY" , 0 , COND_MON_GLUBASECVB_A_TO_T ); COND_MON_GLUBAMINPK_T_TO_HMS = T_TO_HMS_FUNCTION( "HOUR" , 0 , COND_MON_GLUBASECVB_A_TO_T ); COND_MON_GLUBAMINPK_T_TO_HMS = T_TO_HMS_FUNCTION( "MIN" , 0 , COND_MON_GLUBASECVB_A_TO_T ); COND_MON_GLUBAMINPK_T_TO_HMS = T_TO_HMS_FUNCTION( "SEC" , 0 , COND_MON_GLUBASECVB_A_TO_T ); COND_MON_GLUBAMINPK_T_TO_HMS = T_TO_HMS_FUNCTION( "MICROSEC" , 0 , COND_MON_GLUBASECVB_A_TO_T ); COND_MON_GLUBASEC_DIVIDE = DIVIDE_FUNCTION( 0 , COND_MON_GLUBA_Z_T_TO_AN , 3600_0 ); COND_MON_GLUBASECVB_A_TO_T = A_TO_T_FUNCTION( COND_MON_GLUBA_2_S_MULTIPLY ); COND_MON_GLUBA_2_S_MULTIPLY = MULTIPLY_FUNCTION( 0 , COND_MON_GLUBA_SW_A_SW , 3600_0 ); COND_MON_GLUBA_ADD_ADD = ADD_FUNCTION( 0 , COND_MON_GLUBASEC_DIVIDE , COND_MON_GLBAPMPTMR_A_NAME ); COND_MON_GLUBA_ANLG_I_TO_AN = I_TO_AN_FUNCTION( "OUT_1" , 0 , COND_MON_GLUBA_INT_OUT_1 , COND_MON_GLUBA_INT_OUT_2 ); COND_MON_GLUBA_ANLG_I_TO_AN = I_TO_AN_FUNCTION( "OUT_2" , 0 , COND_MON_GLUBA_INT_OUT_1 , COND_MON_GLUBA_INT_OUT_2 ); COND_MON_GLUBA_HR_A_NAME = A_NAME_FUNCTION( COND_MON_GLUBA_ANLG_OUT_1 ); COND_MON_GLUBA_INT_A_TO_INT = A_TO_INT_FUNCTION( "OUT_1" , 0 , COND_MON_GLUBA_SW_A_SW , COND_MON_GLUBA_TNTH_DIVIDE ); COND_MON_GLUBA_INT_A_TO_INT = A_TO_INT_FUNCTION( "OUT_2" , 0 , COND_MON_GLUBA_SW_A_SW , COND_MON_GLUBA_TNTH_DIVIDE ); COND_MON_GLUBA_MIN_A_NAME = A_NAME_FUNCTION( COND_MON_GLUBA_ANLG_OUT_2 ); COND_MON_GLUBA_NV_A_NAME = A_NAME_FUNCTION( COND_MON_GLUBA_SW_A_SW ); COND_MON_GLUBA_SET_I_TO_AN = I_TO_AN_FUNCTION( 0 , *0 (0, 99999999) ); COND_MON_GLUBA_SW_A_SW = A_SW_FUNCTION( COND_MON_MANUAL_OS_ONE_SHOT , COND_MON_GLUBA_Z2_ZMINUS1 , COND_MON_GLUBA_SET_OUT_1 ); COND_MON_GLUBA_TMR_ACCUM = ACCUM_FUNCTION( "ELAP_TIME" , A1_A08_DO_MOT6033_DISPLAY , 0 , COND_MON_NV_RESET_B_NAME , 1_0 , "HR" ); COND_MON_GLUBA_TMR_ACCUM = ACCUM_FUNCTION( "OUT_1" , A1_A08_DO_MOT6033_DISPLAY , 0 , COND_MON_NV_RESET_B_NAME , 1_0 , "HR" ); COND_MON_GLUBA_TNTH_DIVIDE = DIVIDE_FUNCTION( 0 , COND_MON_GLUBAMINPK_MIN , 6_0 ); COND_MON_GLUBA_Z_T_TO_AN = T_TO_AN_FUNCTION( 0 , COND_MON_GLUBA_TMR_ELAP_TIME ); COND_MON_GLUBA_Z2_ZMINUS1 = ZMINUS1_FUNCTION( COND_MON_GLUBA_ADD_ADD ); COND_MON_GLUBBMINPK_T_TO_HMS = T_TO_HMS_FUNCTION( "YEAR" , 0 , COND_MON_GLUBBSECVB_A_TO_T );
void init_stdio_port(void) { ptrdiff_t offset; START_NEW_PROGRAM_ID (STDIO_PORT); offset = ADD_STORAGE(struct port); PIKE_MAP_VARIABLE("_accept_callback", offset + OFFSETOF(port, accept_callback), tMix, PIKE_T_MIXED, 0); PIKE_MAP_VARIABLE("_id", offset + OFFSETOF(port, id), tMix, PIKE_T_MIXED, 0); /* function(int|string,void|mixed,void|string:int) */ ADD_FUNCTION("bind", port_bind, tFunc(tOr(tInt,tStr) tOr(tVoid,tMix) tOr(tVoid,tStr) tOr(tVoid,tInt),tInt), 0); #ifdef HAVE_SYS_UN_H /* function(int|string,void|mixed,void|string:int) */ ADD_FUNCTION("bind_unix", bind_unix, tFunc(tStr tOr(tVoid,tMix),tInt), ID_OPTIONAL); #endif /* HAVE_SYS_UN_H */ ADD_FUNCTION("close",port_close,tFunc(tNone,tVoid),0); /* function(int,void|mixed:int) */ ADD_FUNCTION("listen_fd",port_listen_fd,tFunc(tInt tOr(tVoid,tMix),tInt),0); /* function(mixed:mixed) */ ADD_FUNCTION("set_id",port_set_id,tFunc(tMix,tMix),0); /* function(:mixed) */ ADD_FUNCTION("query_id",port_query_id,tFunc(tNone,tMix),0); /* function(:string) */ ADD_FUNCTION("query_address",socket_query_address,tFunc(tNone,tStr),0); /* function(:int) */ ADD_FUNCTION("errno",port_errno,tFunc(tNone,tInt),0); /* function(:object) */ port_fd_factory_fun_num = ADD_FUNCTION("fd_factory", port_fd_factory, tFunc(tNone,tObjIs_STDIO_FD), ID_PROTECTED); ADD_FUNCTION("accept",port_accept,tFunc(tNone,tObjIs_STDIO_FD),0); /* function(void|string|int,void|mixed,void|string:void) */ ADD_FUNCTION("create", port_create, tFunc(tOr3(tVoid,tStr,tInt) tOr(tVoid,tMix) tOr(tVoid,tStr), tVoid), 0); ADD_FUNCTION ("set_backend", port_set_backend, tFunc(tObj,tVoid), 0); ADD_FUNCTION ("query_backend", port_query_backend, tFunc(tVoid,tObj), 0); ADD_FUNCTION ("query_fd", port_query_fd, tFunc(tVoid,tInt), 0); #ifdef SO_REUSEPORT ADD_INT_CONSTANT( "SO_REUSEPORT_SUPPORT", SO_REUSEPORT, ID_OPTIONAL ); #endif #ifdef TCP_FASTOPEN ADD_INT_CONSTANT( "TCP_FASTOPEN_SUPPORT", TCP_FASTOPEN, ID_OPTIONAL ); #endif set_init_callback(init_port_struct); set_exit_callback(exit_port_struct); port_program = end_program(); add_program_constant( "_port", port_program, 0 ); }
void _ol_ldap_program_init(void) { start_new_program(); ADD_STORAGE(OLSTORAGE); set_init_callback(init_ldap); set_exit_callback(exit_ldap); ADD_FUNCTION("create", f_create, tFunc(tString, tVoid), 0); ADD_FUNCTION("bind", f_ldap_bind, tFunc(tOr(tString, tVoid) tOr(tString, tVoid) tOr(tInt, tVoid), tInt), 0); ADD_FUNCTION("unbind", f_ldap_unbind, tFunc(tVoid, tInt), 0); ADD_FUNCTION("enable_cache", f_ldap_enable_cache, tFunc(tOr(tInt, tVoid) tOr(tInt, tVoid), tInt), 0); ADD_FUNCTION("disable_cache", f_ldap_disable_cache, tFunc(tVoid, tVoid), 0); ADD_FUNCTION("destroy_cache", f_ldap_destroy_cache, tFunc(tVoid, tVoid), 0); ADD_FUNCTION("flush_cache", f_ldap_flush_cache, tFunc(tVoid, tVoid), 0); ADD_FUNCTION("uncache_entry", f_ldap_uncache_entry, tFunc(tString, tVoid), 0); ADD_FUNCTION("set_cache_options", f_ldap_set_cache_options, tFunc(tInt, tVoid), 0); ADD_FUNCTION("err2string", f_ldap_err2string, tFunc(tInt, tVoid), 0); ADD_FUNCTION("set_base_dn", f_set_base_dn, tFunc(tString, tString), 0); ADD_FUNCTION("set_basedn", f_set_base_dn, tFunc(tString, tString), 0); ADD_FUNCTION("set_scope", f_set_scope, tFunc(tInt, tVoid), 0); ADD_FUNCTION("dn2ufn", f_ldap_dn2ufn, tFunc(tString, tString), 0); ADD_FUNCTION("explode_dn", f_ldap_explode_dn, tFunc(tString tOr(tInt, tVoid), tArr(tString)), 0); ADD_FUNCTION("search", f_ldap_search, tFunc(tOr(tMapping, tString tOr(tArray, tVoid) tOr(tInt, tVoid) tOr(tInt, tVoid)), tOr(tObj, tInt)), 0); ADD_FUNCTION("modify", f_ldap_modify, tFunc(tString tArr(tMap(tString, tMixed)), tVoid), 0); ADD_FUNCTION("add", f_ldap_add, tFunc(tString tArr(tMap(tString, tMixed)), tVoid), 0); ADD_FUNCTION("delete", f_ldap_delete, tFunc(tString, tVoid), 0); _ol_result_program_init(); ldap_program = end_program(); add_program_constant("Client", ldap_program, 0); add_program_constant("client", ldap_program, 0); }
static bool InitParamMap() { paramMap["next"] = DataElement(READONLY_TYPE); paramMap["pairs"] = DataElement(READONLY_TYPE); // dummy WeaponDef for offset generation const WeaponDef wd; const char* start = ADDRESS(wd); ADD_FUNCTION("damages", wd.damages, DamagesArray); ADD_FUNCTION("visuals", wd.visuals, VisualsTable); ADD_FUNCTION("hitSound", wd.soundhit, GuiSoundSetTable); ADD_FUNCTION("fireSound", wd.firesound, GuiSoundSetTable); ADD_FUNCTION("customParams", wd.customParams, CustomParamsTable); ADD_FUNCTION("noEnemyCollide", wd.collisionFlags, NoEnemyCollide); ADD_FUNCTION("noFriendlyCollide", wd.collisionFlags, NoFriendlyCollide); ADD_FUNCTION("noFeatureCollide", wd.collisionFlags, NoFeatureCollide); ADD_FUNCTION("noNeutralCollide", wd.collisionFlags, NoNeutralCollide); ADD_FUNCTION("noGroundCollide", wd.collisionFlags, NoGroundCollide); ADD_DEPRECATED_LUADEF_KEY("areaOfEffect"); ADD_DEPRECATED_LUADEF_KEY("maxVelocity"); ADD_DEPRECATED_LUADEF_KEY("onlyTargetCategories"); ADD_INT("id", wd.id); ADD_INT("tdfId", wd.tdfId); ADD_STRING("name", wd.name); ADD_STRING("description", wd.description); ADD_STRING("cegTag", wd.cegTag); ADD_STRING("type", wd.type); ADD_FLOAT("range", wd.range); ADD_FLOAT("heightMod", wd.heightmod); ADD_FLOAT("accuracy", wd.accuracy); ADD_FLOAT("sprayAngle", wd.sprayAngle); ADD_FLOAT("movingAccuracy", wd.movingAccuracy); ADD_FLOAT("targetMoveError", wd.targetMoveError); ADD_FLOAT("leadLimit", wd.leadLimit); ADD_FLOAT("leadBonus", wd.leadBonus); ADD_FLOAT("predictBoost", wd.predictBoost); ADD_INT("highTrajectory", wd.highTrajectory); ADD_BOOL("noSelfDamage", wd.noSelfDamage); ADD_BOOL("impactOnly", wd.impactOnly); ADD_FLOAT("craterAreaOfEffect", wd.craterAreaOfEffect); ADD_FLOAT("damageAreaOfEffect", wd.damageAreaOfEffect); ADD_FLOAT("edgeEffectiveness", wd.edgeEffectiveness); ADD_FLOAT("fireStarter", wd.fireStarter); ADD_FLOAT("size", wd.size); ADD_FLOAT("sizeGrowth", wd.sizeGrowth); ADD_FLOAT("collisionSize", wd.collisionSize); ADD_INT("salvoSize", wd.salvosize); ADD_INT("projectiles", wd.projectilespershot); ADD_FLOAT("salvoDelay", wd.salvodelay); ADD_FLOAT("reload", wd.reload); ADD_FLOAT("beamtime", wd.beamtime); ADD_BOOL("beamburst", wd.beamburst); ADD_BOOL("waterbounce", wd.waterBounce); ADD_BOOL("groundbounce", wd.groundBounce); ADD_FLOAT("groundslip", wd.bounceSlip); ADD_FLOAT("bouncerebound", wd.bounceRebound); ADD_INT("numbounce", wd.numBounce); ADD_FLOAT("maxAngle", wd.maxAngle); ADD_FLOAT("restTime", wd.restTime); ADD_FLOAT("uptime", wd.uptime); ADD_FLOAT("metalCost", wd.metalcost); ADD_FLOAT("energyCost", wd.energycost); ADD_BOOL("turret", wd.turret); ADD_BOOL("onlyForward", wd.onlyForward); ADD_BOOL("waterWeapon", wd.waterweapon); ADD_BOOL("tracks", wd.tracks); ADD_BOOL("paralyzer", wd.paralyzer); ADD_BOOL("noAutoTarget", wd.noAutoTarget); ADD_BOOL("manualFire", wd.manualfire); ADD_INT("targetable", wd.targetable); ADD_BOOL("stockpile", wd.stockpile); ADD_INT("interceptor", wd.interceptor); ADD_FLOAT("coverageRange", wd.coverageRange); ADD_FLOAT("stockpileTime", wd.stockpileTime); ADD_FLOAT("intensity", wd.intensity); ADD_FLOAT("duration", wd.duration); ADD_INT("beamTTL", wd.beamLaserTTL); ADD_BOOL("soundTrigger", wd.soundTrigger); ADD_BOOL("selfExplode", wd.selfExplode); ADD_BOOL("gravityAffected", wd.gravityAffected); ADD_FLOAT("myGravity", wd.myGravity); ADD_BOOL("noExplode", wd.noExplode); ADD_FLOAT("startvelocity", wd.startvelocity); ADD_FLOAT("weaponAcceleration", wd.weaponacceleration); ADD_FLOAT("turnRate", wd.turnrate); ADD_FLOAT("projectilespeed", wd.projectilespeed); ADD_FLOAT("explosionSpeed", wd.explosionSpeed); ADD_FLOAT("wobble", wd.wobble); ADD_FLOAT("dance", wd.dance); ADD_FLOAT("trajectoryHeight", wd.trajectoryHeight); ADD_BOOL("largeBeamLaser", wd.largeBeamLaser); ADD_BOOL("laserHardStop", wd.laserHardStop); ADD_BOOL("isShield", wd.isShield); ADD_BOOL("shieldRepulser", wd.shieldRepulser); ADD_BOOL("smartShield", wd.smartShield); ADD_BOOL("exteriorShield", wd.exteriorShield); ADD_BOOL("visibleShield", wd.visibleShield); ADD_BOOL("visibleShieldRepulse", wd.visibleShieldRepulse); ADD_INT( "visibleShieldHitFrames", wd.visibleShieldHitFrames); ADD_FLOAT("shieldEnergyUse", wd.shieldEnergyUse); ADD_FLOAT("shieldRadius", wd.shieldRadius); ADD_FLOAT("shieldForce", wd.shieldForce); ADD_FLOAT("shieldMaxSpeed", wd.shieldMaxSpeed); ADD_FLOAT("shieldPower", wd.shieldPower); ADD_FLOAT("shieldPowerRegen", wd.shieldPowerRegen); ADD_FLOAT("shieldPowerRegenEnergy", wd.shieldPowerRegenEnergy); ADD_INT( "shieldRechargeDelay", wd.shieldRechargeDelay); ADD_FLOAT("shieldGoodColorR", wd.shieldGoodColor.x); ADD_FLOAT("shieldGoodColorG", wd.shieldGoodColor.y); ADD_FLOAT("shieldGoodColorB", wd.shieldGoodColor.z); ADD_FLOAT("shieldBadColorR", wd.shieldBadColor.x); ADD_FLOAT("shieldBadColorG", wd.shieldBadColor.y); ADD_FLOAT("shieldBadColorB", wd.shieldBadColor.z); ADD_FLOAT("shieldAlpha", wd.shieldAlpha); ADD_INT("shieldInterceptType", wd.shieldInterceptType); ADD_INT("interceptedByShieldType", wd.interceptedByShieldType); ADD_BOOL("avoidFriendly", wd.avoidFriendly); ADD_BOOL("avoidFeature", wd.avoidFeature); ADD_BOOL("avoidNeutral", wd.avoidNeutral); ADD_FLOAT("targetBorder", wd.targetBorder); ADD_FLOAT("cylinderTargetting", wd.cylinderTargetting); ADD_FLOAT("minIntensity", wd.minIntensity); ADD_FLOAT("heightBoostFactor", wd.heightBoostFactor); ADD_FLOAT("proximityPriority", wd.proximityPriority); ADD_BOOL("sweepFire", wd.sweepFire); ADD_BOOL("canAttackGround", wd.canAttackGround); return true; }
COND_MON_T3PEAKTM_ACCUM = ACCUM_FUNCTION( "OUT_1" , COND_MON_T3PEAK_AND , 0 , COND_MON_NV_RESET_B_NAME , 1_0 , "HR" ); COND_MON_T3PEAKTM_ACCUM = ACCUM_FUNCTION( "ELAP_TIME" , COND_MON_T3PEAK_AND , 0 , COND_MON_NV_RESET_B_NAME , 1_0 , "HR" ); COND_MON_T48BASE_AND = AND_FUNCTION( COND_MON_T48GT1575_A_COMPARE , COND_MON_T48LT1584_A_COMPARE , CORE_DIGITAL_FUELON ); COND_MON_T48BASETM_ACCUM = ACCUM_FUNCTION( "ELAP_TIME" , COND_MON_T48BASE_AND , 0 , COND_MON_NV_RESET_B_NAME , 1_0 , "HR" ); COND_MON_T48BASETM_ACCUM = ACCUM_FUNCTION( "OUT_1" , COND_MON_T48BASE_AND , 0 , COND_MON_NV_RESET_B_NAME , 1_0 , "HR" ); COND_MON_T48GT1575_A_COMPARE = A_COMPARE_FUNCTION( "A_COMPARE" , CORE_ANALOG_T48SEL , 1575_0 , 0 ); COND_MON_T48GT1575_A_COMPARE = A_COMPARE_FUNCTION( "A_EQUAL" , CORE_ANALOG_T48SEL , 1575_0 , 0 ); COND_MON_T48GT1585_A_COMPARE = A_COMPARE_FUNCTION( "A_COMPARE" , CORE_ANALOG_T48SEL , 1585_0 , 0 ); COND_MON_T48GT1585_A_COMPARE = A_COMPARE_FUNCTION( "A_EQUAL" , CORE_ANALOG_T48SEL , 1585_0 , 0 ); COND_MON_T48LT1584_A_COMPARE = A_COMPARE_FUNCTION( "A_COMPARE" , 1584_9 , CORE_ANALOG_T48SEL , 0 ); COND_MON_T48LT1584_A_COMPARE = A_COMPARE_FUNCTION( "A_EQUAL" , 1584_9 , CORE_ANALOG_T48SEL , 0 ); COND_MON_T48PEAK_AND = AND_FUNCTION( COND_MON_T48GT1585_A_COMPARE , CORE_DIGITAL_FUELON , IFACE_CORE_Z_SWPEAK_B_NAME ); COND_MON_T48PEAKTM_ACCUM = ACCUM_FUNCTION( "ELAP_TIME" , COND_MON_T48PEAK_AND , 0 , COND_MON_NV_RESET_B_NAME , 1_0 , "HR" ); COND_MON_T48PEAKTM_ACCUM = ACCUM_FUNCTION( "OUT_1" , COND_MON_T48PEAK_AND , 0 , COND_MON_NV_RESET_B_NAME , 1_0 , "HR" ); COND_MON_TM1HRS_DIVIDE = DIVIDE_FUNCTION( 0 , COND_MON_TM1SEC_T_TO_AN , 3600_0 ); COND_MON_TM1RSETADD_ADD = ADD_FUNCTION( 0 , COND_MON_TM1HRS_DIVIDE , COND_MON_FB_HRS_1_A_NAME ); COND_MON_TM1SEC_T_TO_AN = T_TO_AN_FUNCTION( 0 , COND_MON_T48BASETM_ELAP_TIME ); COND_MON_TM2HRS_DIVIDE = DIVIDE_FUNCTION( 0 , COND_MON_TM2TA_T_TO_AN , 3600_0 ); COND_MON_TM2RSETADD_ADD = ADD_FUNCTION( 0 , COND_MON_TM2HRS_DIVIDE , COND_MON_FB_HRS_2_A_NAME ); COND_MON_TM2TA_T_TO_AN = T_TO_AN_FUNCTION( 0 , COND_MON_T48PEAKTM_ELAP_TIME ); COND_MON_TM3HRS_DIVIDE = DIVIDE_FUNCTION( 0 , COND_MON_TM3TA_T_TO_AN , 3600_0 ); COND_MON_TM3RSETADD_ADD = ADD_FUNCTION( 0 , COND_MON_TM3HRS_DIVIDE , COND_MON_FB_HRS_3_A_NAME ); COND_MON_TM3TA_T_TO_AN = T_TO_AN_FUNCTION( 0 , COND_MON_T3BASETM_ELAP_TIME ); COND_MON_TM4HRS_DIVIDE = DIVIDE_FUNCTION( 0 , COND_MON_TM4TA_T_TO_AN , 3600_0 ); COND_MON_TM4RSETADD_ADD = ADD_FUNCTION( 0 , COND_MON_TM4HRS_DIVIDE , COND_MON_FB_HRS_4_A_NAME ); COND_MON_TM4TA_T_TO_AN = T_TO_AN_FUNCTION( 0 , COND_MON_T3PEAKTM_ELAP_TIME ); COND_MON_WAIT_TMR01_ZMINUS1 = ZMINUS1_FUNCTION( COND_MON_TM1RSETADD_ADD ); COND_MON_WAIT_TMR02_ZMINUS1 = ZMINUS1_FUNCTION( COND_MON_TM2RSETADD_ADD ); COND_MON_WAIT_TMR03_ZMINUS1 = ZMINUS1_FUNCTION( COND_MON_TM3RSETADD_ADD ); COND_MON_WAIT_TMR04_ZMINUS1 = ZMINUS1_FUNCTION( COND_MON_TM4RSETADD_ADD );
static bool InitParamMap() { paramMap["next"] = DataElement(READONLY_TYPE); paramMap["pairs"] = DataElement(READONLY_TYPE); // dummy UnitDef for address lookups const UnitDef& ud = *unitDefHandler->unitDefs[0]; const char* start = ADDRESS(ud); /* ADD_FLOAT("maxRange", maxRange); // CUSTOM ADD_BOOL("hasShield", hasShield); // CUSTOM ADD_BOOL("canParalyze", canParalyze); // CUSTOM ADD_BOOL("canStockpile", canStockpile); // CUSTOM ADD_BOOL("canAttackWater", canAttackWater); // CUSTOM */ // ADD_INT("buildOptionsCount", ud.buildOptions.size(")); // CUSTOM ADD_FUNCTION("builder", ud, ReturnFalse); // DEPRECATED ADD_FUNCTION("floater", ud, ReturnFalse); // DEPRECATED ADD_FUNCTION("canDGun", ud, ReturnFalse); // DEPRECATED ADD_FUNCTION("canCrash", ud, ReturnFalse); // DEPRECATED ADD_FUNCTION("isCommander", ud, ReturnFalse); // DEPRECATED ADD_FUNCTION("moveData", ud.pathType, ReturnNil); // DEPRECATED ADD_FUNCTION("type", ud, ReturnEmptyString); // DEPRECATED ADD_FUNCTION("maxSlope", ud, ReturnMinusOne); // DEPRECATED ADD_FUNCTION("totalEnergyOut", ud, TotalEnergyOut); ADD_FUNCTION("modCategories", ud.categoryString, CategorySetFromString); ADD_FUNCTION("springCategories", ud.category, CategorySetFromBits); ADD_FUNCTION("noChaseCategories", ud.noChaseCategory, CategorySetFromBits); ADD_FUNCTION("customParams", ud.customParams, CustomParamsTable); ADD_FUNCTION("buildOptions", ud.buildOptions, BuildOptions); ADD_FUNCTION("decoyDef", ud.decoyDef, UnitDefToID); ADD_FUNCTION("weapons", ud.weapons, WeaponsTable); ADD_FUNCTION("sounds", ud.sounds, SoundsTable); ADD_FUNCTION("model", ud, ModelTable); ADD_FUNCTION("moveDef", ud.pathType, MoveDefTable); ADD_FUNCTION("shieldWeaponDef", ud.shieldWeaponDef, WeaponDefToID); ADD_FUNCTION("stockpileWeaponDef", ud.stockpileWeaponDef, WeaponDefToID); ADD_FUNCTION("iconType", ud.iconType, SafeIconType); ADD_FUNCTION("isTransport", ud, IsTransportUnit); ADD_FUNCTION("isImmobile", ud, IsImmobileUnit); ADD_FUNCTION("isBuilding", ud, IsBuildingUnit); ADD_FUNCTION("isBuilder", ud, IsBuilderUnit); ADD_FUNCTION("isMobileBuilder", ud, IsMobileBuilderUnit); ADD_FUNCTION("isStaticBuilder", ud, IsStaticBuilderUnit); ADD_FUNCTION("isFactory", ud, IsFactoryUnit); ADD_FUNCTION("isExtractor", ud, IsExtractorUnit); ADD_FUNCTION("isGroundUnit", ud, IsGroundUnit); ADD_FUNCTION("isAirUnit", ud, IsAirUnit); ADD_FUNCTION("isStrafingAirUnit", ud, IsStrafingAirUnit); ADD_FUNCTION("isHoveringAirUnit", ud, IsHoveringAirUnit); ADD_FUNCTION("isFighterAirUnit", ud, IsFighterAirUnit); ADD_FUNCTION("isBomberAirUnit", ud, IsBomberAirUnit); ADD_FUNCTION("height", ud, ModelHeight); ADD_FUNCTION("radius", ud, ModelRadius); ADD_FUNCTION("minx", ud, ModelMinx); ADD_FUNCTION("midx", ud, ModelMidx); ADD_FUNCTION("maxx", ud, ModelMaxx); ADD_FUNCTION("miny", ud, ModelMiny); ADD_FUNCTION("midy", ud, ModelMidy); ADD_FUNCTION("maxy", ud, ModelMaxy); ADD_FUNCTION("minz", ud, ModelMinz); ADD_FUNCTION("midz", ud, ModelMidz); ADD_FUNCTION("maxz", ud, ModelMaxz); ADD_INT("id", ud.id); ADD_INT("cobID", ud.cobID); ADD_STRING("name", ud.name); ADD_STRING("humanName", ud.humanName); ADD_STRING("tooltip", ud.tooltip); ADD_STRING("wreckName", ud.wreckName); ADD_FUNCTION("deathExplosion", ud.deathExpWeaponDef, WeaponDefToName); ADD_FUNCTION("selfDExplosion", ud.selfdExpWeaponDef, WeaponDefToName); ADD_STRING("buildpicname", ud.buildPicName); ADD_INT("techLevel", ud.techLevel); ADD_INT("maxThisUnit", ud.maxThisUnit); ADD_FLOAT("metalUpkeep", ud.metalUpkeep); ADD_FLOAT("energyUpkeep", ud.energyUpkeep); ADD_FLOAT("metalMake", ud.metalMake); ADD_FLOAT("makesMetal", ud.makesMetal); ADD_FLOAT("energyMake", ud.energyMake); ADD_FLOAT("metalCost", ud.metal); ADD_FLOAT("energyCost", ud.energy); ADD_FLOAT("buildTime", ud.buildTime); ADD_FLOAT("extractsMetal", ud.extractsMetal); ADD_FLOAT("extractRange", ud.extractRange); ADD_FLOAT("windGenerator", ud.windGenerator); ADD_FLOAT("tidalGenerator", ud.tidalGenerator); ADD_FLOAT("metalStorage", ud.metalStorage); ADD_FLOAT("energyStorage", ud.energyStorage); ADD_DEPRECATED_LUADEF_KEY("extractSquare"); ADD_FLOAT("power", ud.power); ADD_FLOAT("health", ud.health); ADD_FLOAT("autoHeal", ud.autoHeal); ADD_FLOAT("idleAutoHeal", ud.idleAutoHeal); ADD_INT("idleTime", ud.idleTime); ADD_BOOL("canSelfD", ud.canSelfD); ADD_INT("selfDCountdown", ud.selfDCountdown); ADD_FLOAT("speed", ud.speed); ADD_FLOAT("turnRate", ud.turnRate); ADD_BOOL("turnInPlace", ud.turnInPlace); ADD_FLOAT("turnInPlaceSpeedLimit", ud.turnInPlaceSpeedLimit); ADD_BOOL("upright", ud.upright); ADD_BOOL("collide", ud.collide); ADD_FLOAT("losHeight", ud.losHeight); ADD_FLOAT("losRadius", ud.losRadius); ADD_FLOAT("airLosRadius", ud.airLosRadius); ADD_INT("radarRadius", ud.radarRadius); ADD_INT("sonarRadius", ud.sonarRadius); ADD_INT("jammerRadius", ud.jammerRadius); ADD_INT("sonarJamRadius", ud.sonarJamRadius); ADD_INT("seismicRadius", ud.seismicRadius); ADD_FLOAT("seismicSignature", ud.seismicSignature); ADD_BOOL("stealth", ud.stealth); ADD_BOOL("sonarStealth", ud.sonarStealth); ADD_FLOAT("mass", ud.mass); ADD_FLOAT("maxHeightDif", ud.maxHeightDif); ADD_FLOAT("minWaterDepth", ud.minWaterDepth); ADD_FLOAT("maxWaterDepth", ud.maxWaterDepth); ADD_FLOAT("waterline", ud.waterline); ADD_INT("flankingBonusMode", ud.flankingBonusMode); ADD_FLOAT("flankingBonusMax", ud.flankingBonusMax); ADD_FLOAT("flankingBonusMin", ud.flankingBonusMin); ADD_FLOAT("flankingBonusDirX", ud.flankingBonusDir.x); ADD_FLOAT("flankingBonusDirY", ud.flankingBonusDir.y); ADD_FLOAT("flankingBonusDirZ", ud.flankingBonusDir.z); ADD_FLOAT("flankingBonusMobilityAdd", ud.flankingBonusMobilityAdd); ADD_INT("armorType", ud.armorType); ADD_FLOAT("armoredMultiple", ud.armoredMultiple); ADD_FLOAT("minCollisionSpeed", ud.minCollisionSpeed); ADD_FLOAT("slideTolerance", ud.slideTolerance); ADD_FLOAT("maxWeaponRange", ud.maxWeaponRange); ADD_FLOAT("maxCoverage", ud.maxCoverage); ADD_BOOL( "buildRange3D", ud.buildRange3D); ADD_FLOAT("buildDistance", ud.buildDistance); ADD_FLOAT("buildSpeed", ud.buildSpeed); ADD_FLOAT("repairSpeed", ud.repairSpeed); ADD_FLOAT("maxRepairSpeed", ud.repairSpeed); ADD_FLOAT("reclaimSpeed", ud.reclaimSpeed); ADD_FLOAT("resurrectSpeed", ud.resurrectSpeed); ADD_FLOAT("captureSpeed", ud.captureSpeed); ADD_FLOAT("terraformSpeed", ud.terraformSpeed); ADD_BOOL("canSubmerge", ud.canSubmerge); ADD_BOOL("floatOnWater", ud.floatOnWater); ADD_BOOL("canFly", ud.canfly); ADD_BOOL("canMove", ud.canmove); ADD_BOOL("onOffable", ud.onoffable); ADD_BOOL("activateWhenBuilt", ud.activateWhenBuilt); ADD_DEPRECATED_LUADEF_KEY("canHover"); ADD_BOOL("reclaimable", ud.reclaimable); ADD_BOOL("capturable", ud.capturable); ADD_BOOL("repairable", ud.repairable); ADD_BOOL("canManualFire", ud.canManualFire); ADD_BOOL("canCloak", ud.canCloak); ADD_BOOL("canRestore", ud.canRestore); ADD_BOOL("canRepair", ud.canRepair); ADD_BOOL("canSelfRepair", ud.canSelfRepair); ADD_BOOL("canReclaim", ud.canReclaim); ADD_BOOL("canAttack", ud.canAttack); ADD_BOOL("canPatrol", ud.canPatrol); ADD_BOOL("canFight", ud.canFight); ADD_BOOL("canGuard", ud.canGuard); ADD_BOOL("canAssist", ud.canAssist); ADD_BOOL("canBeAssisted", ud.canBeAssisted); ADD_BOOL("canRepeat", ud.canRepeat); ADD_BOOL("canCapture", ud.canCapture); ADD_BOOL("canResurrect", ud.canResurrect); ADD_BOOL("canLoopbackAttack", ud.canLoopbackAttack); ADD_BOOL("canFireControl", ud.canFireControl); ADD_INT( "fireState", ud.fireState); ADD_INT( "moveState", ud.moveState); ADD_BOOL("fullHealthFactory", ud.fullHealthFactory); ADD_BOOL("factoryHeadingTakeoff", ud.factoryHeadingTakeoff); //aircraft stuff ADD_DEPRECATED_LUADEF_KEY("drag"); ADD_FLOAT("wingDrag", ud.wingDrag); ADD_FLOAT("wingAngle", ud.wingAngle); ADD_FLOAT("crashDrag", ud.crashDrag); ADD_FLOAT("frontToSpeed", ud.frontToSpeed); ADD_FLOAT("speedToFront", ud.speedToFront); ADD_FLOAT("myGravity", ud.myGravity); ADD_FLOAT("verticalSpeed",ud.verticalSpeed); ADD_FLOAT("maxBank", ud.maxBank); ADD_FLOAT("maxPitch", ud.maxPitch); ADD_FLOAT("turnRadius", ud.turnRadius); ADD_FLOAT("wantedHeight", ud.wantedHeight); ADD_BOOL("hoverAttack", ud.hoverAttack); ADD_BOOL("airStrafe", ud.airStrafe); ADD_BOOL("bankingAllowed",ud.bankingAllowed); ADD_BOOL("useSmoothMesh", ud.useSmoothMesh); // < 0 means it can land, // >= 0 indicates how much the unit will move during hovering on the spot ADD_FLOAT("dlHoverFactor", ud.dlHoverFactor); // bool DontLand (") { return dlHoverFactor >= 0.0f; } ADD_FLOAT("maxAcc", ud.maxAcc); ADD_FLOAT("maxDec", ud.maxDec); ADD_FLOAT("maxAileron", ud.maxAileron); ADD_FLOAT("maxElevator", ud.maxElevator); ADD_FLOAT("maxRudder", ud.maxRudder); ADD_FLOAT("maxFuel", ud.maxFuel); ADD_FLOAT("refuelTime", ud.refuelTime); ADD_FLOAT("minAirBasePower", ud.minAirBasePower); // unsigned char* yardmapLevels[6]; // unsigned char* yardmaps[4]; //Iterations of the Ymap for building rotation ADD_INT("xsize", ud.xsize); ADD_INT("zsize", ud.zsize); // transport stuff ADD_INT( "transportCapacity", ud.transportCapacity); ADD_INT( "transportSize", ud.transportSize); ADD_FLOAT("transportMass", ud.transportMass); ADD_FLOAT("loadingRadius", ud.loadingRadius); ADD_BOOL( "isAirBase", ud.isAirBase); ADD_BOOL( "isFirePlatform", ud.isFirePlatform); ADD_BOOL( "holdSteady", ud.holdSteady); ADD_BOOL( "releaseHeld", ud.releaseHeld); ADD_BOOL( "cantBeTransported", ud.cantBeTransported); ADD_BOOL( "transportByEnemy", ud.transportByEnemy); ADD_INT( "transportUnloadMethod", ud.transportUnloadMethod); ADD_FLOAT("fallSpeed", ud.fallSpeed); ADD_FLOAT("unitFallSpeed", ud.unitFallSpeed); ADD_BOOL( "startCloaked", ud.startCloaked); ADD_FLOAT("cloakCost", ud.cloakCost); ADD_FLOAT("cloakCostMoving", ud.cloakCostMoving); ADD_FLOAT("decloakDistance", ud.decloakDistance); ADD_BOOL( "decloakSpherical", ud.decloakSpherical); ADD_BOOL( "decloakOnFire", ud.decloakOnFire); ADD_INT( "cloakTimeout", ud.cloakTimeout); ADD_BOOL( "canKamikaze", ud.canKamikaze); ADD_FLOAT("kamikazeDist", ud.kamikazeDist); ADD_BOOL( "kamikazeUseLOS", ud.kamikazeUseLOS); ADD_BOOL("targfac", ud.targfac); ADD_BOOL("needGeo", ud.needGeo); ADD_BOOL("isFeature", ud.isFeature); ADD_BOOL("hideDamage", ud.hideDamage); ADD_BOOL("showPlayerName", ud.showPlayerName); ADD_INT("highTrajectoryType", ud.highTrajectoryType); ADD_BOOL( "leaveTracks", ud.decalDef.leaveTrackDecals); ADD_INT( "trackType", ud.decalDef.trackDecalType); ADD_FLOAT("trackWidth", ud.decalDef.trackDecalWidth); ADD_FLOAT("trackOffset", ud.decalDef.trackDecalOffset); ADD_FLOAT("trackStrength", ud.decalDef.trackDecalStrength); ADD_FLOAT("trackStretch", ud.decalDef.trackDecalStretch); ADD_BOOL( "canDropFlare", ud.canDropFlare); ADD_FLOAT("flareReloadTime", ud.flareReloadTime); ADD_FLOAT("flareEfficiency", ud.flareEfficiency); ADD_FLOAT("flareDelay", ud.flareDelay); ADD_FLOAT("flareDropVectorX", ud.flareDropVector.x); ADD_FLOAT("flareDropVectorY", ud.flareDropVector.y); ADD_FLOAT("flareDropVectorZ", ud.flareDropVector.z); ADD_INT( "flareTime", ud.flareTime); ADD_INT( "flareSalvoSize", ud.flareSalvoSize); ADD_INT( "flareSalvoDelay", ud.flareSalvoDelay); ADD_BOOL("levelGround", ud.levelGround); ADD_BOOL("strafeToAttack", ud.strafeToAttack); ADD_BOOL( "useBuildingGroundDecal", ud.decalDef.useGroundDecal); ADD_INT( "buildingDecalType", ud.decalDef.groundDecalType); ADD_INT( "buildingDecalSizeX", ud.decalDef.groundDecalSizeX); ADD_INT( "buildingDecalSizeY", ud.decalDef.groundDecalSizeY); ADD_FLOAT("buildingDecalDecaySpeed", ud.decalDef.groundDecalDecaySpeed); ADD_BOOL("showNanoFrame", ud.showNanoFrame); ADD_BOOL("showNanoSpray", ud.showNanoSpray); ADD_FLOAT("nanoColorR", ud.nanoColor.x); ADD_FLOAT("nanoColorG", ud.nanoColor.y); ADD_FLOAT("nanoColorB", ud.nanoColor.z); ADD_STRING("scriptName", ud.scriptName); ADD_STRING("scriptPath", ud.scriptName); //FIXME // backward compability return true; }
void pike_module_init() { struct utsname utsname; char *p; uname(&utsname); if ((p = strchr (utsname.nodename, '.'))) *p = 0; Hostname=strdup(utsname.nodename); Tempdir=(char *) LIBMUTT_TEMPDIR; ADD_INT_CONSTANT("M_READ",M_READ,0); ADD_INT_CONSTANT("M_REPLIED",M_REPLIED,0); ADD_INT_CONSTANT("M_OLD",M_OLD,0); ADD_INT_CONSTANT("M_FLAG",M_FLAG,0); ADD_INT_CONSTANT("M_DELETE",M_DELETE,0); ADD_INT_CONSTANT("M_TAG",M_TAG,0); ADD_INT_CONSTANT("M_NEW",M_NEW,0); /* constants for mx_check_mailbox() */ ADD_INT_CONSTANT("M_NEW_MAIL",M_NEW_MAIL,0); ADD_INT_CONSTANT("M_REOPENED",M_REOPENED,0); ADD_INT_CONSTANT("M_FLAGS",M_FLAGS,0); start_new_program(); ADD_STORAGE(MAILSTORE_STORAGE); set_init_callback(init_mailstore); set_exit_callback(exit_mailstore); // public pike methods ADD_FUNCTION("create", f_create, tFunc(tString, tVoid), 0); ADD_FUNCTION("_sizeof", f__sizeof, tFunc(tVoid, tInt), 0); ADD_FUNCTION("stat", f_stat, tFunc(tVoid, tMapping), 0); ADD_FUNCTION("get_header", f_get_header, tFunc(tInt, tMapping), 0); ADD_FUNCTION("debug", f_debug, tFunc(tInt, tInt), 0); ADD_FUNCTION("set_flag", f_set_flag, tFunc(tInt tInt, tVoid), 0); ADD_FUNCTION("reset_flag", f_reset_flag, tFunc(tInt tInt, tVoid), 0); ADD_FUNCTION("check_mailbox", f_check_mailbox, tFunc(tVoid, tInt), 0); /* Mailbox.Message */ start_new_program(); set_init_callback(init_message_storage); set_exit_callback(exit_message_storage); ADD_STORAGE( MESSAGE_STORAGE ); ADD_FUNCTION("create", f_msg_create, tFunc(tInt, tVoid), 0); ADD_FUNCTION("getFD", f_msg_getfd, tFunc(tVoid, tInt), 0); ADD_FUNCTION("get_header",f_msg_get_header, tFunc(tVoid, tMapping), 0); end_class("Message",0); end_class("Mailbox",0); mutt_error=libmutt_error; /* reference it so that it's not optimized out */ __dummy_variable[0] = (void*)NULL; }
/* Function: alureGetProcAddress * * Returns a pointer for the named ALURE function. * * Returns: * NULL on error. * * *Version Added*: 1.1 */ ALURE_API void* ALURE_APIENTRY alureGetProcAddress(const ALchar *funcname) { static const struct { const char *name; void *func; } FunctionList[] = { #define ADD_FUNCTION(x) { #x, (void*)x }, ADD_FUNCTION(alureGetVersion) ADD_FUNCTION(alureGetErrorString) ADD_FUNCTION(alureGetDeviceNames) ADD_FUNCTION(alureFreeDeviceNames) ADD_FUNCTION(alureInitDevice) ADD_FUNCTION(alureShutdownDevice) ADD_FUNCTION(alureGetSampleFormat) ADD_FUNCTION(alureSleep) ADD_FUNCTION(alureCreateBufferFromFile) ADD_FUNCTION(alureCreateBufferFromMemory) ADD_FUNCTION(alureBufferDataFromFile) ADD_FUNCTION(alureBufferDataFromMemory) ADD_FUNCTION(alureCreateStreamFromFile) ADD_FUNCTION(alureCreateStreamFromMemory) ADD_FUNCTION(alureCreateStreamFromStaticMemory) ADD_FUNCTION(alureCreateStreamFromCallback) ADD_FUNCTION(alureRewindStream) ADD_FUNCTION(alureDestroyStream) ADD_FUNCTION(alureInstallDecodeCallbacks) ADD_FUNCTION(alureSetIOCallbacks) ADD_FUNCTION(alureGetProcAddress) ADD_FUNCTION(alurePlaySourceStream) ADD_FUNCTION(alurePlaySource) ADD_FUNCTION(alureStopSource) ADD_FUNCTION(alureGetSourceOffset) #undef ADD_FUNCTION { NULL, NULL } }; size_t i; for(i = 0; FunctionList[i].name; i++) { if(strcmp(FunctionList[i].name, funcname) == 0) break; } if(!FunctionList[i].name) SetError("Function not found"); return FunctionList[i].func; }
/** * Add native methods to the Bluetooth object. * [0] - Bluetooth Object */ duk_ret_t ModuleBluetooth(duk_context *ctx) { ADD_FUNCTION("init", js_bluetooth_init, 0); return 0; } // ModuleBluetooth