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 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); }
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(); }
void pike_module_init( void ) { STRS(data) = make_shared_string("data"); STRS(file) = make_shared_string("file"); STRS(method) = make_shared_string("method"); STRS(protocol) = make_shared_string("protocol"); STRS(query) = make_shared_string("query"); STRS(raw_url) = make_shared_string("raw_url"); SVAL(data)->type = T_STRING; SVAL(file)->type = T_STRING; SVAL(method)->type = T_STRING; SVAL(protocol)->type = T_STRING; SVAL(query)->type = T_STRING; SVAL(raw_url)->type = T_STRING; add_function_constant( "parse_headers", f_parse_headers, "function(string:mapping)", 0); add_function_constant( "parse_query_string", f_parse_query_string, "function(string,mapping:void)", OPT_SIDE_EFFECT); add_function_constant( "get_address", f_get_address, "function(string:string)", 0); start_new_program(); ADD_STORAGE( buffer ); add_function( "append", f_buf_append, "function(string:int)", OPT_SIDE_EFFECT ); add_function( "create", f_buf_create, "function(mapping,mapping:void)", 0 ); set_exit_callback(free_buf_struct); set_init_callback(alloc_buf_struct); parsehttp_program = end_program(); add_program_constant("ParseHTTP", parsehttp_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); }
void init_pike_searching(void) { start_new_program(); pike_search_struct_offset=ADD_STORAGE(struct pike_mem_searcher); MAP_VARIABLE("__s", tStr, 0, pike_search_struct_offset + OFFSETOF(pike_mem_searcher,s), PIKE_T_STRING); pike_search_program=end_program(); add_program_constant("Search",pike_search_program,ID_STATIC); memsearch_cache=allocate_mapping(10); memsearch_cache->data->flags |= MAPPING_FLAG_WEAK; }
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 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); }
/* 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); }
/* Initialize and start module */ void pike_module_init( void ) { STRS(data) = make_shared_string("data"); STRS(file) = make_shared_string("file"); STRS(method) = make_shared_string("method"); STRS(protocol) = make_shared_string("protocol"); STRS(query) = make_shared_string("query"); STRS(raw_url) = make_shared_string("raw_url"); SVAL(data)->type = T_STRING; SVAL(file)->type = T_STRING; SVAL(method)->type = T_STRING; SVAL(protocol)->type = T_STRING; SVAL(query)->type = T_STRING; SVAL(raw_url)->type = T_STRING; add_function_constant( "parse_headers", f_parse_headers, "function(string:mapping)", 0); add_function_constant( "parse_query_string", f_parse_query_string, "function(string,mapping:void)", OPT_SIDE_EFFECT); add_function_constant( "parse_prestates", f_parse_prestates, "function(string,multiset,multiset:string)", OPT_SIDE_EFFECT); add_function_constant( "get_address", f_get_address, "function(string:string)", 0); add_function_constant( "extension", f_extension, "function(string:string)", 0); add_function_constant( "create_process", f_create_process, "function(array(string),void|mapping(string:mixed):int)", 0); start_new_program(); ADD_STORAGE( buffer ); add_function( "append", f_buf_append, "function(string:int)", OPT_SIDE_EFFECT ); add_function( "create", f_buf_create, "function(mapping,mapping,int|void:void)", 0 ); set_init_callback(alloc_buf_struct); set_exit_callback(free_buf_struct); end_class("ParseHTTP", 0); init_nbio(); }
void init_avs_search_program(void) { // start building the AVS.Search program start_new_program(); // request space for the per-object private data ADD_STORAGE(struct private_search_data); // add the program methods add_function("create", f_create, "function(object:void)", ID_PUBLIC); add_function("destroy", f_destroy, "function(void:void)", ID_PUBLIC); add_function("docsfound", f_docsfound, "function(void:int)", ID_PUBLIC); add_function("docsreturned", f_docsreturned, "function(void:int)", ID_PUBLIC); add_function("termcount", f_termcount, "function(void:int)", ID_PUBLIC); add_function("get_result", f_get_result, "function(int:void)", ID_PUBLIC); add_function("get_term", f_get_term, "function(int:array)", ID_PUBLIC); add_function("get_version", f_get_version, "function(void:string)", ID_PUBLIC); add_function("get_date", f_get_date, "function(void:array)", ID_PUBLIC); add_function("get_data", f_get_data, "function(void:string)", ID_PUBLIC); add_function("get_docid", f_get_docid, "function(void:string)", ID_PUBLIC); add_function("get_relevance", f_get_relevance, "function(void:float)", ID_PUBLIC); // finish and add the AVS.Search program search_program = end_program(); add_program_constant("Search", search_program, 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 init_avs_count_program(void) { // start building the AVS.Search program start_new_program(); // request space for the per-object private data ADD_STORAGE(struct private_count_data); // add the program methods add_function("create", f_create, "function(object:void)", ID_PUBLIC); add_function("destroy", f_destroy, "function(void:void)", ID_PUBLIC); add_function("get_count", f_get_count, "function(void:int)", ID_PUBLIC); add_function("next", f_next, "function(void:void)", ID_PUBLIC); add_function("get_word", f_get_word, "function(void:string)", ID_PUBLIC); // finish and add the AVS.Search program count_program = end_program(); add_program_constant("Count", count_program, 0); }
/*! @decl program load_module(string module_name) *! *! Load a binary module. *! *! This function loads a module written in C or some other language *! into Pike. The module is initialized and any programs or constants *! defined will immediately be available. *! *! When a module is loaded the C function @tt{pike_module_init()@} will *! be called to initialize it. When Pike exits @tt{pike_module_exit()@} *! will be called. These two functions @b{must@} be available in the module. *! *! @note *! The current working directory is normally not searched for *! dynamic modules. Please use @expr{"./name.so"@} instead of just *! @expr{"name.so"@} to load modules from the current directory. */ void f_load_module(INT32 args) { extern int global_callable_flags; void *module; modfun init, exit; struct module_list *new_module; struct pike_string *module_name; ONERROR err; module_name = Pike_sp[-args].u.string; if((Pike_sp[-args].type != T_STRING) || (module_name->size_shift) || string_has_null(module_name)) { Pike_error("Bad argument 1 to load_module()\n"); } { struct module_list *mp; for (mp = dynamic_module_list; mp; mp = mp->next) if (mp->name == module_name && mp->module_prog) { pop_n_elems(args); ref_push_program(mp->module_prog); return; } } /* Removing RTLD_GLOBAL breaks some PiGTK themes - Hubbe */ /* Using RTLD_LAZY is faster, but makes it impossible to * detect linking problems at runtime.. */ module=dlopen(module_name->str, RTLD_NOW /*|RTLD_GLOBAL*/ ); if(!module) { struct object *err_obj = low_clone (module_load_error_program); #define LOADERR_STRUCT(OBJ) \ ((struct module_load_error_struct *) (err_obj->storage + module_load_error_offset)) const char *err = dlerror(); if (err) { if (err[strlen (err) - 1] == '\n') push_string (make_shared_binary_string (err, strlen (err) - 1)); else push_text (err); } else push_constant_text ("Unknown reason"); add_ref (LOADERR_STRUCT (err_obj)->path = Pike_sp[-args - 1].u.string); add_ref (LOADERR_STRUCT (err_obj)->reason = Pike_sp[-1].u.string); if (Pike_sp[-args].u.string->len < 1024) { throw_error_object (err_obj, "load_module", Pike_sp - args - 1, args, "load_module(\"%s\") failed: %s\n", module_name->str, Pike_sp[-1].u.string->str); } else { throw_error_object (err_obj, "load_module", Pike_sp - args - 1, args, "load_module() failed: %s\n", Pike_sp[-1].u.string->str); } } #ifdef PIKE_DEBUG { struct module_list *mp; for (mp = dynamic_module_list; mp; mp = mp->next) if (mp->module == module && mp->module_prog) { fprintf(stderr, "load_module(): Module loaded twice:\n" "Old name: %s\n" "New name: %s\n", mp->name->str, module_name->str); pop_n_elems(args); ref_push_program(mp->module_prog); return; } } #endif /* PIKE_DEBUG */ init = CAST_TO_FUN(dlsym(module, "pike_module_init")); if (!init) { init = CAST_TO_FUN(dlsym(module, "_pike_module_init")); if (!init) { dlclose(module); Pike_error("pike_module_init missing in dynamic module \"%S\".\n", module_name); } } exit = CAST_TO_FUN(dlsym(module, "pike_module_exit")); if (!exit) { exit = CAST_TO_FUN(dlsym(module, "_pike_module_exit")); if (!exit) { dlclose(module); Pike_error("pike_module_exit missing in dynamic module \"%S\".\n", module_name); } } #if defined(__NT__) && defined(_M_IA64) { fprintf(stderr, "pike_module_init: 0x%p\n" " func: 0x%p\n" " gp: 0x%p\n", init, ((void **)init)[0], ((void **)init)[1]); fprintf(stderr, "pike_module_exit: 0x%p\n" " func: 0x%p\n" " gp: 0x%p\n", exit, ((void **)exit)[0], ((void **)exit)[1]); } #endif /* __NT__ && _M_IA64 */ new_module=ALLOC_STRUCT(module_list); new_module->next=dynamic_module_list; dynamic_module_list=new_module; new_module->module=module; copy_shared_string(new_module->name, Pike_sp[-args].u.string); new_module->module_prog = NULL; new_module->init=init; new_module->exit=exit; enter_compiler(new_module->name, 1); start_new_program(); global_callable_flags|=CALLABLE_DYNAMIC; #ifdef PIKE_DEBUG { struct svalue *save_sp=Pike_sp; #endif SET_ONERROR(err, cleanup_compilation, NULL); #if defined(__NT__) && defined(_M_IA64) fprintf(stderr, "Calling pike_module_init()...\n"); #endif /* __NT__ && _M_IA64 */ (*(modfun)init)(); #if defined(__NT__) && defined(_M_IA64) fprintf(stderr, "pike_module_init() done.\n"); #endif /* __NT__ && _M_IA64 */ UNSET_ONERROR(err); #ifdef PIKE_DEBUG if(Pike_sp != save_sp) Pike_fatal("load_module(%s) left %ld droppings on stack!\n", module_name->str, PTRDIFF_T_TO_LONG(Pike_sp - save_sp)); } #endif pop_n_elems(args); { struct program *p = end_program(); exit_compiler(); if (p) { if ( #if 0 p->num_identifier_references #else /* !0 */ 1 #endif /* 0 */ ) { push_program(p); add_ref(new_module->module_prog = Pike_sp[-1].u.program); } else { /* No identifier references -- Disabled module. */ free_program(p); push_undefined(); } } else { /* Initialization failed. */ new_module->exit(); dlclose(module); dynamic_module_list = new_module->next; free_string(new_module->name); free(new_module); Pike_error("Failed to initialize dynamic module \"%S\".\n", module_name); } } }
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; }