void CSearchList::KademliaSearchKeyword(uint32 searchID, const Kademlia::CUInt128* fileID, LPCTSTR name, uint32 size, LPCTSTR type, UINT numProperties, ...) { va_list args; va_start(args, numProperties); EUtf8Str eStrEncode = utf8strRaw; CSafeMemFile* temp = new CSafeMemFile(250); uchar fileid[16]; fileID->toByteArray(fileid); temp->WriteHash16(fileid); temp->WriteUInt32(0); // client IP temp->WriteUInt16(0); // client port // write tag list UINT uFilePosTagCount = (UINT)temp->GetPosition(); uint32 tagcount = 0; temp->WriteUInt32(tagcount); // dummy tag count, will be filled later // standard tags CTag tagName(FT_FILENAME, name); tagName.WriteTagToFile(temp, eStrEncode); tagcount++; CTag tagSize(FT_FILESIZE, size); tagSize.WriteTagToFile(temp, eStrEncode); tagcount++; if (type != NULL && type[0] != _T('\0')) { CTag tagType(FT_FILETYPE, type); tagType.WriteTagToFile(temp, eStrEncode); tagcount++; } // additional tags while (numProperties-- > 0) { UINT uPropType = va_arg(args, UINT); LPCSTR pszPropName = va_arg(args, LPCSTR); LPVOID pvPropValue = va_arg(args, LPVOID); if (uPropType == 2 /*TAGTYPE_STRING*/) { if ((LPCTSTR)pvPropValue != NULL && ((LPCTSTR)pvPropValue)[0] != _T('\0')) { if (strlen(pszPropName) == 1) { CTag tagProp((uint8)*pszPropName, (LPCTSTR)pvPropValue); tagProp.WriteTagToFile(temp, eStrEncode); } else { CTag tagProp(pszPropName, (LPCTSTR)pvPropValue); tagProp.WriteTagToFile(temp, eStrEncode); } tagcount++; } } else if (uPropType == 3 /*TAGTYPE_UINT32*/) { if ((uint32)pvPropValue != 0) { CTag tagProp(pszPropName, (uint32)pvPropValue); tagProp.WriteTagToFile(temp, eStrEncode); tagcount++; } } else { ASSERT(0); } } va_end(args); temp->Seek(uFilePosTagCount, SEEK_SET); temp->WriteUInt32(tagcount); temp->SeekToBegin(); CSearchFile* tempFile = new CSearchFile(temp, eStrEncode == utf8strRaw, searchID, 0, 0, 0, true); AddToList(tempFile); delete temp; }
// Take each parsed format and expands the result into the 'print_buffer' based on the given 'options'. // The 'print_buffer' size is passed in so it not to overflow it. static uint16_t expand_data(va_list *ap, PARSEOPTION_TYPE *options, char *print_buffer, int16_t buffer_size) { uint16_t out_size = 0; if (!buffer_size) return 0; // We can probably trust outer loop won't call when there's no buffer left, but just in case if (options->MinWidth > buffer_size) options->MinWidth = buffer_size; switch (options->ParseType) { case PARSE_NONE: break; case PARSE_PERCENT: { *print_buffer++ = '%'; out_size++; } break; case PARSE_NONSENSE: // write error code as a complete unit or not at all if (buffer_size > 4) { *print_buffer++ = '%'; *print_buffer++ = '?'; *print_buffer++ = '?'; *print_buffer++ = '?'; out_size += 4; } break; case PARSE_BINARY: { uint8_t temp_num[BITS_PER_BYTE * sizeof(uint32_t)]; uint8_t *temp_num_ptr = temp_num; int16_t temp_num_size = 0; // Get value from argument list and convert it to digits // Decode the number to temporary storage as we need to write Most Significant Digit first // to the output buffer and we don't know how much to pad yet for MinWidth. if (options->Long == true) { uint32_t value = va_arg(*ap, uint32_t); do { *temp_num_ptr++ = (value & 1); value >>= 1; temp_num_size++; } while (value != 0); } else { uint16_t value = va_arg(*ap, uint16_t); do { *temp_num_ptr++ = (value & 1); value >>= 1; temp_num_size++; } while (value != 0); } // Pad and zero fill if the user wants it. { // calculate what's left for leading zero's. int16_t num_zeros = options->MinWidth - (temp_num_size + out_size); while ((num_zeros-- > 0) && (out_size < buffer_size)) { *print_buffer++ = (options->ZeroFill == true) ? '0' : ' '; out_size++; } } // Write the converted number. while ((temp_num_size-- > 0) && (out_size < buffer_size)) { // Write the digit converted to ascii *print_buffer++ = *(--temp_num_ptr) ? '1' : '0'; out_size++; } }
static gboolean egg_desktop_file_launchv (EggDesktopFile *desktop_file, GSList *documents, va_list args, GError **error) { EggDesktopFileLaunchOption option; GSList *translated_documents = NULL, *docs = NULL; char *command, **argv; int argc, i, screen_num; gboolean success, current_success; GdkDisplay *display; char *startup_id; GPtrArray *env = NULL; char **variables = NULL; GdkScreen *screen = NULL; int workspace = -1; const char *directory = NULL; guint32 launch_time = (guint32)-1; GSpawnFlags flags = G_SPAWN_SEARCH_PATH; GSpawnChildSetupFunc setup_func = NULL; gpointer setup_data = NULL; GPid *ret_pid = NULL; int *ret_stdin = NULL, *ret_stdout = NULL, *ret_stderr = NULL; char **ret_startup_id = NULL; if (documents && desktop_file->document_code == 0) { g_set_error (error, EGG_DESKTOP_FILE_ERROR, EGG_DESKTOP_FILE_ERROR_NOT_LAUNCHABLE, _("Application does not accept documents on command line")); return FALSE; } /* Read the options: technically it's incorrect for the caller to * NULL-terminate the list of options (rather than 0-terminating * it), but NULL-terminating lets us use G_GNUC_NULL_TERMINATED, * it's more consistent with other glib/gtk methods, and it will * work as long as sizeof (int) <= sizeof (NULL), and NULL is * represented as 0. (Which is true everywhere we care about.) */ while ((option = va_arg (args, EggDesktopFileLaunchOption))) { switch (option) { case EGG_DESKTOP_FILE_LAUNCH_CLEARENV: if (env) g_ptr_array_free (env, TRUE); env = g_ptr_array_new (); break; case EGG_DESKTOP_FILE_LAUNCH_PUTENV: variables = va_arg (args, char **); for (i = 0; variables[i]; i++) env = array_putenv (env, variables[i]); break; case EGG_DESKTOP_FILE_LAUNCH_SCREEN: screen = va_arg (args, GdkScreen *); break; case EGG_DESKTOP_FILE_LAUNCH_WORKSPACE: workspace = va_arg (args, int); break; case EGG_DESKTOP_FILE_LAUNCH_DIRECTORY: directory = va_arg (args, const char *); break; case EGG_DESKTOP_FILE_LAUNCH_TIME: launch_time = va_arg (args, guint32); break; case EGG_DESKTOP_FILE_LAUNCH_FLAGS: flags |= va_arg (args, GSpawnFlags); /* Make sure they didn't set any flags that don't make sense. */ flags &= ~G_SPAWN_FILE_AND_ARGV_ZERO; break; case EGG_DESKTOP_FILE_LAUNCH_SETUP_FUNC: setup_func = va_arg (args, GSpawnChildSetupFunc); setup_data = va_arg (args, gpointer); break; case EGG_DESKTOP_FILE_LAUNCH_RETURN_PID: ret_pid = va_arg (args, GPid *); break; case EGG_DESKTOP_FILE_LAUNCH_RETURN_STDIN_PIPE: ret_stdin = va_arg (args, int *); break; case EGG_DESKTOP_FILE_LAUNCH_RETURN_STDOUT_PIPE: ret_stdout = va_arg (args, int *); break; case EGG_DESKTOP_FILE_LAUNCH_RETURN_STDERR_PIPE: ret_stderr = va_arg (args, int *); break; case EGG_DESKTOP_FILE_LAUNCH_RETURN_STARTUP_ID: ret_startup_id = va_arg (args, char **); break; default: g_set_error (error, EGG_DESKTOP_FILE_ERROR, EGG_DESKTOP_FILE_ERROR_UNRECOGNIZED_OPTION, _("Unrecognized launch option: %d"), GPOINTER_TO_INT (option)); success = FALSE; goto out; } } if (screen) { char *display_name = gdk_screen_make_display_name (screen); char *display_env = g_strdup_printf ("DISPLAY=%s", display_name); env = array_putenv (env, display_env); g_free (display_name); g_free (display_env); display = gdk_screen_get_display (screen); } else { display = gdk_display_get_default (); screen = gdk_display_get_default_screen (display); } screen_num = gdk_screen_get_number (screen); translated_documents = translate_document_list (desktop_file, documents); docs = translated_documents; success = FALSE; do { command = parse_exec (desktop_file, &docs, error); if (!command) goto out; if (!g_shell_parse_argv (command, &argc, &argv, error)) { g_free (command); goto out; } g_free (command); #if GTK_CHECK_VERSION (2, 12, 0) startup_id = start_startup_notification (display, desktop_file, argv[0], screen_num, workspace, launch_time); if (startup_id) { char *startup_id_env = g_strdup_printf ("DESKTOP_STARTUP_ID=%s", startup_id); env = array_putenv (env, startup_id_env); g_free (startup_id_env); } #else startup_id = NULL; #endif /* GTK 2.12 */ if (env != NULL) g_ptr_array_add (env, NULL); current_success = g_spawn_async_with_pipes (directory, argv, env ? (char **)(env->pdata) : NULL, flags, setup_func, setup_data, ret_pid, ret_stdin, ret_stdout, ret_stderr, error); g_strfreev (argv); if (startup_id) { #if GTK_CHECK_VERSION (2, 12, 0) if (current_success) { set_startup_notification_timeout (display, startup_id); if (ret_startup_id) *ret_startup_id = startup_id; else g_free (startup_id); } else #endif /* GTK 2.12 */ g_free (startup_id); } else if (ret_startup_id) *ret_startup_id = NULL; if (current_success) { /* If we successfully launch any instances of the app, make * sure we return TRUE and don't set @error. */ success = TRUE; error = NULL; /* Also, only set the output params on the first one */ ret_pid = NULL; ret_stdin = ret_stdout = ret_stderr = NULL; ret_startup_id = NULL; } } while (docs && current_success); out: if (env) { g_ptr_array_foreach (env, (GFunc)g_free, NULL); g_ptr_array_free (env, TRUE); } free_document_list (translated_documents); return success; }
static int response_to_link_parent (entity_messages message, entity *receiver, entity *sender, va_list pargs) { list_types list_type; #if DEBUG_MODULE debug_log_entity_message (message, receiver, sender, pargs); #endif list_type = va_arg (pargs, list_types); switch (list_type) { //////////////////////////////////////// case LIST_TYPE_GUNSHIP_TARGET: //////////////////////////////////////// { set_local_entity_int_value (receiver, INT_TYPE_GUNSHIP_RADAR_LOS_CLEAR, TRUE); set_local_entity_float_value (receiver, FLOAT_TYPE_AIR_RADAR_CONTACT_TIMEOUT, AIR_RADAR_CONTACT_TIMEOUT); // show icon on map if gunship scans it. /* if (get_local_entity_int_value (receiver, INT_TYPE_SIDE) == get_global_gunship_side ()) { set_planner_icon_update (receiver, FALSE); } */ break; } //////////////////////////////////////// case LIST_TYPE_TARGET: //////////////////////////////////////// { entity *group; // // Notify the group that it has been targeted // if (get_comms_model () == COMMS_MODEL_SERVER) { if (get_local_entity_int_value (sender, INT_TYPE_IDENTIFY_MOBILE)) { group = get_local_entity_parent (sender, LIST_TYPE_MEMBER); if (group) { notify_local_entity (ENTITY_MESSAGE_ENTITY_TARGETED, group, receiver, sender); } } } // // if targetting the player then insert into the gunship target list if not already there // if (sender == get_gunship_entity ()) { if (!get_local_entity_parent (receiver, LIST_TYPE_GUNSHIP_TARGET)) { if (get_local_entity_int_value (receiver, INT_TYPE_TARGET_TYPE) != TARGET_TYPE_INVALID) { if (get_local_entity_int_value (receiver, INT_TYPE_THREAT_TYPE) != THREAT_TYPE_INVALID) { insert_local_entity_into_parents_child_list (receiver, LIST_TYPE_GUNSHIP_TARGET, sender, NULL); } } } } break; } } return (TRUE); }
static inline void opengl_post_hook(const char* name, void* fptr, int len_args, ...) { /* Shader errors */ const char* shdr_err = 0; if (fptr == glCompileShader || fptr == glLinkProgram) { GLuint s; va_list l; va_start(l, len_args); s = va_arg(l, GLuint); va_end(l); if (fptr == glCompileShader) shdr_err = gl_check_last_compile_error(s); else if (fptr == glLinkProgram) shdr_err = gl_check_last_link_error(s); } GLenum code = REAL_GL_FUNC(glGetError)(); if (code != GL_NO_ERROR || shdr_err) { /* Header */ size_t sz = 0; char* buf = 0; const char* header_fmt = "PANIC!\nOpenGL error in %s():\n"; sz += snprintf(0, 0, header_fmt, name) + 1; buf = realloc(buf, sz); snprintf(buf, sz, header_fmt, name); /* Shader errors */ if (shdr_err) { sz += strlen(shdr_err); buf = realloc(buf, sz); strcat(buf, shdr_err); free((void*)shdr_err); shdr_err = 0; } /* Messages */ for (;;) { GLint next_log_len = 0; glGetIntegerv(GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH, &next_log_len); if (!next_log_len) break; char* msg_buf = calloc(1, next_log_len); GLsizei length; GLenum source, type, id, severity; glGetDebugMessageLog(1, next_log_len, &source, &type, &id, &severity, &length, (GLchar*)msg_buf); if (type == GL_DEBUG_TYPE_ERROR) { const char* msg = construct_opengl_debug_msg(source, type, id, severity, length, (const char*)msg_buf); sz += strlen(msg); buf = realloc(buf, sz); strcat(buf, msg); free((void*)msg); } free(msg_buf); } /* Backtrace */ #ifdef __GLIBC__ const char* bt = btrace(); sz += strlen(bt); buf = realloc(buf, sz); strcat(buf, bt); free((void*)bt); #endif /* Show */ showerr_cb(showerr_ud, buf); free(buf); } }
char *FmtStr( char *buff, const char *fmt, va_list args ) { char *ptr; unsigned len; long val; address addr; char *res; sym_handle *sym; char save_buff[UTIL_LEN + 1]; while( *fmt != NULLCHAR ) { if( *fmt != '%' ) { *buff = *fmt; ++buff; } else { ++fmt; switch( *fmt ) { case 'c': val = va_arg( args, int ); *buff++ = val; break; case 's': ptr = va_arg( args, char * ); buff = StrCopy( ptr, buff ); break; case 't': ptr = va_arg( args, char * ); len = va_arg( args, unsigned ); memcpy( buff, ptr, len ); buff += len; break; case 'l': addr = va_arg( args, address ); buff = StrAddr( &addr, buff, TXT_LEN ); // nyi - overflow? res = LineAddr( &addr, save_buff, sizeof( save_buff ) ); if( res != NULL ) { *buff++ = '('; buff = StrCopy( save_buff, buff ); *buff++ = ')'; } break; case 'A': addr = va_arg( args, address ); buff = UniqStrAddr( &addr, buff, TXT_LEN ); // nyi - overflow? break; case 'a': addr = va_arg( args, address ); buff = StrAddr( &addr, buff, TXT_LEN ); // nyi - overflow? break; case 'p': addr = va_arg( args, address ); buff = AddrToIOString( &addr, buff, TXT_LEN ); // nyi - overflow? break; case 'e': val = va_arg( args, unsigned ); buff = SysErrMsg( val, buff ); break; case 'U': buff = CnvULongDec( va_arg( args, unsigned long), buff, TXT_LEN ); break; case 'd': val = va_arg( args, int ); buff = CnvLongDec( val, buff, TXT_LEN ); break; case 'u': val = va_arg( args, unsigned ); buff = CnvULongDec( val, buff, TXT_LEN ); break; case '%': *buff++ = '%'; break; case 'o': val = va_arg( args, long ); if( val < 0 ) { *buff++ = '-'; val = -val; } else { *buff++ = '+'; } buff = AddHexSpec( buff ); buff = CnvULongHex( val, buff, TXT_LEN ); break; case 'S': sym = va_arg( args, sym_handle * ); buff += SymName( sym, NULL, SN_SOURCE, buff, TXT_LEN ); break; } } ++fmt; } *buff = NULLCHAR; return( buff ); }
/** * Call with AS_OPERATIONS_CDT_OP only. */ static bool as_operations_cdt_op(as_operations *ops, const as_bin_name name, as_cdt_optype op, size_t n, ...) { if (op >= cdt_op_table_size) { return false; } const cdt_op_table_entry *entry = &cdt_op_table[op]; if (n < entry->count - entry->opt_args || n > entry->count) { return false; } va_list vl; if (n > 0) { va_start(vl, n); } as_arraylist list; as_arraylist_inita(&list, (uint32_t)n + 1); // +1 to avoid alloca(0) undefined behavior for (size_t i = 0; i < n; i++) { as_cdt_paramtype type = entry->args[i]; switch (type) { case AS_CDT_PARAM_PAYLOAD: { as_val *arg = va_arg(vl, as_val *); if (as_arraylist_append(&list, arg) != AS_ARRAYLIST_OK) { va_end(vl); as_arraylist_destroy(&list); return false; } break; } case AS_CDT_PARAM_COUNT: { uint64_t arg = va_arg(vl, uint64_t); if (as_arraylist_append(&list, (as_val *)as_integer_new(arg)) != AS_ARRAYLIST_OK) { va_end(vl); as_arraylist_destroy(&list); return false; } break; } case AS_CDT_PARAM_INDEX: { int64_t arg = va_arg(vl, int64_t); if (as_arraylist_append(&list, (as_val *)as_integer_new(arg)) != AS_ARRAYLIST_OK) { va_end(vl); as_arraylist_destroy(&list); return false; } break; } default: break; } } if (n > 0) { va_end(vl); } as_serializer ser; as_msgpack_init(&ser); uint32_t list_size = as_serializer_serialize_getsize(&ser, (as_val *) &list); as_bytes *bytes = as_bytes_new(sizeof(uint16_t) + list_size); uint8_t *list_write = as_bytes_get(bytes); uint16_t *list_write_op = (uint16_t *)list_write; *list_write_op = cf_swap_to_be16(op); list_write += sizeof(uint16_t); as_serializer_serialize_presized(&ser, (const as_val *) &list, list_write); as_serializer_destroy(&ser); as_arraylist_destroy(&list); bytes->size = bytes->capacity; // as_bytes->type default to AS_BYTES_BLOB if (entry->rw_type == CDT_RW_TYPE_MODIFY) { return as_operations_add_cdt_modify(ops, name, (as_bin_value *) bytes); } return as_operations_add_cdt_read(ops, name, (as_bin_value *) bytes); }
/* * pseudo signature: * * int API_dev_read( * struct device_info *di, * void *buf, * size_t *len, * unsigned long *start * size_t *act_len * ) * * buf: ptr to buffer where to put the read data * * len: ptr to length to be read * - network: len of packet to read (in bytes) * - storage: # of blocks to read (can vary in size depending on define) * * start: ptr to start block (only used for storage devices, ignored for * network) * * act_len: ptr to where to put the len actually read */ static int API_dev_read(va_list ap) { struct device_info *di; void *buf; lbasize_t *len_stor, *act_len_stor; lbastart_t *start; int *len_net, *act_len_net; /* 1. arg is ptr to the device_info struct */ di = (struct device_info *)va_arg(ap, u_int32_t); if (di == NULL) return API_EINVAL; /* XXX should we check if device is open? i.e. the ->state ? */ if (di->cookie == NULL) return API_ENODEV; /* 2. arg is ptr to buffer from where to put the read data */ buf = (void *)va_arg(ap, u_int32_t); if (buf == NULL) return API_EINVAL; if (di->type & DEV_TYP_STOR) { /* 3. arg - ptr to var with # of blocks to read */ len_stor = (lbasize_t *)va_arg(ap, u_int32_t); if (!len_stor) return API_EINVAL; if (*len_stor <= 0) return API_EINVAL; /* 4. arg - ptr to var with start block */ start = (lbastart_t *)va_arg(ap, u_int32_t); /* 5. arg - ptr to var where to put the len actually read */ act_len_stor = (lbasize_t *)va_arg(ap, u_int32_t); if (!act_len_stor) return API_EINVAL; *act_len_stor = dev_read_stor(di->cookie, buf, *len_stor, *start); } else if (di->type & DEV_TYP_NET) { /* 3. arg points to the var with length of packet to read */ len_net = (int *)va_arg(ap, u_int32_t); if (!len_net) return API_EINVAL; if (*len_net <= 0) return API_EINVAL; /* 4. - ptr to var where to put the len actually read */ act_len_net = (int *)va_arg(ap, u_int32_t); if (!act_len_net) return API_EINVAL; *act_len_net = dev_read_net(di->cookie, buf, *len_net); } else return API_ENODEV; return 0; }
/** * @brief Reads from a buffer according to format; version without syntactic sugar for variable arguments, to call it from other functions with variable arguments * @sa SV_ReadFormat * @param[in] buf The buffer we read the data from * @param[in] format The format string may not be nullptr */ void NET_vReadFormat (dbuffer* buf, const char* format, va_list ap) { while (*format) { const char typeID = *format++; switch (typeID) { case 'c': *va_arg(ap, int*) = NET_ReadChar(buf); break; case 'b': *va_arg(ap, int*) = NET_ReadByte(buf); break; case 's': *va_arg(ap, int*) = NET_ReadShort(buf); break; case 'l': *va_arg(ap, int*) = NET_ReadLong(buf); break; case 'p': NET_ReadPos(buf, *va_arg(ap, vec3_t*)); break; case 'g': NET_ReadGPos(buf, *va_arg(ap, pos3_t*)); break; case 'd': NET_ReadDir(buf, *va_arg(ap, vec3_t*)); break; case 'a': *va_arg(ap, float*) = NET_ReadAngle(buf); break; case '!': format++; break; case '&': { char* str = va_arg(ap, char*); const size_t length = va_arg(ap, size_t); NET_ReadString(buf, str, length); break; } case '*': { int i; byte* p; const int n = NET_ReadShort(buf); *va_arg(ap, int*) = n; p = va_arg(ap, byte*); for (i = 0; i < n; i++) *p++ = NET_ReadByte(buf); } break; default: Com_Error(ERR_DROP, "ReadFormat: Unknown type!"); } } /* Too many arguments for the given format; too few cause crash above */ #ifdef PARANOID if (!ap) Com_Error(ERR_DROP, "ReadFormat: Too many arguments!"); #endif }
int idaapi DBG_Callback(void *ud, int notification_code, va_list va) { // This hook gets called from the kernel. Ensure we hold the GIL. PYW_GIL_GET; class DBG_Hooks *proxy = (class DBG_Hooks *)ud; debug_event_t *event; int code = 0; try { switch (notification_code) { case dbg_process_start: event = va_arg(va, debug_event_t *); proxy->dbg_process_start(event->pid, event->tid, event->ea, event->modinfo.name, event->modinfo.base, event->modinfo.size); break; case dbg_process_exit: event = va_arg(va, debug_event_t *); proxy->dbg_process_exit( event->pid, event->tid, event->ea, event->exit_code); break; case dbg_process_attach: event = va_arg(va, debug_event_t *); proxy->dbg_process_attach( event->pid, event->tid, event->ea, event->modinfo.name, event->modinfo.base, event->modinfo.size); break; case dbg_process_detach: event = va_arg(va, debug_event_t *); proxy->dbg_process_detach( event->pid, event->tid, event->ea); break; case dbg_thread_start: event = va_arg(va, debug_event_t *); proxy->dbg_thread_start( event->pid, event->tid, event->ea); break; case dbg_thread_exit: event = va_arg(va, debug_event_t *); proxy->dbg_thread_exit( event->pid, event->tid, event->ea, event->exit_code); break; case dbg_library_load: event = va_arg(va, debug_event_t *); proxy->dbg_library_load( event->pid, event->tid, event->ea, event->modinfo.name, event->modinfo.base, event->modinfo.size); break; case dbg_library_unload: event = va_arg(va, debug_event_t *); proxy->dbg_library_unload( event->pid, event->tid, event->ea, event->info); break; case dbg_information: event = va_arg(va, debug_event_t *); proxy->dbg_information( event->pid, event->tid, event->ea, event->info); break; case dbg_exception: { event = va_arg(va, debug_event_t *); int *warn = va_arg(va, int *); *warn = proxy->dbg_exception( event->pid, event->tid, event->ea, event->exc.code, event->exc.can_cont, event->exc.ea, event->exc.info); break; } case dbg_suspend_process: proxy->dbg_suspend_process(); break; case dbg_bpt: { thid_t tid = va_arg(va, thid_t); ea_t breakpoint_ea = va_arg(va, ea_t); int *warn = va_arg(va, int *); *warn = proxy->dbg_bpt(tid, breakpoint_ea); break; } case dbg_trace: { thid_t tid = va_arg(va, thid_t); ea_t ip = va_arg(va, ea_t); code = proxy->dbg_trace(tid, ip); break; } case dbg_request_error: { int failed_command = (int)va_argi(va, ui_notification_t); int failed_dbg_notification = (int)va_argi(va, dbg_notification_t); proxy->dbg_request_error(failed_command, failed_dbg_notification); break; } case dbg_step_into: proxy->dbg_step_into(); break; case dbg_step_over: proxy->dbg_step_over(); break; case dbg_run_to: event = va_arg(va, debug_event_t *); proxy->dbg_run_to( event->pid, event->tid, event->ea); break; case dbg_step_until_ret: proxy->dbg_step_until_ret(); break; } } catch (Swig::DirectorException &e) { msg("Exception in DBG Hook function: %s\n", e.getMessage()); if (PyErr_Occurred()) PyErr_Print(); } return code; }
static void flush_pending_metadata_to_save (ItemHandler *item, ...) { gboolean to_free; gchar *stats; gchar *query; gchar *useless; gchar *uri; va_list params; gpointer key; gpointer value; GList *statements; GHashTable *table; GHashTableIter iter; GVariant *results; GVariant *rows; GVariant *sub_value; GVariant *sub_sub_value; GVariantIter r_iter; GVariantIter sub_iter; GVariantIter sub_sub_iter; GError *error; Property *prop; statements = NULL; va_start (params, item); while ((table = va_arg (params, GHashTable*)) != NULL) { to_free = va_arg (params, gboolean); g_hash_table_iter_init (&iter, table); while (g_hash_table_iter_next (&iter, &key, &value)) { prop = properties_pool_get_by_name ((gchar*) key); switch (property_get_datatype (prop)) { case PROPERTY_TYPE_STRING: stats = g_strdup_printf ("%s \"%s\"", (gchar*) key, (gchar*) value); statements = g_list_prepend (statements, stats); break; case PROPERTY_TYPE_RESOURCE: stats = g_strdup_printf ("%s <%s>", (gchar*) key, (gchar*) value); statements = g_list_prepend (statements, stats); break; default: stats = g_strdup_printf ("%s %s", (gchar*) key, (gchar*) value); statements = g_list_prepend (statements, stats); break; } } if (to_free == TRUE) g_hash_table_foreach_remove (table, destroy_value_in_hash, NULL); } va_end (params); if (statements == NULL) return; stats = from_glist_to_string (statements, " ; ", TRUE); query = g_strdup_printf ("INSERT { _:item a nfo:FileDataObject ; a nie:InformationElement ; %s }", stats); g_free (stats); error = NULL; results = execute_update_blank (query, &error); if (error != NULL) { g_warning ("Error while saving metadata: %s", error->message); g_error_free (error); } else { /* To know how to iter a SparqlUpdateBlank response, cfr. http://mail.gnome.org/archives/commits-list/2011-February/msg05384.html */ g_variant_iter_init (&r_iter, results); if ((rows = g_variant_iter_next_value (&r_iter))) { g_variant_iter_init (&sub_iter, rows); if ((sub_value = g_variant_iter_next_value (&sub_iter))) { g_variant_iter_init (&sub_sub_iter, sub_value); if ((sub_sub_value = g_variant_iter_next_value (&sub_sub_iter))) { useless = NULL; uri = NULL; g_variant_get (sub_sub_value, "a{ss}", &useless, &uri); item->priv->subject = g_strdup (uri); g_variant_unref (sub_sub_value); } g_variant_unref (sub_value); } g_variant_unref (rows); } } g_free (query); }
int _nis_getnetbyaddr(void *rval, void *cb_data, va_list ap) { #ifdef YP uint32_t addr; int af; char *buffer; size_t buflen; int *errnop, *h_errnop; struct netent *nptr, ne; struct netent_data *ned; char *str, *cp; uint32_t net2; int nn; unsigned int netbr[4]; char buf[MAXDNAME]; res_state statp; addr = va_arg(ap, uint32_t); af = va_arg(ap, int); nptr = va_arg(ap, struct netent *); buffer = va_arg(ap, char *); buflen = va_arg(ap, size_t); errnop = va_arg(ap, int *); h_errnop = va_arg(ap, int *); statp = __res_state(); if ((ned = __netent_data_init()) == NULL) { RES_SET_H_ERRNO(statp, NETDB_INTERNAL); *h_errnop = statp->res_h_errno; return (NS_UNAVAIL); } if (af != AF_INET) { RES_SET_H_ERRNO(statp, NETDB_INTERNAL); *h_errnop = statp->res_h_errno; errno = EAFNOSUPPORT; return (NS_UNAVAIL); } for (nn = 4, net2 = addr; net2; net2 >>= 8) { netbr[--nn] = net2 & 0xff; } switch (nn) { case 3: /* Class A */ sprintf(buf, "%u", netbr[3]); break; case 2: /* Class B */ sprintf(buf, "%u.%u", netbr[2], netbr[3]); break; case 1: /* Class C */ sprintf(buf, "%u.%u.%u", netbr[1], netbr[2], netbr[3]); break; case 0: /* Class D - E */ sprintf(buf, "%u.%u.%u.%u", netbr[0], netbr[1], netbr[2], netbr[3]); break; } str = (char *)&buf; cp = str + (strlen(str) - 2); while(!strcmp(cp, ".0")) { *cp = '\0'; cp = str + (strlen(str) - 2); } if (_getnetbynis(str, "networks.byaddr", af, &ne, ned) != 0) { *h_errnop = statp->res_h_errno; return (NS_NOTFOUND); } if (__copy_netent(&ne, nptr, buffer, buflen) != 0) { *errnop = errno; RES_SET_H_ERRNO(statp, NETDB_INTERNAL); *h_errnop = statp->res_h_errno; return (NS_RETURN); } *((struct netent **)rval) = nptr; return (NS_SUCCESS); #else return (NS_UNAVAIL); #endif /* YP */ }
/** * Write a formatted string to a printf context * * @v ctx Context * @v fmt Format string * @v args Arguments corresponding to the format string * @ret len Length of formatted string */ size_t vcprintf ( struct printf_context *ctx, const char *fmt, va_list args ) { int flags; int width; uint8_t *length; char *ptr; char tmp_buf[32]; /* 32 is enough for all numerical formats. * Insane width fields could overflow this buffer. */ wchar_t *wptr; /* Initialise context */ ctx->len = 0; for ( ; *fmt ; fmt++ ) { /* Pass through ordinary characters */ if ( *fmt != '%' ) { cputchar ( ctx, *fmt ); continue; } fmt++; /* Process flag characters */ flags = 0; for ( ; ; fmt++ ) { if ( *fmt == '#' ) { flags |= ALT_FORM; } else if ( *fmt == '0' ) { flags |= ZPAD; } else { /* End of flag characters */ break; } } /* Process field width */ width = 0; for ( ; ; fmt++ ) { if ( ( ( unsigned ) ( *fmt - '0' ) ) < 10 ) { width = ( width * 10 ) + ( *fmt - '0' ); } else { break; } } /* We don't do floating point */ /* Process length modifier */ length = &type_sizes[INT_LEN]; for ( ; ; fmt++ ) { if ( *fmt == 'h' ) { length--; } else if ( *fmt == 'l' ) { length++; } else if ( *fmt == 'z' ) { length = &type_sizes[SIZE_T_LEN]; } else { break; } } /* Process conversion specifier */ ptr = tmp_buf + sizeof ( tmp_buf ) - 1; *ptr = '\0'; wptr = NULL; if ( *fmt == 'c' ) { if ( length < &type_sizes[LONG_LEN] ) { cputchar ( ctx, va_arg ( args, unsigned int ) ); } else { wchar_t wc; size_t len; wc = va_arg ( args, wint_t ); len = wcrtomb ( tmp_buf, wc, NULL ); tmp_buf[len] = '\0'; ptr = tmp_buf; } } else if ( *fmt == 's' ) { if ( length < &type_sizes[LONG_LEN] ) { ptr = va_arg ( args, char * ); } else { wptr = va_arg ( args, wchar_t * ); } if ( ( ptr == NULL ) && ( wptr == NULL ) ) ptr = "<NULL>"; } else if ( *fmt == 'p' ) {
/** * cd_state_set_steps_real: **/ gboolean cd_state_set_steps_real (CdState *state, GError **error, const gchar *strloc, gint value, ...) { va_list args; guint i; gint value_temp; guint total; g_return_val_if_fail (state != NULL, FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); /* we must set at least one thing */ total = value; /* process the valist */ va_start (args, value); for (i = 0;; i++) { value_temp = va_arg (args, gint); if (value_temp == -1) break; total += (guint) value_temp; } va_end (args); /* does not sum to 100% */ if (total != 100) { g_set_error (error, CD_STATE_ERROR, CD_STATE_ERROR_INVALID, "percentage not 100: %u", total); return FALSE; } /* set step number */ if (!cd_state_set_number_steps_real (state, i+1, strloc)) { g_set_error (error, CD_STATE_ERROR, CD_STATE_ERROR_INVALID, "failed to set number steps: %u", i+1); return FALSE; } /* save this data */ total = value; state->priv->step_data = g_new0 (guint, i+2); state->priv->step_profile = g_new0 (gdouble, i+2); state->priv->step_data[0] = total; va_start (args, value); for (i = 0;; i++) { value_temp = va_arg (args, gint); if (value_temp == -1) break; /* we pre-add the data to make access simpler */ total += (guint) value_temp; state->priv->step_data[i+1] = total; } va_end (args); return TRUE; }
/* Print a formatted string to screen. Only used for debugging. This is NOT a POSIX compliant function. */ void debug_print (const char *format_string, ...) { va_list va_arguments; int index = 0; va_start (va_arguments, format_string); if (format_string == NULL) { debug_print ("%s: format_string == NULL.\n", __FUNCTION__); return; } /* Main parser loop. */ while (format_string[index] != 0) { switch (format_string[index]) { /* Percent sign means we get a formatting code as the next character. */ case '%': { index++; switch (format_string[index]) { /* Character. */ case 'c': { char character = va_arg (va_arguments, int); put_character (x_position, y_position, character, text_attribute); /* Move the cursor. */ x_position++; if (x_position >= DEBUG_SCREEN_WIDTH) { y_position++; x_position = 0; } break; } /* String. */ case 's': { print_simple (va_arg (va_arguments, char *)); break; } /* Signed number. */ case 'd': { char string[11]; signed number = va_arg (va_arguments, signed); /* If the number is negative, print it with a hyphen before. */ if (number < 0) { string[0] = '-'; decimal_string (string + 1, -number); } else { decimal_string (string, number); } print_simple (string); break; } /* Unsigned number. */ case 'u': { char string[11]; decimal_string (string, va_arg (va_arguments, unsigned)); print_simple (string); break; } /* Hexadecimal number. Padded to eight characters with zeroes. */ case 'p': case 'x': { char string[9]; hex_string (string, va_arg (va_arguments, unsigned)); print_simple (string); break; } /* 64-bit hexadecimal number. */ case 'X': { char string[9]; hex_string (string, va_arg (va_arguments, uint64_t)); print_simple (string); break; } /* Anything other is printed out in plain. */ default: { put_character (x_position, y_position, format_string[index], text_attribute); /* Move the cursor. */ x_position++; if (x_position >= DEBUG_SCREEN_WIDTH) { y_position++; x_position = 0; } break; } } break; } /* New line. */ case '\n': { y_position++; x_position = 0; break; } /* All regular characters are just printed out. */ default: { put_character (x_position, y_position, format_string[index], text_attribute); /* Move the cursor. */ x_position++; if (x_position >= DEBUG_SCREEN_WIDTH) { y_position++; x_position = 0; } } } /* If we're passing the last line on screen, scroll everything upwards one line. */ if (y_position == DEBUG_SCREEN_HEIGHT) { y_position--; memory_copy ((void *) screen, (void *) &screen[DEBUG_SCREEN_WIDTH], (DEBUG_SCREEN_WIDTH * (DEBUG_SCREEN_HEIGHT - 1)) * 2); memory_set_uint16 ((void *) &screen[DEBUG_SCREEN_WIDTH * (DEBUG_SCREEN_HEIGHT - 1)], (background_attribute << 8) | ' ', DEBUG_SCREEN_WIDTH); } index++; } va_end (va_arguments); }
//----------------------------------------------------------------------------- int at_parse_command(const unsigned char *input, const char *format, ...) //----------------------------------------------------------------------------- { const char *fmt = format; const char *inp = (const char *)input; char *endptr; unsigned char *out_us; unsigned char *buffer; size_t length; size_t storage_size; int *out_i; long int *out_l; va_list ap; int error = 1; printf("PARSER_LOG:Parsing %s\n with %s\n", input, format); va_start(ap, format); while (*fmt) { switch(*fmt++) { case '@': if (*fmt == 0) { printf("PARSER_LOG:Invalid format string: %s\n", format); error = 0; goto end; } switch(*fmt++) { case 'i': out_i = va_arg(ap, int *); *out_i = strtol(inp, &endptr, 10); if (endptr == inp) { error = 0; goto end; } printf("PARSER_LOG:Parsed int %d\n", *out_i); inp = endptr; break; case 'I': out_i = va_arg(ap, int *); *out_i = strtol(inp, &endptr, 10); if (endptr == inp) { printf("PARSER_LOG:Number empty\n"); *out_i = 0; } else { printf("PARSER_LOG:Parsed int %d\n", *out_i); inp = endptr; } break; case 'l': out_l = va_arg(ap, long int *); *out_l = strtol(inp, &endptr, 10); if (endptr == inp) { error = 0; goto end; } printf("PARSER_LOG:Parsed long int %ld\n", *out_l); inp = endptr; break; case 'r': out_us = va_arg(ap, unsigned char *); storage_size = va_arg(ap, size_t); length = at_grab_string(inp, &buffer); printf("PARSER_LOG:Parsed raw string \"%s\"\n", buffer); if (strlen(buffer) > storage_size) { free(buffer); error = 0; goto end; } strcpy(out_us, buffer); free(buffer); inp += length; break; case '@': if (*inp++ != '@') { error = 0; goto end; } break; case '0': /* Just skip the rest */ goto end; default: printf("PARSER_LOG:Invalid format string (@%c): %s\n", *(fmt - 1), format); error = 0; goto end; } break; case ' ': while (isspace(*inp)) inp++; break; default: if (*inp++ != *(fmt - 1)) { error = 0; goto end; } break; } } /* Ignore trailing spaces */ while (isspace(*inp)) inp++; if (*inp != 0) { printf("PARSER_LOG:String do not end same!\n"); error = 0; goto end; } end: va_end(ap); return error; }
//<code(py_idbhooks)> //--------------------------------------------------------------------------- int idaapi IDB_Callback(void *ud, int notification_code, va_list va) { // This hook gets called from the kernel. Ensure we hold the GIL. PYW_GIL_GET; class IDB_Hooks *proxy = (class IDB_Hooks *)ud; int ret = 0; try { switch ( notification_code ) { // hookgenIDB:notifications case idb_event::byte_patched: { ea_t ea = va_arg(va, ea_t); uint32 old_value = va_arg(va, uint32); ret = proxy->byte_patched(ea, old_value); } break; case idb_event::cmt_changed: { ea_t ea = va_arg(va, ea_t); bool repeatable_cmt = bool(va_arg(va, int)); ret = proxy->cmt_changed(ea, repeatable_cmt); } break; case idb_event::ti_changed: { ea_t ea = va_arg(va, ea_t); const type_t * type = va_arg(va, const type_t *); const p_list * fnames = va_arg(va, const p_list *); ret = proxy->ti_changed(ea, type, fnames); } break; case idb_event::op_ti_changed: { ea_t ea = va_arg(va, ea_t); int n = va_arg(va, int); const type_t * type = va_arg(va, const type_t *); const p_list * fnames = va_arg(va, const p_list *); ret = proxy->op_ti_changed(ea, n, type, fnames); } break; case idb_event::op_type_changed: { ea_t ea = va_arg(va, ea_t); int n = va_arg(va, int); ret = proxy->op_type_changed(ea, n); } break; case idb_event::enum_created: { enum_t id = va_arg(va, enum_t); ret = proxy->enum_created(id); } break; case idb_event::enum_deleted: { enum_t id = va_arg(va, enum_t); ret = proxy->enum_deleted(id); } break; case idb_event::enum_bf_changed: { enum_t id = va_arg(va, enum_t); ret = proxy->enum_bf_changed(id); } break; case idb_event::enum_renamed: { tid_t id = va_arg(va, tid_t); ret = proxy->enum_renamed(id); } break; case idb_event::enum_cmt_changed: { tid_t id = va_arg(va, tid_t); bool repeatable = bool(va_arg(va, int)); ret = proxy->enum_cmt_changed(id, repeatable); } break; case idb_event::enum_const_created: { enum_t id = va_arg(va, enum_t); const_t cid = va_arg(va, const_t); ret = proxy->enum_member_created(id, cid); } break; case idb_event::enum_const_deleted: { enum_t id = va_arg(va, enum_t); const_t cid = va_arg(va, const_t); ret = proxy->enum_member_deleted(id, cid); } break; case idb_event::struc_created: { tid_t struc_id = va_arg(va, tid_t); ret = proxy->struc_created(struc_id); } break; case idb_event::struc_deleted: { tid_t struc_id = va_arg(va, tid_t); ret = proxy->struc_deleted(struc_id); } break; case idb_event::struc_renamed: { struc_t * sptr = va_arg(va, struc_t *); ret = proxy->struc_renamed(sptr); } break; case idb_event::struc_expanded: { struc_t * sptr = va_arg(va, struc_t *); ret = proxy->struc_expanded(sptr); } break; case idb_event::struc_cmt_changed: { tid_t struc_id = va_arg(va, tid_t); bool repeatable_cmt = bool(va_arg(va, int)); ret = proxy->struc_cmt_changed(struc_id, repeatable_cmt); } break; case idb_event::struc_member_created: { struc_t * sptr = va_arg(va, struc_t *); member_t * mptr = va_arg(va, member_t *); ret = proxy->struc_member_created(sptr, mptr); } break; case idb_event::struc_member_deleted: { struc_t * sptr = va_arg(va, struc_t *); tid_t member_id = va_arg(va, tid_t); ea_t offset = va_arg(va, ea_t); ret = proxy->struc_member_deleted(sptr, member_id, offset); } break; case idb_event::struc_member_renamed: { struc_t * sptr = va_arg(va, struc_t *); member_t * mptr = va_arg(va, member_t *); ret = proxy->struc_member_renamed(sptr, mptr); } break; case idb_event::struc_member_changed: { struc_t * sptr = va_arg(va, struc_t *); member_t * mptr = va_arg(va, member_t *); ret = proxy->struc_member_changed(sptr, mptr); } break; case idb_event::thunk_func_created: { func_t * pfn = va_arg(va, func_t *); ret = proxy->thunk_func_created(pfn); } break; case idb_event::func_tail_appended: { func_t * pfn = va_arg(va, func_t *); func_t * tail = va_arg(va, func_t *); ret = proxy->func_tail_appended(pfn, tail); } break; case idb_event::func_tail_removed: { func_t * pfn = va_arg(va, func_t *); ea_t tail_ea = va_arg(va, ea_t); ret = proxy->func_tail_removed(pfn, tail_ea); } break; case idb_event::tail_owner_changed: { func_t * tail = va_arg(va, func_t *); ea_t owner_func = va_arg(va, ea_t); ea_t old_owner = va_arg(va, ea_t); ret = proxy->tail_owner_changed(tail, owner_func, old_owner); } break; case idb_event::func_noret_changed: { func_t * pfn = va_arg(va, func_t *); ret = proxy->func_noret_changed(pfn); } break; case idb_event::segm_added: { segment_t * s = va_arg(va, segment_t *); ret = proxy->segm_added(s); } break; case idb_event::segm_deleted: { ea_t startEA = va_arg(va, ea_t); ea_t endEA = va_arg(va, ea_t); ret = proxy->segm_deleted(startEA, endEA); } break; case idb_event::segm_start_changed: { segment_t * s = va_arg(va, segment_t *); ea_t oldstart = va_arg(va, ea_t); ret = proxy->segm_start_changed(s, oldstart); } break; case idb_event::segm_end_changed: { segment_t * s = va_arg(va, segment_t *); ea_t oldend = va_arg(va, ea_t); ret = proxy->segm_end_changed(s, oldend); } break; case idb_event::segm_moved: { ea_t from = va_arg(va, ea_t); ea_t to = va_arg(va, ea_t); asize_t size = va_arg(va, asize_t); ret = proxy->segm_moved(from, to, size); } break; case idb_event::area_cmt_changed: { areacb_t * cb = va_arg(va, areacb_t *); const area_t * a = va_arg(va, const area_t *); const char * cmt = va_arg(va, const char *); bool repeatable = bool(va_arg(va, int)); ret = proxy->area_cmt_changed(cb, a, cmt, repeatable); } break; case idb_event::changing_cmt: { ea_t ea = va_arg(va, ea_t); bool repeatable_cmt = bool(va_arg(va, int)); const char * newcmt = va_arg(va, const char *); ret = proxy->changing_cmt(ea, repeatable_cmt, newcmt); } break; case idb_event::changing_ti: { ea_t ea = va_arg(va, ea_t); const type_t * new_type = va_arg(va, const type_t *); const p_list * new_fnames = va_arg(va, const p_list *); ret = proxy->changing_ti(ea, new_type, new_fnames); } break; case idb_event::changing_op_ti: { ea_t ea = va_arg(va, ea_t); int n = va_arg(va, int); const type_t * new_type = va_arg(va, const type_t *); const p_list * new_fnames = va_arg(va, const p_list *); ret = proxy->changing_op_ti(ea, n, new_type, new_fnames); } break; case idb_event::changing_op_type: { ea_t ea = va_arg(va, ea_t); int n = va_arg(va, int); ret = proxy->changing_op_type(ea, n); } break; case idb_event::deleting_enum: { enum_t id = va_arg(va, enum_t); ret = proxy->deleting_enum(id); } break; case idb_event::changing_enum_bf: { enum_t id = va_arg(va, enum_t); bool new_bf = bool(va_arg(va, int)); ret = proxy->changing_enum_bf(id, new_bf); } break; case idb_event::renaming_enum: { tid_t id = va_arg(va, tid_t); bool is_enum = bool(va_arg(va, int)); const char * newname = va_arg(va, const char *); ret = proxy->renaming_enum(id, is_enum, newname); } break; case idb_event::changing_enum_cmt: { tid_t id = va_arg(va, tid_t); bool repeatable = bool(va_arg(va, int)); const char * newcmt = va_arg(va, const char *); ret = proxy->changing_enum_cmt(id, repeatable, newcmt); } break; case idb_event::deleting_enum_const: { ret = proxy->deleting_enum_const(); } break; case idb_event::deleting_struc: { struc_t * sptr = va_arg(va, struc_t *); ret = proxy->deleting_struc(sptr); } break; case idb_event::renaming_struc: { tid_t id = va_arg(va, tid_t); const char * oldname = va_arg(va, const char *); const char * newname = va_arg(va, const char *); ret = proxy->renaming_struc(id, oldname, newname); } break; case idb_event::expanding_struc: { struc_t * sptr = va_arg(va, struc_t *); ea_t offset = va_arg(va, ea_t); adiff_t delta = va_arg(va, adiff_t); ret = proxy->expanding_struc(sptr, offset, delta); } break; case idb_event::changing_struc_cmt: { tid_t struc_id = va_arg(va, tid_t); bool repeatable = bool(va_arg(va, int)); const char * newcmt = va_arg(va, const char *); ret = proxy->changing_struc_cmt(struc_id, repeatable, newcmt); } break; case idb_event::deleting_struc_member: { struc_t * sptr = va_arg(va, struc_t *); member_t * mptr = va_arg(va, member_t *); ret = proxy->deleting_struc_member(sptr, mptr); } break; case idb_event::renaming_struc_member: { struc_t * sptr = va_arg(va, struc_t *); member_t * mptr = va_arg(va, member_t *); const char * newname = va_arg(va, const char *); ret = proxy->renaming_struc_member(sptr, mptr, newname); } break; case idb_event::changing_struc_member: { struc_t * sptr = va_arg(va, struc_t *); member_t * mptr = va_arg(va, member_t *); flags_t flag = va_arg(va, flags_t); const opinfo_t * ti = va_arg(va, const opinfo_t *); asize_t nbytes = va_arg(va, asize_t); ret = proxy->changing_struc_member(sptr, mptr, flag, ti, nbytes); } break; case idb_event::removing_func_tail: { func_t * pfn = va_arg(va, func_t *); const area_t * tail = va_arg(va, const area_t *); ret = proxy->removing_func_tail(pfn, tail); } break; case idb_event::deleting_segm: { ea_t startEA = va_arg(va, ea_t); ret = proxy->deleting_segm(startEA); } break; case idb_event::changing_segm_start: { segment_t * s = va_arg(va, segment_t *); ea_t new_start = va_arg(va, ea_t); int segmod_flags = va_arg(va, int); ret = proxy->changing_segm_start(s, new_start, segmod_flags); } break; case idb_event::changing_segm_end: { segment_t * s = va_arg(va, segment_t *); ea_t new_end = va_arg(va, ea_t); int segmod_flags = va_arg(va, int); ret = proxy->changing_segm_end(s, new_end, segmod_flags); } break; case idb_event::changing_area_cmt: { areacb_t * cb = va_arg(va, areacb_t *); const area_t * a = va_arg(va, const area_t *); const char * cmt = va_arg(va, const char *); bool repeatable = bool(va_arg(va, int)); ret = proxy->changing_area_cmt(cb, a, cmt, repeatable); } break; case idb_event::changing_segm_name: { segment_t * s = va_arg(va, segment_t *); const char * oldname = va_arg(va, const char *); ret = proxy->changing_segm_name(s, oldname); } break; case idb_event::changing_segm_class: { segment_t * s = va_arg(va, segment_t *); ret = proxy->changing_segm_class(s); } break; case idb_event::segm_name_changed: { segment_t * s = va_arg(va, segment_t *); const char * name = va_arg(va, const char *); ret = proxy->segm_name_changed(s, name); } break; case idb_event::segm_class_changed: { segment_t * s = va_arg(va, segment_t *); const char * sclass = va_arg(va, const char *); ret = proxy->segm_class_changed(s, sclass); } break; case idb_event::destroyed_items: { ea_t ea1 = va_arg(va, ea_t); ea_t ea2 = va_arg(va, ea_t); bool will_disable_range = bool(va_arg(va, int)); ret = proxy->destroyed_items(ea1, ea2, will_disable_range); } break; case idb_event::changed_stkpnts: { func_t * pfn = va_arg(va, func_t *); ret = proxy->changed_stkpnts(pfn); } break; case idb_event::extra_cmt_changed: { ea_t ea = va_arg(va, ea_t); int line_idx = va_arg(va, int); const char * cmt = va_arg(va, const char *); ret = proxy->extra_cmt_changed(ea, line_idx, cmt); } break; case idb_event::changing_struc: { struc_t * sptr = va_arg(va, struc_t *); ret = proxy->changing_struc(sptr); } break; case idb_event::changed_struc: { struc_t * sptr = va_arg(va, struc_t *); ret = proxy->changed_struc(sptr); } break; case idb_event::local_types_changed: { ret = proxy->local_types_changed(); } break; case idb_event::segm_attrs_changed: { segment_t * s = va_arg(va, segment_t *); ret = proxy->segm_attrs_changed(s); } break; case idb_event::allsegs_moved: { segm_move_infos_t * info = va_arg(va, segm_move_infos_t *); ret = proxy->allsegs_moved(info); } break; } } catch (Swig::DirectorException &e) { msg("Exception in IDB Hook function: %s\n", e.getMessage()); PYW_GIL_CHECK_LOCKED_SCOPE(); if ( PyErr_Occurred() ) PyErr_Print(); } return 0; }
//---------------------------------------------------------------------- static int notify(processor_t::idp_notify msgid, ...) { // Various messages: va_list va; va_start(va, msgid); // A well behaving processor module should call invoke_callbacks() // in his notify() function. If this function returns 0, then // the processor module should process the notification itself // Otherwise the code should be returned to the caller: int code = invoke_callbacks(HT_IDP, msgid, va); if ( code ) return code; int retcode = 1; segment_t *sptr; static uchar first = 0; switch(msgid) { case processor_t::newseg: sptr = va_arg(va, segment_t *); sptr->defsr[rVds-ph.regFirstSreg] = find_selector(inf.start_cs); //sptr->sel; break; case processor_t::init: ovrtrans.create(ovrtrans_name); // it makes no harm to create it again default: break; case processor_t::oldfile: m.asect_top = (ushort)ovrtrans.altval(n_asect); m.ovrcallbeg = (ushort)ovrtrans.altval(n_ovrbeg); m.ovrcallend = (ushort)ovrtrans.altval(n_ovrend); if(ovrtrans.altval(n_asciiX)) ash.XlatAsciiOutput = macro11.XlatAsciiOutput = NULL; m.ovrtbl_base = (uint32)ovrtrans.altval(n_ovrbas); case processor_t::newfile: first = 1; break; case processor_t::loader: { pdp_ml_t **ml = va_arg(va, pdp_ml_t **); netnode **mn = va_arg(va, netnode **); if(ml && mn) { *ml = &m; *mn = &ovrtrans; retcode = 0; } } break; case processor_t::move_segm: // A segment is moved // Fix processor dependent address sensitive information // args: ea_t from - old segment address // segment_t - moved segment { ea_t from = va_arg(va, ea_t); segment_t *s = va_arg(va, segment_t *); ovrtrans.altshift(from, s->startEA, s->size()); // i'm not sure about this } break; } va_end(va); return(retcode); }
va_list lib_RawDoFmt(struct SysBase *SysBase, const char *fmt, va_list ap, void (*PutCh)(INT32, APTR), APTR PutChData) { char *p; int ch; unsigned long ul; int lflag; int pad0flag; int wflag; int width; int pflag; int precision; int total_chars; int chars_to_print; int pad_spaces; //if(fmt == NULL || ap == NULL || PutCh == NULL) return ap; if(fmt == NULL || PutCh == NULL) return ap; for (;;) { while ((ch = *fmt++) != '%') { if (ch == '\0') { PutCh(ch, PutChData); // report the \0 return ap; } PutCh(ch, PutChData); } lflag = 0; pad0flag = 0; wflag = 0; width = 0; pflag = 0; precision = 0; reswitch: switch (ch = *fmt++) { case '\0': PutCh(ch, PutChData); // report the \0 return ap; case '%': PutCh(ch, PutChData); // report one % character break; case 'l': lflag = 1; goto reswitch; case 'c': ch = va_arg(ap, int); PutCh(ch & 0xff, PutChData); break; case 's': p = va_arg(ap, char *); if(p == NULL) break; if(pflag == 0 && wflag == 0) { while ((ch = *p++) != '\0') PutCh(ch, PutChData); } else { char *q = p; total_chars = 0; chars_to_print = 0; pad_spaces = 0; //calculate string length while ((ch = *q++) != '\0') total_chars++; //count max chars to print if(pflag == 1) { chars_to_print = (precision < total_chars) ? precision : total_chars; } else { chars_to_print = total_chars; } //count spaces to pad if(wflag == 1) { pad_spaces = (width > chars_to_print) ? (width - chars_to_print) : 0; } else { pad_spaces = 0; } //print spaces while (pad_spaces-- > 0) PutCh(' ', PutChData); //print chars while ((ch = *p++) != '\0' && chars_to_print-- > 0) PutCh(ch, PutChData); } break; case 'd': ul = lflag ? va_arg(ap, long) : va_arg(ap, int); if ((long)ul < 0) { PutCh('-', PutChData); ul = -(long)ul; } lib_int_RawDoFmtNumber(ul, 10, PutCh, PutChData, pad0flag, width); break; case 'i': ul = lflag ? va_arg(ap, long) : va_arg(ap, int); if ((long)ul < 0) { PutCh('-', PutChData); ul = -(long)ul; } else { PutCh('+', PutChData); } lib_int_RawDoFmtNumber(ul, 10, PutCh, PutChData, pad0flag, width); break; case 'o': PutCh('0', PutChData); PutCh('o', PutChData); ul = va_arg(ap, UINT32); lib_int_RawDoFmtNumber(ul, 8, PutCh, PutChData, pad0flag, width); break; case 'O': ul = va_arg(ap, UINT32); lib_int_RawDoFmtNumber(ul, 8, PutCh, PutChData, pad0flag, width); break; case 'b': PutCh('0', PutChData); PutCh('b', PutChData); ul = va_arg(ap, UINT32); lib_int_RawDoFmtNumber(ul, 2, PutCh, PutChData, pad0flag, width); break; case 'B': ul = va_arg(ap, UINT32); lib_int_RawDoFmtNumber(ul, 2, PutCh, PutChData, pad0flag, width); break; case 'u': ul = va_arg(ap, UINT32); lib_int_RawDoFmtNumber(ul, 10, PutCh, PutChData, pad0flag, width); break; case 'p': PutCh('0', PutChData); PutCh('x', PutChData); ul = va_arg(ap, UINT32); lib_int_RawDoFmtNumber(ul, 16, PutCh, PutChData, 1, 8); break; case 'x': PutCh('0', PutChData); PutCh('x', PutChData); ul = va_arg(ap, UINT32); lib_int_RawDoFmtNumber(ul, 16, PutCh, PutChData, pad0flag, width); break; case 'X': ul = va_arg(ap, UINT32); lib_int_RawDoFmtNumber(ul, 16, PutCh, PutChData, pad0flag, width); break; case '0': if(pad0flag == 0 && wflag == 0 && pflag == 0) { pad0flag = 1; goto reswitch; } else { //fall through } case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': if(pflag == 0) { wflag = 1; if(width != 0) { width = width*10 + (ch - '0'); } else { width = ch - '0'; } } else { pflag = 1; if(precision != 0) { precision = precision*10 + (ch - '0'); } else { precision = ch - '0'; } } goto reswitch; case '.': pflag = 1; goto reswitch; case '*': if(wflag == 0) { wflag = 1; width = va_arg(ap, int); if(width < 0) width = -width; goto reswitch; } if(pflag == 1) { precision = va_arg(ap, int); if(precision < 0) precision = -precision; goto reswitch; } default: PutCh('%', PutChData); if (lflag) PutCh('l', PutChData); PutCh(ch, PutChData); }
static int host_id_func(char *buffer, size_t *buffer_size, va_list ap, void *cache_mdata) { res_state statp; u_long res_options; const int op_id = 1; char *str; void *addr; socklen_t len; int type; size_t desired_size, size; enum nss_lookup_type lookup_type; char *p; int res = NS_UNAVAIL; statp = __res_state(); res_options = statp->options & (RES_RECURSE | RES_DEFNAMES | RES_DNSRCH | RES_NOALIASES | RES_USE_INET6); lookup_type = (enum nss_lookup_type)cache_mdata; switch (lookup_type) { case nss_lt_name: str = va_arg(ap, char *); type = va_arg(ap, int); size = strlen(str); desired_size = sizeof(res_options) + sizeof(int) + sizeof(enum nss_lookup_type) + sizeof(int) + size + 1; if (desired_size > *buffer_size) { res = NS_RETURN; goto fin; } p = buffer; memcpy(p, &res_options, sizeof(res_options)); p += sizeof(res_options); memcpy(p, &op_id, sizeof(int)); p += sizeof(int); memcpy(p, &lookup_type, sizeof(enum nss_lookup_type)); p += sizeof(int); memcpy(p, &type, sizeof(int)); p += sizeof(int); memcpy(p, str, size + 1); res = NS_SUCCESS; break; case nss_lt_id: addr = va_arg(ap, void *); len = va_arg(ap, socklen_t); type = va_arg(ap, int); desired_size = sizeof(res_options) + sizeof(int) + sizeof(enum nss_lookup_type) + sizeof(int) + sizeof(socklen_t) + len; if (desired_size > *buffer_size) { res = NS_RETURN; goto fin; } p = buffer; memcpy(p, &res_options, sizeof(res_options)); p += sizeof(res_options); memcpy(p, &op_id, sizeof(int)); p += sizeof(int); memcpy(p, &lookup_type, sizeof(enum nss_lookup_type)); p += sizeof(int); memcpy(p, &type, sizeof(int)); p += sizeof(int); memcpy(p, &len, sizeof(socklen_t)); p += sizeof(socklen_t); memcpy(p, addr, len); res = NS_SUCCESS; break; default: /* should be unreachable */ return (NS_UNAVAIL); } fin: *buffer_size = desired_size; return (res); }
int open(const char *path, int oflags, ...) { struct filelist *list; FAR struct inode *inode; const char *relpath = NULL; #if defined(CONFIG_FILE_MODE) || !defined(CONFIG_DISABLE_MOUNTPOINT) mode_t mode = 0666; #endif int ret; int fd; /* Get the thread-specific file list */ list = sched_getfiles(); if (!list) { ret = EMFILE; goto errout; } #ifdef CONFIG_FILE_MODE # ifdef CONFIG_CPP_HAVE_WARNING # warning "File creation not implemented" # endif /* If the file is opened for creation, then get the mode bits */ if (oflags & (O_WRONLY|O_CREAT) != 0) { va_list ap; va_start(ap, oflags); mode = va_arg(ap, mode_t); va_end(ap); } #endif /* Get an inode for this file */ inode = inode_find(path, &relpath); if (!inode) { /* "O_CREAT is not set and the named file does not exist. Or, * a directory component in pathname does not exist or is a * dangling symbolic link." */ ret = ENOENT; goto errout; } /* Verify that the inode is valid and either a "normal" or a mountpoint. We * specifically exclude block drivers. */ if ((!INODE_IS_DRIVER(inode) && !INODE_IS_MOUNTPT(inode)) || !inode->u.i_ops) { ret = ENXIO; goto errout_with_inode; } /* Make sure that the inode supports the requested access */ ret = inode_checkflags(inode, oflags); if (ret < 0) { ret = -ret; goto errout_with_inode; } /* Associate the inode with a file structure */ fd = files_allocate(inode, oflags, 0, 0); if (fd < 0) { ret = EMFILE; goto errout_with_inode; } /* Perform the driver open operation. NOTE that the open method may * be called many times. The driver/mountpoint logic should handled this * becuase it may also be closed that many times. */ ret = OK; if (inode->u.i_ops->open) { #ifndef CONFIG_DISABLE_MOUNTPOINT if (INODE_IS_MOUNTPT(inode)) { ret = inode->u.i_mops->open((FAR struct file*)&list->fl_files[fd], relpath, oflags, mode); } else #endif { ret = inode->u.i_ops->open((FAR struct file*)&list->fl_files[fd]); } } if (ret < 0) { ret = -ret; goto errout_with_fd; } return fd; errout_with_fd: files_release(fd); errout_with_inode: inode_release(inode); errout: errno = ret; return ERROR; }
static int _TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap) { TIFFDirectory* td = &tif->tif_dir; int status = 1; uint32 v32; int i, v; double d; char* s; switch (tag) { case TIFFTAG_SUBFILETYPE: td->td_subfiletype = va_arg(ap, uint32); break; case TIFFTAG_IMAGEWIDTH: td->td_imagewidth = va_arg(ap, uint32); break; case TIFFTAG_IMAGELENGTH: td->td_imagelength = va_arg(ap, uint32); break; case TIFFTAG_BITSPERSAMPLE: td->td_bitspersample = (uint16) va_arg(ap, int); /* * If the data require post-decoding processing * to byte-swap samples, set it up here. Note * that since tags are required to be ordered, * compression code can override this behaviour * in the setup method if it wants to roll the * post decoding work in with its normal work. */ if (tif->tif_flags & TIFF_SWAB) { if (td->td_bitspersample == 16) tif->tif_postdecode = _TIFFSwab16BitData; else if (td->td_bitspersample == 32) tif->tif_postdecode = _TIFFSwab32BitData; else if (td->td_bitspersample == 64) tif->tif_postdecode = _TIFFSwab64BitData; } break; case TIFFTAG_COMPRESSION: v = va_arg(ap, int) & 0xffff; /* * If we're changing the compression scheme, * the notify the previous module so that it * can cleanup any state it's setup. */ if (TIFFFieldSet(tif, FIELD_COMPRESSION)) { if (td->td_compression == v) break; (*tif->tif_cleanup)(tif); tif->tif_flags &= ~TIFF_CODERSETUP; } /* * Setup new compression routine state. */ if ( ! tif->tif_mode == O_RDONLY ) { /* Handle removal of LZW compression */ if ( v == COMPRESSION_LZW ) { TIFFError(tif->tif_name, "LZW compression no longer supported due to Unisys patent enforcement"); v=COMPRESSION_NONE; } } if( (status = TIFFSetCompressionScheme(tif, v)) != 0 ) td->td_compression = v; break; case TIFFTAG_PHOTOMETRIC: td->td_photometric = (uint16) va_arg(ap, int); break; case TIFFTAG_THRESHHOLDING: td->td_threshholding = (uint16) va_arg(ap, int); break; case TIFFTAG_FILLORDER: v = va_arg(ap, int); if (v != FILLORDER_LSB2MSB && v != FILLORDER_MSB2LSB) goto badvalue; td->td_fillorder = (uint16) v; break; case TIFFTAG_DOCUMENTNAME: _TIFFsetString(&td->td_documentname, va_arg(ap, char*)); break; case TIFFTAG_ARTIST: _TIFFsetString(&td->td_artist, va_arg(ap, char*)); break; case TIFFTAG_DATETIME: _TIFFsetString(&td->td_datetime, va_arg(ap, char*)); break; case TIFFTAG_HOSTCOMPUTER: _TIFFsetString(&td->td_hostcomputer, va_arg(ap, char*)); break; case TIFFTAG_IMAGEDESCRIPTION: _TIFFsetString(&td->td_imagedescription, va_arg(ap, char*)); break; case TIFFTAG_MAKE: _TIFFsetString(&td->td_make, va_arg(ap, char*)); break; case TIFFTAG_MODEL: _TIFFsetString(&td->td_model, va_arg(ap, char*)); break; case TIFFTAG_SOFTWARE: _TIFFsetString(&td->td_software, va_arg(ap, char*)); break; case TIFFTAG_ORIENTATION: v = va_arg(ap, int); if (v < ORIENTATION_TOPLEFT || ORIENTATION_LEFTBOT < v) { TIFFWarning(tif->tif_name, "Bad value %ld for \"%s\" tag ignored", v, _TIFFFieldWithTag(tif, tag)->field_name); } else td->td_orientation = (uint16) v; break; case TIFFTAG_SAMPLESPERPIXEL: /* XXX should cross check -- e.g. if pallette, then 1 */ v = va_arg(ap, int); if (v == 0) goto badvalue; td->td_samplesperpixel = (uint16) v; break; case TIFFTAG_ROWSPERSTRIP: v32 = va_arg(ap, uint32); if (v32 == 0) goto badvalue32; td->td_rowsperstrip = v32; if (!TIFFFieldSet(tif, FIELD_TILEDIMENSIONS)) { td->td_tilelength = v32; td->td_tilewidth = td->td_imagewidth; } break; case TIFFTAG_MINSAMPLEVALUE: td->td_minsamplevalue = (uint16) va_arg(ap, int); break; case TIFFTAG_MAXSAMPLEVALUE: td->td_maxsamplevalue = (uint16) va_arg(ap, int); break; case TIFFTAG_SMINSAMPLEVALUE: td->td_sminsamplevalue = (double) va_arg(ap, dblparam_t); break; case TIFFTAG_SMAXSAMPLEVALUE: td->td_smaxsamplevalue = (double) va_arg(ap, dblparam_t); break; case TIFFTAG_XRESOLUTION: td->td_xresolution = (float) va_arg(ap, dblparam_t); break; case TIFFTAG_YRESOLUTION: td->td_yresolution = (float) va_arg(ap, dblparam_t); break; case TIFFTAG_PLANARCONFIG: v = va_arg(ap, int); if (v != PLANARCONFIG_CONTIG && v != PLANARCONFIG_SEPARATE) goto badvalue; td->td_planarconfig = (uint16) v; break; case TIFFTAG_PAGENAME: _TIFFsetString(&td->td_pagename, va_arg(ap, char*)); break; case TIFFTAG_XPOSITION: td->td_xposition = (float) va_arg(ap, dblparam_t); break; case TIFFTAG_YPOSITION: td->td_yposition = (float) va_arg(ap, dblparam_t); break; case TIFFTAG_RESOLUTIONUNIT: v = va_arg(ap, int); if (v < RESUNIT_NONE || RESUNIT_CENTIMETER < v) goto badvalue; td->td_resolutionunit = (uint16) v; break; case TIFFTAG_PAGENUMBER: td->td_pagenumber[0] = (uint16) va_arg(ap, int); td->td_pagenumber[1] = (uint16) va_arg(ap, int); break; case TIFFTAG_HALFTONEHINTS: td->td_halftonehints[0] = (uint16) va_arg(ap, int); td->td_halftonehints[1] = (uint16) va_arg(ap, int); break; case TIFFTAG_COLORMAP: v32 = (uint32)(1L<<td->td_bitspersample); _TIFFsetShortArray(&td->td_colormap[0], va_arg(ap, uint16*), v32); _TIFFsetShortArray(&td->td_colormap[1], va_arg(ap, uint16*), v32); _TIFFsetShortArray(&td->td_colormap[2], va_arg(ap, uint16*), v32); break; case TIFFTAG_EXTRASAMPLES: if (!setExtraSamples(td, ap, &v)) goto badvalue; break; case TIFFTAG_MATTEING: td->td_extrasamples = (uint16) (va_arg(ap, int) != 0); if (td->td_extrasamples) { uint16 sv = EXTRASAMPLE_ASSOCALPHA; _TIFFsetShortArray(&td->td_sampleinfo, &sv, 1); } break; case TIFFTAG_TILEWIDTH: v32 = va_arg(ap, uint32); if (v32 % 16) { if (tif->tif_mode != O_RDONLY) goto badvalue32; TIFFWarning(tif->tif_name, "Nonstandard tile width %d, convert file", v32); } td->td_tilewidth = v32; tif->tif_flags |= TIFF_ISTILED; break; case TIFFTAG_TILELENGTH: v32 = va_arg(ap, uint32); if (v32 % 16) { if (tif->tif_mode != O_RDONLY) goto badvalue32; TIFFWarning(tif->tif_name, "Nonstandard tile length %d, convert file", v32); } td->td_tilelength = v32; tif->tif_flags |= TIFF_ISTILED; break; case TIFFTAG_TILEDEPTH: v32 = va_arg(ap, uint32); if (v32 == 0) goto badvalue32; td->td_tiledepth = v32; break; case TIFFTAG_DATATYPE: v = va_arg(ap, int); switch (v) { case DATATYPE_VOID: v = SAMPLEFORMAT_VOID; break; case DATATYPE_INT: v = SAMPLEFORMAT_INT; break; case DATATYPE_UINT: v = SAMPLEFORMAT_UINT; break; case DATATYPE_IEEEFP: v = SAMPLEFORMAT_IEEEFP;break; default: goto badvalue; } td->td_sampleformat = (uint16) v; break; case TIFFTAG_SAMPLEFORMAT: v = va_arg(ap, int); if (v < SAMPLEFORMAT_UINT || SAMPLEFORMAT_VOID < v) goto badvalue; td->td_sampleformat = (uint16) v; break; case TIFFTAG_IMAGEDEPTH: td->td_imagedepth = va_arg(ap, uint32); break; case TIFFTAG_STONITS: d = va_arg(ap, dblparam_t); if (d <= 0.) goto badvaluedbl; td->td_stonits = d; break; /* Begin Pixar Tags */ case TIFFTAG_PIXAR_IMAGEFULLWIDTH: td->td_imagefullwidth = va_arg(ap, uint32); break; case TIFFTAG_PIXAR_IMAGEFULLLENGTH: td->td_imagefulllength = va_arg(ap, uint32); break; case TIFFTAG_PIXAR_TEXTUREFORMAT: _TIFFsetString(&td->td_textureformat, va_arg(ap, char*)); break; case TIFFTAG_PIXAR_WRAPMODES: _TIFFsetString(&td->td_wrapmodes, va_arg(ap, char*)); break; case TIFFTAG_PIXAR_FOVCOT: td->td_fovcot = (float) va_arg(ap, dblparam_t); break; case TIFFTAG_PIXAR_MATRIX_WORLDTOSCREEN: _TIFFsetFloatArray(&td->td_matrixWorldToScreen, va_arg(ap, float*), 16); break; case TIFFTAG_PIXAR_MATRIX_WORLDTOCAMERA: _TIFFsetFloatArray(&td->td_matrixWorldToCamera, va_arg(ap, float*), 16); break; /* End Pixar Tags */ #if SUBIFD_SUPPORT case TIFFTAG_SUBIFD: if ((tif->tif_flags & TIFF_INSUBIFD) == 0) { td->td_nsubifd = (uint16) va_arg(ap, int); _TIFFsetLongArray(&td->td_subifd, va_arg(ap, uint32*), (long) td->td_nsubifd); } else {
static void va_arg_fill( v_paramlst * plst, va_list va ) { int iArg; for( iArg = 0; iArg < plst->maxarg; ++iArg ) { switch( plst->arglst[ iArg ].id ) { case v_x_uint: plst->arglst[ iArg ].value.as_x_uint = va_arg( va, _x_uint ); break; case v_x_long: plst->arglst[ iArg ].value.as_x_long = va_arg( va, _x_long ); break; case v_x_ulong: plst->arglst[ iArg ].value.as_x_ulong = va_arg( va, _x_ulong ); break; case v_x_longlong: plst->arglst[ iArg ].value.as_x_longlong = va_arg( va, _x_longlong ); break; case v_x_ulonglong: plst->arglst[ iArg ].value.as_x_ulonglong = va_arg( va, _x_ulonglong ); break; case v_x_intmax_t: plst->arglst[ iArg ].value.as_x_intmax_t = va_arg( va, _x_intmax_t ); break; case v_x_uintmax_t: plst->arglst[ iArg ].value.as_x_uintmax_t = va_arg( va, _x_uintmax_t ); break; case v_x_size_t: plst->arglst[ iArg ].value.as_x_size_t = va_arg( va, _x_size_t ); break; case v_x_ptrdiff_t: plst->arglst[ iArg ].value.as_x_ptrdiff_t = va_arg( va, _x_ptrdiff_t ); break; case v_x_ptr: plst->arglst[ iArg ].value.as_x_ptr = va_arg( va, _x_ptr ); break; case v_x_str: plst->arglst[ iArg ].value.as_x_str = va_arg( va, _x_str ); break; case v_x_wstr: plst->arglst[ iArg ].value.as_x_wstr = va_arg( va, _x_wstr ); break; case v_x_intptr: plst->arglst[ iArg ].value.as_x_intptr = va_arg( va, _x_intptr ); break; case v_x_double: plst->arglst[ iArg ].value.as_x_double = va_arg( va, _x_double ); break; case v_x_long_dbl: plst->arglst[ iArg ].value.as_x_long_dbl = va_arg( va, _x_long_dbl ); break; default: plst->arglst[ iArg ].value.as_x_int = va_arg( va, _x_int ); break; } } }
Node *Node_cons(const char *format, ...) { const char *cur = format; va_list args; va_start (args, format); Node *root = NULL; Node *cur_node = NULL; assert_not(format, NULL); #define UP() { cur_node = cur_node->parent; if(cur_node == NULL) break; } for(; *cur != '\0'; cur++) { switch(*cur) { case '[': cur_node = Node_new_group(cur_node); if(root == NULL) { root = cur_node; } break; case 'n': { uint64_t number = va_arg(args, uint64_t); Node *n = Node_new_number(cur_node, number); assert_not(n,NULL); break; } case 'f': { double floating = va_arg(args, double); Node *n = Node_new_float(cur_node, floating); assert_not(n,NULL); break; } case 'b': { bstring blob = va_arg(args, bstring); check(blob != NULL, "NULL given for blob"); Node *n = Node_new_blob(cur_node, blob); assert_not(n,NULL); break; } case 's': { bstring string = va_arg(args, bstring); check(string != NULL, "NULL given for string"); Node *n = Node_new_string(cur_node, string); check(n != NULL, "Failed to create new string node"); break; } case ']': { UP(); break; } case '@': { const char *attr = va_arg(args, const char *); check(attr != NULL, "NULL given for attr"); Node_name(cur_node->child, bfromcstr(attr)); break; } case 'w': { const char *word = va_arg(args, const char *); check(word != NULL, "NULL given for word name"); Node_name(cur_node, bfromcstr(word)); UP(); break; } case 'G': { Node *group = va_arg(args, Node *); check(group != NULL, "NULL given for group to add"); LIST_ADD(Node, cur_node->child, group, sibling); break; } case ' ': case '\t': case '\n': { break; } default: { fail("invalid character in spec"); break; } } } assert(*cur == '\0'); assert(cur_node == NULL); va_end(args); return root; on_fail(return NULL); }
/* ** =================================================================== ** Method : Timer_DefConstruct ** Description : Constructor por defecto ** =================================================================== */ void Timer_DefConstruct(struct Timer * self,va_list *args){ Timer_Construct(self,va_arg(*args,ulong)); }
int vlc_plugin_set (module_t *module, module_config_t *item, int propid, ...) { va_list ap; int ret = 0; va_start (ap, propid); switch (propid) { case VLC_SUBMODULE_CREATE: { module_t **pp = va_arg (ap, module_t **); *pp = vlc_submodule_create (module); if (*pp == NULL) ret = -1; break; } case VLC_CONFIG_CREATE: { int type = va_arg (ap, int); module_config_t **pp = va_arg (ap, module_config_t **); *pp = vlc_config_create (module, type); if (*pp == NULL) ret = -1; break; } case VLC_MODULE_CPU_REQUIREMENT: assert (!module->b_submodule); module->i_cpu |= va_arg (ap, int); break; case VLC_MODULE_SHORTCUT: { unsigned i; for (i = 0; module->pp_shortcuts[i] != NULL; i++); if (i >= (MODULE_SHORTCUT_MAX - 1)) break; module->pp_shortcuts[i] = va_arg (ap, char *); break; } case VLC_MODULE_CAPABILITY: module->psz_capability = va_arg (ap, char *); break; case VLC_MODULE_SCORE: module->i_score = va_arg (ap, int); break; case VLC_MODULE_CB_OPEN: module->pf_activate = va_arg (ap, int (*) (vlc_object_t *)); break; case VLC_MODULE_CB_CLOSE: module->pf_deactivate = va_arg (ap, void (*) (vlc_object_t *)); break; case VLC_MODULE_NO_UNLOAD: module->b_unloadable = false; break; case VLC_MODULE_NAME: { const char *value = va_arg (ap, const char *); free( module->psz_object_name ); module->psz_object_name = strdup( value ); module->pp_shortcuts[0] = (char*)value; /* dooh! */ if (module->psz_longname == default_name) module->psz_longname = (char*)value; /* dooh! */ break; } case VLC_MODULE_SHORTNAME: { const char *domain = va_arg (ap, const char *); if (domain == NULL) domain = PACKAGE; module->psz_shortname = mdgettext (domain, va_arg (ap, char *)); break; } case VLC_MODULE_DESCRIPTION: { const char *domain = va_arg (ap, const char *); if (domain == NULL) domain = PACKAGE; module->psz_longname = mdgettext (domain, va_arg (ap, char *)); break; } case VLC_MODULE_HELP: { const char *domain = va_arg (ap, const char *); if (domain == NULL) domain = PACKAGE; module->psz_help = mdgettext (domain, va_arg (ap, char *)); break; } case VLC_CONFIG_NAME: { const char *name = va_arg (ap, const char *); vlc_callback_t cb = va_arg (ap, vlc_callback_t); assert (name != NULL); item->psz_name = strdup (name); item->pf_callback = cb; break; } case VLC_CONFIG_VALUE: { if (IsConfigIntegerType (item->i_type)) { item->orig.i = item->saved.i = item->value.i = va_arg (ap, int); } else if (IsConfigFloatType (item->i_type)) { item->orig.f = item->saved.f = item->value.f = va_arg (ap, double); }
void __mockart_expect_entrance(const char *file, int lineno, const char *fname, ...) { va_list args; GList *sched_list; sched_entry_t *sched_entry; GList *mock_args; mockart_arg_t *mock_arg; mockart_arg_type_t mock_arg_type; sched_list = g_hash_table_lookup(entrance_schedule_table, fname); sched_entry = malloc(sizeof(sched_entry_t)); sched_entry->file = file; sched_entry->lineno = lineno; mock_args = NULL; va_start(args, fname); for(;;) { mock_arg_type = va_arg(args, mockart_arg_type_t); if (mock_arg_type == 0) { break; } mock_arg = malloc(sizeof(mockart_arg_t)); mock_arg->type = mock_arg_type; switch(mock_arg_type) { case MOCK_ARG_SKIP: va_arg(args, void *); break; case MOCK_ARG_INT: mock_arg->u._int = va_arg(args, int); break; case MOCK_ARG_LONG: mock_arg->u._long = va_arg(args, long); break; case MOCK_ARG_STR: mock_arg->u._str = va_arg(args, const char *); break; case MOCK_ARG_PTR: mock_arg->u._ptr = va_arg(args, void *); break; default: fprintf(stderr, "mockart_assert_will_call: unimplemented type %d\n", mock_arg_type); exit(EXIT_FAILURE); } mock_args = g_list_append(mock_args, mock_arg); } sched_entry->mock_args = mock_args; sched_list = g_list_append(sched_list, sched_entry); g_hash_table_insert(entrance_schedule_table, (char *) fname, sched_list); va_end(args); }
/* We parse the argument list in Unicode */ U_CFUNC int32_t u_printf_parse(const u_printf_stream_handler *streamHandler, const UChar *fmt, void *context, u_localized_print_string *locStringContext, ULocaleBundle *formatBundle, int32_t *written, va_list ap) { uint16_t handlerNum; ufmt_args args; ufmt_type_info argType; u_printf_handler *handler; u_printf_spec spec; u_printf_spec_info *info = &(spec.fInfo); const UChar *alias = fmt; const UChar *backup; const UChar *lastAlias; /* iterate through the pattern */ while(!locStringContext || locStringContext->available > 0) { /* find the next '%' */ lastAlias = alias; while(*alias != UP_PERCENT && *alias != 0x0000) { alias++; } /* write any characters before the '%' */ if(alias > lastAlias) { *written += (streamHandler->write)(context, lastAlias, (int32_t)(alias - lastAlias)); } /* break if at end of string */ if(*alias == 0x0000) { break; } /* initialize spec to default values */ spec.fWidthPos = -1; spec.fPrecisionPos = -1; spec.fArgPos = -1; uprv_memset(info, 0, sizeof(*info)); info->fPrecision = -1; info->fWidth = -1; info->fPadChar = 0x0020; /* skip over the initial '%' */ alias++; /* Check for positional argument */ if(ISDIGIT(*alias)) { /* Save the current position */ backup = alias; /* handle positional parameters */ if(ISDIGIT(*alias)) { spec.fArgPos = (int) (*alias++ - DIGIT_ZERO); while(ISDIGIT(*alias)) { spec.fArgPos *= 10; spec.fArgPos += (int) (*alias++ - DIGIT_ZERO); } } /* if there is no '$', don't read anything */ if(*alias != SPEC_DOLLARSIGN) { spec.fArgPos = -1; alias = backup; } /* munge the '$' */ else alias++; } /* Get any format flags */ while(ISFLAG(*alias)) { switch(*alias++) { /* left justify */ case FLAG_MINUS: info->fLeft = TRUE; break; /* always show sign */ case FLAG_PLUS: info->fShowSign = TRUE; break; /* use space if no sign present */ case FLAG_SPACE: info->fShowSign = TRUE; info->fSpace = TRUE; break; /* use alternate form */ case FLAG_POUND: info->fAlt = TRUE; break; /* pad with leading zeroes */ case FLAG_ZERO: info->fZero = TRUE; info->fPadChar = 0x0030; break; /* pad character specified */ case FLAG_PAREN: /* TODO test that all four are numbers */ /* first four characters are hex values for pad char */ info->fPadChar = (UChar)ufmt_digitvalue(*alias++); info->fPadChar = (UChar)((info->fPadChar * 16) + ufmt_digitvalue(*alias++)); info->fPadChar = (UChar)((info->fPadChar * 16) + ufmt_digitvalue(*alias++)); info->fPadChar = (UChar)((info->fPadChar * 16) + ufmt_digitvalue(*alias++)); /* final character is ignored */ alias++; break; } } /* Get the width */ /* width is specified out of line */ if(*alias == SPEC_ASTERISK) { info->fWidth = -2; /* Skip the '*' */ alias++; /* Save the current position */ backup = alias; /* handle positional parameters */ if(ISDIGIT(*alias)) { spec.fWidthPos = (int) (*alias++ - DIGIT_ZERO); while(ISDIGIT(*alias)) { spec.fWidthPos *= 10; spec.fWidthPos += (int) (*alias++ - DIGIT_ZERO); } } /* if there is no '$', don't read anything */ if(*alias != SPEC_DOLLARSIGN) { spec.fWidthPos = -1; alias = backup; } /* munge the '$' */ else alias++; } /* read the width, if present */ else if(ISDIGIT(*alias)){ info->fWidth = (int) (*alias++ - DIGIT_ZERO); while(ISDIGIT(*alias)) { info->fWidth *= 10; info->fWidth += (int) (*alias++ - DIGIT_ZERO); } } /* Get the precision */ if(*alias == SPEC_PERIOD) { /* eat up the '.' */ alias++; /* precision is specified out of line */ if(*alias == SPEC_ASTERISK) { info->fPrecision = -2; /* Skip the '*' */ alias++; /* save the current position */ backup = alias; /* handle positional parameters */ if(ISDIGIT(*alias)) { spec.fPrecisionPos = (int) (*alias++ - DIGIT_ZERO); while(ISDIGIT(*alias)) { spec.fPrecisionPos *= 10; spec.fPrecisionPos += (int) (*alias++ - DIGIT_ZERO); } /* if there is no '$', don't read anything */ if(*alias != SPEC_DOLLARSIGN) { spec.fPrecisionPos = -1; alias = backup; } else { /* munge the '$' */ alias++; } } } /* read the precision */ else if(ISDIGIT(*alias)){ info->fPrecision = (int) (*alias++ - DIGIT_ZERO); while(ISDIGIT(*alias)) { info->fPrecision *= 10; info->fPrecision += (int) (*alias++ - DIGIT_ZERO); } } } /* Get any modifiers */ if(ISMOD(*alias)) { switch(*alias++) { /* short */ case MOD_H: info->fIsShort = TRUE; break; /* long or long long */ case MOD_LOWERL: if(*alias == MOD_LOWERL) { info->fIsLongLong = TRUE; /* skip over the next 'l' */ alias++; } else info->fIsLong = TRUE; break; /* long double */ case MOD_L: info->fIsLongDouble = TRUE; break; } } /* finally, get the specifier letter */ info->fSpec = *alias++; info->fOrigSpec = info->fSpec; /* fill in the precision and width, if specified out of line */ /* width specified out of line */ if(spec.fInfo.fWidth == -2) { if(spec.fWidthPos == -1) { /* read the width from the argument list */ info->fWidth = va_arg(ap, int32_t); } /* else handle positional parameter */ /* if it's negative, take the absolute value and set left alignment */ if(info->fWidth < 0) { info->fWidth *= -1; /* Make positive */ info->fLeft = TRUE; } } /* precision specified out of line */ if(info->fPrecision == -2) { if(spec.fPrecisionPos == -1) { /* read the precision from the argument list */ info->fPrecision = va_arg(ap, int32_t); } /* else handle positional parameter */ /* if it's negative, set it to zero */ if(info->fPrecision < 0) info->fPrecision = 0; } handlerNum = (uint16_t)(info->fSpec - UPRINTF_BASE_FMT_HANDLERS); if (handlerNum < UPRINTF_NUM_FMT_HANDLERS) { /* query the info function for argument information */ argType = g_u_printf_infos[ handlerNum ].info; switch(argType) { case ufmt_count: /* set the spec's width to the # of chars written */ info->fWidth = *written; /* fall through to set the pointer */ case ufmt_string: case ufmt_ustring: case ufmt_pointer: args.ptrValue = va_arg(ap, void*); break; case ufmt_char: case ufmt_uchar: case ufmt_int: if (info->fIsLongLong) { args.int64Value = va_arg(ap, int64_t); } else { args.int64Value = va_arg(ap, int32_t); } break; case ufmt_float: args.floatValue = (float) va_arg(ap, double); break; case ufmt_double: args.doubleValue = va_arg(ap, double); break; default: /* else args is ignored */ args.ptrValue = NULL; break; } /* call the handler function */ handler = g_u_printf_infos[ handlerNum ].handler; if(handler != 0) { *written += (*handler)(streamHandler, context, formatBundle, info, &args); } else { /* just echo unknown tags */ *written += (streamHandler->write)(context, fmt, (int32_t)(alias - lastAlias)); } } else {
stock_id = va_arg (args, const gchar *); label = va_arg (args, const gchar *); response = va_arg (args, gint); /* add a mixed button to the dialog */ button = xfce_gtk_button_new_mixed (stock_id, label); gtk_widget_set_can_default (button, TRUE); gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button, response); gtk_widget_show (button); } else if (strcmp (text, XFCE_BUTTON_TYPE_PIXBUF) == 0) { /* get arguments */ pixbuf = va_arg (args, GdkPixbuf *); label = va_arg (args, const gchar *); response = va_arg (args, gint); /* lookup real icons size for button icons */ gtk_icon_size_lookup (GTK_ICON_SIZE_BUTTON, &w, &h); /* scale the pixbuf if needed */ if (gdk_pixbuf_get_width (pixbuf) != w || gdk_pixbuf_get_height (pixbuf) != h) scaled = gdk_pixbuf_scale_simple (pixbuf, w, h, GDK_INTERP_BILINEAR); else scaled = NULL; image = gtk_image_new_from_pixbuf (scaled ? scaled : pixbuf); /* release scaled image */ if (scaled != NULL) g_object_unref (G_OBJECT (scaled));
EAPI const Eo_Event_Description _EV_CLICKED = EO_EVENT_DESCRIPTION("clicked"); typedef struct { Evas_Object *bt; } Widget_Data; #define MY_CLASS ELW_BUTTON_CLASS static void _position_set(Eo *obj, void *class_data EINA_UNUSED, va_list *list) { (void) obj; Evas_Coord x, y; x = va_arg(*list, Evas_Coord); y = va_arg(*list, Evas_Coord); printf("But set position %d,%d\n", x, y); eo_do_super(obj, MY_CLASS, exevas_obj_position_set(x, y)); } static void _text_set(Eo *obj EINA_UNUSED, void *class_data, va_list *list) { Widget_Data *wd = class_data; const char *text; text = va_arg(*list, const char *); elm_object_text_set(wd->bt, text); } static void