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
