void set_is_offset(bool x) {
if (x) {
GRN_DAT_DEBUG_THROW_IF(is_offset());
value_ |= IS_OFFSET_FLAG;
} else {
GRN_DAT_DEBUG_THROW_IF(!is_offset());
value_ &= ~IS_OFFSET_FLAG;
}
}
bool binspector_parser_t::is_field()
{
adobe::name_t named_field_identifier;
atom_base_type_t atom_type(atom_unknown_k);
adobe::array_t bit_count_expression;
adobe::array_t is_big_endian_expression;
bool named_field(is_named_field(named_field_identifier));
bool atom_field(!named_field &&
is_atom_field(atom_type,
bit_count_expression,
is_big_endian_expression));
if (!named_field && !atom_field)
return false;
adobe::name_t field_identifier;
require_identifier(field_identifier);
adobe::array_t field_size_expression;
field_size_t field_size_type(field_size_none_k);
adobe::array_t offset_expression;
adobe::array_t callback_expression;
bool shuffleable(false);
is_field_size(field_size_type, field_size_expression, shuffleable); // optional
is_offset(offset_expression); // optional
try
{
static const adobe::array_t empty_array_k;
adobe::dictionary_t parameters;
parameters[key_field_name].assign(field_identifier);
parameters[key_field_size_type].assign(field_size_type);
parameters[key_field_size_expression].assign(field_size_expression);
parameters[key_field_offset_expression].assign(offset_expression);
parameters[key_field_shuffle].assign(shuffleable);
// add the field to the current structure description
if (named_field)
{
parameters[key_field_type].assign(value_field_type_named);
parameters[key_named_type_name].assign(named_field_identifier);
}
else
{
parameters[key_field_type].assign(value_field_type_atom);
parameters[key_atom_base_type].assign(atom_type);
parameters[key_atom_bit_count_expression].assign(bit_count_expression);
parameters[key_atom_is_big_endian_expression].assign(is_big_endian_expression);
}
insert_parser_metadata(parameters);
add_field_proc_m(field_identifier, parameters);
}
catch (const std::exception& error)
{
putback();
throw adobe::stream_error_t(error, next_position());
}
return true;
}
GList *create_scheduled_tasks(int x, int y, int z){
int i, j, k, n, m;
GList *offsets_intersec = NULL;
GList *generated_offsets = NULL;
task *task_w_chosen_offset;
int *period;
GList *tasks_list = NULL;
tasks_list = g_list_append(tasks_list,
set_task( (1 + (rand() % x)) * y, 1 + (rand() % z), 0 ) );
task_w_chosen_offset = g_list_first(tasks_list)->data;
offsets_intersec = g_list_append(offsets_intersec, GINT_TO_POINTER(0));
while(offsets_intersec != NULL){
tasks_list = g_list_append(tasks_list,
set_task( (1 + (rand() % x)) * y, 1 + (rand() % z), 0) );
task *tasks_vet = (task*) malloc(g_list_length(tasks_list) * sizeof(task));
tasklist_to_taskvet(tasks_list, tasks_vet);
period = (int *) malloc (g_list_length(tasks_list) * sizeof(int));
get_tasklist_period(tasks_list, period);
allocate_gcds_matrix(g_list_length(tasks_list));
init_gcds_matrix(g_list_length(tasks_list), period);
for(j = 1; j < g_list_length(tasks_list); j++){
i = 0;
generated_offsets = NULL;
offsets_intersec = NULL;
for (n = min_Nij(i, j, tasks_vet[i].offset, tasks_vet[j]);
n <= max_Nij(i, j, tasks_vet[i].offset, tasks_vet[i]);
n++){
for(m = min_Mij(tasks_vet[i]);
m <= max_Mij(i,j,tasks_vet[j]);
m++){
generated_offsets = g_list_append(generated_offsets,
GINT_TO_POINTER(get_offset(tasks_vet[i].offset, n, m, i, j)));
}
}
offsets_intersec = generated_offsets;
offsets_intersec = (GList *)is_offset(offsets_intersec, j);
for(i = 1; i < j; i++){
generated_offsets = NULL;
for (n = min_Nij(i,j, tasks_vet[i].offset, tasks_vet[j]);
n <= max_Nij(i,j, tasks_vet[i].offset, tasks_vet[i]);
n++){
for(m = min_Mij(tasks_vet[i]);
m <= max_Mij(i,j,tasks_vet[j]);
m++){
generated_offsets = g_list_append(generated_offsets,
GINT_TO_POINTER(get_offset(tasks_vet[i].offset, n, m, i, j)));
}
}
offsets_intersec = get_list_intersec(offsets_intersec, generated_offsets);
offsets_intersec = (GList *) is_offset(offsets_intersec, j);
}
if(offsets_intersec != NULL){
k = rand() % g_list_length(offsets_intersec);
task_w_chosen_offset = g_list_last(tasks_list)->data;
task_w_chosen_offset->offset = GPOINTER_TO_INT(g_list_nth(offsets_intersec, k)->data);
g_list_last(tasks_list)->data = task_w_chosen_offset;
}
}
free(period);
free(tasks_vet);
free(gcds);
}
tasks_list = g_list_remove(tasks_list, g_list_last(tasks_list)->data);
return tasks_list;
}
unsigned long
print_makerentry(FILE *inptr,unsigned short byteorder,
struct ifd_entry *entry_ptr,unsigned long fileoffset_base,
struct image_summary *summary_entry,char *parent_name,
int indent,int make,int model)
{
int value_is_offset = 0;
unsigned long endoffset = 0UL;
int chpr = 0;
value_is_offset = is_offset(entry_ptr);
if(value_is_offset == 0)
value_is_offset = maker_value_is_offset(entry_ptr,make,model);
else
value_is_offset += maker_value_is_offset(entry_ptr,make,model);
if(PRINT_ENTRY)
print_makertaginfo(entry_ptr,parent_name,indent,make,model);
if((entry_ptr->value_type == 0) || (entry_ptr->value_type > DOUBLE))
{
if(PRINT_ENTRY)
chpr = printf("# INVALID MAKERNOTE ENTRY (%#lx)",entry_ptr->value);
endoffset = ftell(inptr);
}
else if(entry_ptr->count == 0)
{
if(PRINT_VALUE)
chpr = printf("EMPTY (%lu)",entry_ptr->value);
endoffset = ftell(inptr);
}
else if(value_is_offset)
{
if(value_is_offset > 0)
{
if(PRINT_BOTH_OFFSET)
chpr += printf("@%#lx=%lu",entry_ptr->value + fileoffset_base,
entry_ptr->value + fileoffset_base);
else if(PRINT_HEX_OFFSET)
chpr += printf("@%#lx",entry_ptr->value + fileoffset_base);
else if(PRINT_DEC_OFFSET)
chpr += printf("@%lu",entry_ptr->value + fileoffset_base);
if(fileoffset_base && (PRINT_ENTRY_RELOFFSET))
chpr += printf(" (%lu)",entry_ptr->value);
}
else if((value_is_offset < 0) && (PRINT_VALUE))
print_makervalue(entry_ptr,make,model,PREFIX);
/* Print "inline" in REPORT & LIST modes */
if(!(PRINT_VALUE_AT_OFFSET))
{
setcharsprinted(chpr);
chpr = 0;
endoffset = print_offset_makervalue(inptr,byteorder,
entry_ptr,fileoffset_base,
summary_entry,parent_name,
"@",indent + SUBINDENT,
make,model,0);
}
}
else if(PRINT_VALUE)
print_makervalue(entry_ptr,make,model,PREFIX);
chpr = newline(chpr);
return(endoffset);
}
