/**
*
*
* @param input
* @param filename
*/
void do_ppt(FILE *input,char *filename) {
int itemsread=1;
int rectype;
long reclen;
unsigned char recbuf[8];
while(itemsread) {
itemsread = catdoc_read(recbuf, 1, 8, input);
/* fprintf(stderr,"itemsread=%d: ",itemsread); */
/* for(i=0; i<8; i++) */
/* fprintf(stderr,"%02x ",recbuf[i]); */
/* fprintf(stderr,"\n"); */
if (catdoc_eof(input)) {
process_item(DOCUMENT_END,0,input);
return;
}
if(itemsread < 8)
break;
rectype=getshort(recbuf,2);
reclen=getulong(recbuf,4);
if (reclen < 0) {
return;
}
process_item(rectype,reclen,input);
}
}
static bool match(UChar **items, int32_t *item_lengths, uint32_t item_count, UChar *needle, Match *match_results, int32_t *final_positions, int32_t needle_char_len, UChar *level1, UChar *level2, UChar *level3) {
Stack stack = {0};
int32_t i = 0, maxhl = 0;
int32_t r = 0, *positions = NULL;
MatchInfo *matches = NULL;
bool ok = FALSE;
MemoryItem ***memo = NULL;
int32_t needle_len = u_strlen(needle);
if (needle_len <= 0 || item_count <= 0) {
for (i = 0; i < (int32_t)item_count; i++) match_results[i].score = 0.0;
ok = TRUE;
goto end;
}
matches = (MatchInfo*)calloc(item_count, sizeof(MatchInfo));
positions = (int32_t*)calloc(2*needle_len, sizeof(int32_t)); // One set of positions is the final answer and one set is working space
if (matches == NULL || positions == NULL) {PyErr_NoMemory(); goto end;}
for (i = 0; i < (int32_t)item_count; i++) {
matches[i].haystack = items[i];
matches[i].haystack_len = item_lengths[i];
matches[i].needle = needle;
matches[i].needle_len = needle_len;
matches[i].max_score_per_char = (1.0 / matches[i].haystack_len + 1.0 / needle_len) / 2.0;
matches[i].level1 = level1;
matches[i].level2 = level2;
matches[i].level3 = level3;
maxhl = MAX(maxhl, matches[i].haystack_len);
}
if (maxhl <= 0) {
for (i = 0; i < (int32_t)item_count; i++) match_results[i].score = 0.0;
ok = TRUE;
goto end;
}
alloc_stack(&stack, needle_len, maxhl);
memo = alloc_memory(needle_len, maxhl);
if (stack.items == NULL || memo == NULL) {PyErr_NoMemory(); goto end;}
for (i = 0; i < (int32_t)item_count; i++) {
for (r = 0; r < needle_len; r++) {
positions[r] = -1;
}
stack_clear(&stack);
clear_memory(memo, needle_len, matches[i].haystack_len);
matches[i].memo = memo;
match_results[i].score = process_item(&matches[i], &stack, positions);
convert_positions(positions, final_positions + i, matches[i].haystack, needle_char_len, needle_len, match_results[i].score);
}
ok = TRUE;
end:
nullfree(positions);
nullfree(stack.items);
nullfree(matches);
nullfree(memo);
return ok;
}
void traverse_tree(tree *l)
{
if (l != NULL) {
traverse_tree(l->left);
process_item(l->item);
traverse_tree(l->right);
}
}
/*FALLTHRU*/
case 'k':
case 'K':
result *= 1024;
if (result < result_arg)
goto overflow;
endptr++; /* skip over the size character */
break;
default:
break; /* handled later */
}
if (*endptr != '\0')
goto badnumber;
(*item->item_size_target) = result;
return (ARG_SUCCESS);
badnumber:
log_message("%s: %s: not a number\n", CURRENT, item->item_name);
return (ARG_BAD);
overflow:
log_message("%s: %s: overflowed\n", CURRENT, item->item_name);
return (ARG_BAD);
}
static int
umem_log_process(const umem_env_item_t *item, const char *item_arg)
{
if (item_arg != NULL) {
int ret;
ret = item_size_process(item, item_arg);
if (ret != ARG_SUCCESS)
return (ret);
if (*item->item_size_target == 0)
return (ARG_SUCCESS);
} else
*item->item_size_target = 64*1024;
umem_logging = 1;
return (ARG_SUCCESS);
}
static int
umem_size_process(const umem_env_item_t *item, const char *item_arg)
{
const char *name = item->item_name;
void (*action_func)(size_t);
size_t result;
int ret;
if (strcmp(name, "size_clear") == 0) {
if (item_arg != NULL) {
log_message("%s: %s: does not take a value. ignored\n",
CURRENT, name);
return (ARG_BAD);
}
umem_alloc_sizes_clear();
return (ARG_SUCCESS);
} else if (strcmp(name, "size_add") == 0) {
action_func = umem_alloc_sizes_add;
} else if (strcmp(name, "size_remove") == 0) {
action_func = umem_alloc_sizes_remove;
} else {
log_message("%s: %s: internally unrecognized\n",
CURRENT, name, name, name);
return (ARG_BAD);
}
if (item_arg == NULL) {
log_message("%s: %s: requires a value. ignored\n",
CURRENT, name);
return (ARG_BAD);
}
ret = item_size_process(item, item_arg);
if (ret != ARG_SUCCESS)
return (ret);
result = *item->item_size_target;
action_func(result);
return (ARG_SUCCESS);
}
#ifndef UMEM_STANDALONE
static int
umem_backend_process(const umem_env_item_t *item, const char *item_arg)
{
const char *name = item->item_name;
if (item_arg == NULL)
goto fail;
if (strcmp(item_arg, "sbrk") == 0)
vmem_backend |= VMEM_BACKEND_SBRK;
else if (strcmp(item_arg, "mmap") == 0)
vmem_backend |= VMEM_BACKEND_MMAP;
else
goto fail;
return (ARG_SUCCESS);
fail:
log_message("%s: %s: must be %s=sbrk or %s=mmap\n",
CURRENT, name, name, name);
return (ARG_BAD);
}
#endif
static int
process_item(const umem_env_item_t *item, const char *item_arg)
{
int arg_required = 0;
arg_process_t *processor;
switch (item->item_type) {
case ITEM_FLAG:
case ITEM_CLEARFLAG:
case ITEM_OPTUINT:
case ITEM_OPTSIZE:
case ITEM_SPECIAL:
arg_required = 0;
break;
case ITEM_UINT:
case ITEM_SIZE:
arg_required = 1;
break;
}
switch (item->item_type) {
case ITEM_FLAG:
case ITEM_CLEARFLAG:
if (item_arg != NULL) {
log_message("%s: %s: does not take a value. ignored\n",
CURRENT, item->item_name);
return (1);
}
processor = NULL;
break;
case ITEM_UINT:
case ITEM_OPTUINT:
processor = item_uint_process;
break;
case ITEM_SIZE:
case ITEM_OPTSIZE:
processor = item_size_process;
break;
case ITEM_SPECIAL:
processor = item->item_special;
break;
default:
log_message("%s: %s: Invalid type. Ignored\n",
CURRENT, item->item_name);
return (1);
}
if (arg_required && item_arg == NULL) {
log_message("%s: %s: Required value missing\n",
CURRENT, item->item_name);
goto invalid;
}
if (item_arg != NULL || item->item_type == ITEM_SPECIAL) {
if (processor(item, item_arg) != ARG_SUCCESS)
goto invalid;
}
if (item->item_flag_target) {
if (item->item_type == ITEM_CLEARFLAG)
(*item->item_flag_target) &= ~item->item_flag_value;
else
(*item->item_flag_target) |= item->item_flag_value;
}
return (0);
invalid:
return (1);
}
#define ENV_SHORT_BYTES 10 /* bytes to print on error */
void
umem_process_value(umem_env_item_t *item_list, const char *beg, const char *end)
{
char buf[UMEM_ENV_ITEM_MAX];
char *argptr;
size_t count;
while (beg < end && isspace(*beg))
beg++;
while (beg < end && isspace(*(end - 1)))
end--;
if (beg >= end) {
log_message("%s: empty option\n", CURRENT);
return;
}
count = end - beg;
if (count + 1 > sizeof (buf)) {
char outbuf[ENV_SHORT_BYTES + 1];
/*
* Have to do this, since sprintf("%10s",...) calls malloc()
*/
(void) strncpy(outbuf, beg, ENV_SHORT_BYTES);
outbuf[ENV_SHORT_BYTES] = 0;
log_message("%s: argument \"%s...\" too long\n", CURRENT,
outbuf);
return;
}
(void) strncpy(buf, beg, count);
buf[count] = 0;
argptr = strchr(buf, '=');
if (argptr != NULL)
*argptr++ = 0;
for (; item_list->item_name != NULL; item_list++) {
if (strcmp(buf, item_list->item_name) == 0) {
(void) process_item(item_list, argptr);
return;
}
}
log_message("%s: '%s' not recognized\n", CURRENT, buf);
}
void
threaded_listener::thread_func(unsigned int index) {
boost::shared_ptr<queue_type> items_by_index = items_[index];
typedef queue_type::raw_items_type items_type;
items_type items;
while (items_by_index->pop_all(items)) {
for (items_type::iterator i = items.begin(), end = items.end(); i != end; ++i) {
process_item(*i);
}
}
}
void
my_get_selection_text(GtkClipboard *cb, const gchar *text, gpointer
data)
{
/* previous clipboard content */
static gchar *old_content = "";
static gint has_old_content = 0;
gchar *content;
gchar *converted;
begin_func("my_get_selection_text");
if (text == NULL) {
return_void();
}
if (g_utf8_collate(text, old_content) != 0 &&
!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menu_app_clip_ignore))) {
/* new data in clipboard */
/* store new content for future comparation */
content = g_strdup(text);
converted = from_utf8(content);
/* fprintf(stderr, ">>> %s\n", converted); */
g_free(converted);
if (has_old_content > 0)
g_free(old_content);
old_content = content;
has_old_content = 1;
/* process item */
process_item(content, 0, TRUE);
}
/* when clipboard is locked, set selection owener to myself */
if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menu_app_clip_ignore)) ||
gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menu_app_clip_lock))) {
if (gtk_selection_owner_set(dock_app,
clipboard,
GDK_CURRENT_TIME) == 0)
selected = NULL;
}
return_void();
}
void
process_items_from_list(GList * list_of_row_refs, gboolean skip_done)
{
GList * i;
Settings * user_settings;
GtkTreeIter iter;
int is_first = TRUE;
processing = TRUE;
keep_going = TRUE;
show_execute_button(FALSE);
user_settings = settings_get_from_gui();
i = list_of_row_refs;
while (i && keep_going)
{
GtkTreeRowReference * ref;
GtkTreePath * path;
ref = (GtkTreeRowReference *) i->data;
path = gtk_tree_row_reference_get_path(ref);
gtk_tree_model_get_iter(GTK_TREE_MODEL(list_store), &iter, path);
process_item(&iter, user_settings, skip_done, is_first);
while (gtk_events_pending())
gtk_main_iteration();
i = g_list_next(i);
is_first = FALSE;
}
processing = FALSE;
settings_delete_dem_and_mask(user_settings);
settings_delete(user_settings);
show_execute_button(TRUE);
g_list_foreach(list_of_row_refs, (GFunc)gtk_tree_row_reference_free, NULL);
g_list_free(list_of_row_refs);
}
static void
process_file_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
ProcessUserguideData *data;
GFileInfo *file_info;
GError *error = NULL;
GFile *file;
gboolean is_dir;
data = user_data;
file = G_FILE (object);
file_info = g_file_query_info_finish (file, result, &error);
if (error) {
tracker_miner_fs_file_notify (TRACKER_MINER_FS (data->miner), file, error);
process_userguide_data_free (data);
g_error_free (error);
return;
}
is_dir = g_file_info_get_file_type (file_info) == G_FILE_TYPE_DIRECTORY;
process_item (data, file_info, is_dir, &error);
tracker_miner_fs_file_notify (TRACKER_MINER_FS (data->miner), data->file, error);
process_userguide_data_free (data);
if (error) {
g_error_free (error);
}
if (file_info) {
g_object_unref (file_info);
}
}
static int config_log_transaction(request_rec *r, config_log_state *cls,
array_header *default_format)
{
log_format_item *items;
char *str, *s;
const char **strs;
int *strl;
request_rec *orig;
int i;
int len = 0;
array_header *format;
char *envar;
if (cls->fname == NULL) {
return DECLINED;
}
/*
* See if we've got any conditional envariable-controlled logging decisions
* to make.
*/
if (cls->condition_var != NULL) {
envar = cls->condition_var;
if (*envar != '!') {
if (ap_table_get(r->subprocess_env, envar) == NULL) {
return DECLINED;
}
}
else {
if (ap_table_get(r->subprocess_env, &envar[1]) != NULL) {
return DECLINED;
}
}
}
format = cls->format ? cls->format : default_format;
strs = ap_palloc(r->pool, sizeof(char *) * (format->nelts));
strl = ap_palloc(r->pool, sizeof(int) * (format->nelts));
items = (log_format_item *) format->elts;
orig = r;
while (orig->prev) {
orig = orig->prev;
}
while (r->next) {
r = r->next;
}
for (i = 0; i < format->nelts; ++i) {
strs[i] = process_item(r, orig, &items[i]);
}
for (i = 0; i < format->nelts; ++i) {
len += strl[i] = strlen(strs[i]);
}
#ifdef BUFFERED_LOGS
if (len + cls->outcnt > LOG_BUFSIZE) {
flush_log(cls);
}
if (len >= LOG_BUFSIZE) {
str = ap_palloc(r->pool, len + 1);
for (i = 0, s = str; i < format->nelts; ++i) {
memcpy(s, strs[i], strl[i]);
s += strl[i];
}
write(cls->log_fd, str, len);
}
else {
for (i = 0, s = &cls->outbuf[cls->outcnt]; i < format->nelts; ++i) {
memcpy(s, strs[i], strl[i]);
s += strl[i];
}
cls->outcnt += len;
}
#else
str = ap_palloc(r->pool, len + 1);
for (i = 0, s = str; i < format->nelts; ++i) {
memcpy(s, strs[i], strl[i]);
s += strl[i];
}
write(cls->log_fd, str, len);
#endif
return OK;
}
static int config_log_transaction(request_rec *r, config_log_state *cls,
apr_array_header_t *default_format)
{
log_format_item *items;
const char **strs;
int *strl;
request_rec *orig;
int i;
apr_size_t len = 0;
apr_array_header_t *format;
char *envar;
apr_status_t rv;
if (cls->fname == NULL) {
return DECLINED;
}
/*
* See if we've got any conditional envariable-controlled logging decisions
* to make.
*/
if (cls->condition_var != NULL) {
envar = cls->condition_var;
if (*envar != '!') {
if (apr_table_get(r->subprocess_env, envar) == NULL) {
return DECLINED;
}
}
else {
if (apr_table_get(r->subprocess_env, &envar[1]) != NULL) {
return DECLINED;
}
}
}
format = cls->format ? cls->format : default_format;
strs = apr_palloc(r->pool, sizeof(char *) * (format->nelts));
strl = apr_palloc(r->pool, sizeof(int) * (format->nelts));
items = (log_format_item *) format->elts;
orig = r;
while (orig->prev) {
orig = orig->prev;
}
while (r->next) {
r = r->next;
}
for (i = 0; i < format->nelts; ++i) {
strs[i] = process_item(r, orig, &items[i]);
}
for (i = 0; i < format->nelts; ++i) {
len += strl[i] = strlen(strs[i]);
}
if (!log_writer) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, APR_EGENERAL, r,
"log writer isn't correctly setup");
return HTTP_INTERNAL_SERVER_ERROR;
}
rv = log_writer(r, cls->log_writer, strs, strl, format->nelts, len);
/* xxx: do we return an error on log_writer? */
return OK;
}
void do_table(FILE *input,char *filename) {
long rectype;
long reclen,build_year=0,build_rel=0,offset=0;
int eof_flag=0;
int itemsread=1;
date_shift=25569.0; /* Windows 1900 date system */
CleanUpFormatIdxUsed();
while (itemsread) {
catdoc_read(rec,2,1,input);
biff_version=getshort(rec,0);
catdoc_read(rec,2,1,input);
reclen=getshort(rec,0);
if ( biff_version == 0x0809 || biff_version == 0x0409 ||
biff_version == 0x0209 || biff_version == 0x0009 ) {
if (reclen==8 || reclen==16) {
if (biff_version == 0x0809 ) {
itemsread=catdoc_read(rec,4,1,input);
if (itemsread == 0)
break;
build_year=getshort(rec+2,0);
build_rel=getshort(rec,0);
(void) build_rel;
if(build_year > 5 ) {
catdoc_read(rec,8,1,input);
biff_version=8;
offset=12;
}
else {
biff_version=7;
offset=4;
}
} else if (biff_version == 0x0209 ) {
biff_version=3;
offset=2;
} else if (biff_version == 0x0409 ) {
offset=2;
biff_version=4;
} else {
biff_version=2;
}
itemsread=catdoc_read(rec,reclen-offset,1,input);
break;
} else {
fprintf(stderr,"%s: Invalid BOF record\n",filename);
return;
}
} else {
itemsread=catdoc_read(rec,126,1,input);
}
}
if (catdoc_eof(input)) {
fprintf(stderr,"%s: No BOF record found\n",filename);
exit(1);
}
while(itemsread){
unsigned char buffer[2];
itemsread = catdoc_read(buffer, 2, 1, input);
if (catdoc_eof(input)) {
process_item(MSEOF,0,NULL);
return;
}
if(itemsread == 0)
break;
rectype=getshort(buffer,0);
itemsread = catdoc_read(buffer, 2, 1, input);
if(itemsread == 0)
break;
reclen=getshort(buffer,0);
if (reclen && reclen <MAX_MS_RECSIZE &&reclen >0){
itemsread = catdoc_read(rec, 1, reclen, input);
rec[reclen] = '\0';
}
if(eof_flag) {
if (rectype != BOF) {
break;
}
}
/* fprintf(stderr,"Rectype 0x%04X reclen=%d\n",rectype, reclen); */
process_item(rectype,reclen,rec);
if (rectype == MSEOF) {
eof_flag=1;
} else {
eof_flag=0;
}
}
return;
}
//--------------------------------------------------------------------------
//
// load file into the database.
//
void idaapi load_file(linput_t *li, ushort /*neflag*/, const char * /*fileformatname*/)
{
// int i;
aif_header_t hd;
if ( ph.id != PLFM_ARM )
set_processor_type("arm", SETPROC_ALL|SETPROC_FATAL);
lread(li,&hd,sizeof(hd));
mf = uchar(match_zero_code(hd) - 1);
if ( (hd.address_mode & 0xFF) != 32 )
{
if ( (hd.address_mode & 0xFF) != 0 )
loader_failure("26-bit modules are not supported");
msg("Old AIF format file...");
}
if ( hd.decompress_code != NOP )
loader_failure("Compressed modules are not supported");
if ( hd.self_reloc_code != NOP )
loader_failure("Self-relocating modules are not supported");
inf.baseaddr = 0;
int isexec = is_bl(hd.entry_point);
uint32 offset = sizeof(aif_header_t);
uint32 start = hd.image_base;
if ( isexec ) {
start += sizeof(aif_header_t);
hd.readonly_size -= sizeof(aif_header_t);
}
uint32 end = start + hd.readonly_size;
file2base(li, offset, start, end, FILEREG_PATCHABLE);
offset += hd.readonly_size;
create_section(1, start, end, NAME_CODE, CLASS_CODE);
if ( hd.readwrite_size != 0 ) {
start = (hd.address_mode & AIF_SEP_DATA) ? hd.data_base : end;
end = start + hd.readwrite_size;
file2base(li, offset, start, end, FILEREG_PATCHABLE);
offset += hd.readwrite_size;
create_section(2, start, end, NAME_DATA, CLASS_DATA);
}
if ( hd.zero_init_size != 0 ) {
start = end;
end = start + hd.zero_init_size;
create_section(3, start, end, NAME_BSS, CLASS_BSS);
}
create_filename_cmt();
if ( isexec )
hd.entry_point = hd.image_base
+ offsetof(aif_header_t,entry_point)
+ ((hd.entry_point & ~BLMASK) << 2)
+ 8;
inf.start_cs = 1;
inf.startIP = hd.entry_point;
inf.beginEA = hd.entry_point;
if ( hd.debug_size != 0 ) {
msg("Debugging information is present (%u bytes at file offset 0x%X)...\n",
hd.debug_size, offset);
uchar *di = qalloc_array<uchar>(size_t(hd.debug_size));
if ( di == NULL )
nomem("AIF debugging info");
qlseek(li,offset);
lread(li, di, size_t(hd.debug_size));
uchar *ptr = di;
uchar *end = di + size_t(hd.debug_size);
section_t *sect = NULL;
while ( ptr < end )
{
size_t len = process_item(ptr, end-ptr, sect);
if ( len == 0 )
{
warning("Corrupted debug info.");
break;
}
ptr += len;
}
qfree(di);
}
}
//--------------------------------------------------------------------------
// Process debugging information item and try to incorporate it into
// the database.
// NOTE: This function does not process all debugging information.
// It knows only about some types of debugingo.
static size_t process_item(uchar *di, size_t disize, section_t *sect)
{
uchar *const end = di + disize;
uint32 fw = *(uint32 *)di;
if ( mf )
fw = swap32(fw);
size_t len = fw >> 16;
if ( len == 0 || len > disize )
return 0;
switch ( fw & 0xFFFF )
{
case AIF_DEB_SECT: // section
if ( disize < sizeof(section_t) )
return 0;
sect = (section_t *)di;
if ( mf )
swap_section(sect);
if ( sect->debugsize != 0 )
len = sect->debugsize;
switch ( sect->lang )
{
case LANG_C:
add_long_cmt(sect->codestart,1,"C source level debugging data is present");
break;
case LANG_PASCAL:
add_long_cmt(sect->codestart,1,"Pascal source level debugging data is present");
break;
case LANG_FORTRAN:
add_long_cmt(sect->codestart,1,"Fortran-77 source level debugging data is present");
break;
case LANG_ASM:
add_long_cmt(sect->codestart,1,"ARM assembler line number data is present");
break;
}
if ( sect->lang == LANG_NONE )
{
size_t nsyms = size_t(sect->name);
dsym_t *ds = (dsym_t *)(sect+1);
char *str = (char *)(ds+nsyms);
if ( str >= (char *)end )
return 0;
bool use_pascal = swap_symbols(ds, str, end, nsyms);
for ( int i=0; i < nsyms; i++,ds++ )
{
if ( ds->sym & ASD_16BITSYM ) continue;
size_t off = size_t(ds->sym & ASD_SYMOFF);
char *name = str + off + use_pascal;
if ( name < str || name >= (char *)end )
continue;
if ( special_name(name) )
continue;
if ( ds->sym & ASD_ABSSYM ) // if the symbol is absolute
{
add_pgm_cmt("%s = 0x%X", name, ds->value);
}
else if ( isEnabled(ds->value) )
{
if ( ds->sym & ASD_GLOBSYM )
{
add_entry(ds->value, ds->value, name, is_true_text_symbol(ds, name));
}
else
{
do_name_anyway(ds->value, name);
if ( is_true_text_symbol(ds, name) )
auto_make_code(ds->value);
}
}
}
}
else
{
char name[64];
const uchar *nptr = (const uchar *)§->name;
size_t namelen = *nptr++;
namelen = qmin(namelen, sizeof(name) - 1);
namelen = qmin(namelen, end - nptr);
memcpy(name, nptr, namelen); //lint !e670
name[namelen] = '\0';
if ( sect->codestart != 0 )
add_long_cmt(sect->codestart,1,"Section \"%s\", size 0x%X",name,sect->codesize);
if ( sect->datastart != 0 )
add_long_cmt(sect->datastart,1,"Section \"%s\", size 0x%X",name,sect->datasize);
}
#if 0
if ( sect->fileinfo != 0 ) { // fileinfo is present?
process_item(di+size_t(sect->fileinfo),sect);
}
#endif
break;
case AIF_DEB_FDEF: // procedure/function definition
deb(IDA_DEBUG_LDR, "procedure/function definition\n");
break;
case AIF_DEB_ENDP: // endproc
deb(IDA_DEBUG_LDR, "endproc\n");
break;
case AIF_DEB_VAR: // variable
deb(IDA_DEBUG_LDR, "variable\n");
break;
case AIF_DEB_TYPE: // type
deb(IDA_DEBUG_LDR, "type\n");
break;
case AIF_DEB_STRU: // struct
deb(IDA_DEBUG_LDR, "struct\n");
break;
case AIF_DEB_ARRAY: // array
deb(IDA_DEBUG_LDR, "array\n");
break;
case AIF_DEB_RANGE: // subrange
deb(IDA_DEBUG_LDR, "subrange\n");
break;
case AIF_DEB_SET: // set
deb(IDA_DEBUG_LDR, "set\n");
break;
case AIF_DEB_FILE: // fileinfo
deb(IDA_DEBUG_LDR, "fileinfo\n");
break;
case AIF_DEB_CENUM: // contiguous enumeration
deb(IDA_DEBUG_LDR, "contiguous enumeration\n");
break;
case AIF_DEB_DENUM: // discontiguous enumeration
deb(IDA_DEBUG_LDR, "discontiguous enumeration\n");
break;
case AIF_DEB_FDCL: // procedure/function declaration
deb(IDA_DEBUG_LDR, "procedure/function declaration\n");
break;
case AIF_DEB_SCOPE: // begin naming scope
deb(IDA_DEBUG_LDR, "begin naming scope\n");
break;
case AIF_DEB_ENDS: // end naming scope
deb(IDA_DEBUG_LDR, "end naming scope\n");
break;
case AIF_DEB_BITF: // bitfield
deb(IDA_DEBUG_LDR, "bitfield\n");
break;
case AIF_DEB_MACRO: // macro definition
deb(IDA_DEBUG_LDR, "macro definition\n");
break;
case AIF_DEB_ENDM: // macro undefinition
deb(IDA_DEBUG_LDR, "macro undefinition\n");
break;
case AIF_DEB_CLASS: // class
deb(IDA_DEBUG_LDR, "class\n");
break;
case AIF_DEB_UNION: // union
deb(IDA_DEBUG_LDR, "union\n");
break;
case AIF_DEB_FPMAP: // FP map fragment
deb(IDA_DEBUG_LDR, "FP map fragment\n");
break;
default:
msg("unknown (0x%d.)!!!\n", fw & 0xFFFF);
break;
}
return len;
}
