const string predefined::get_random_output(sentence* s) {
if (!freehal_base::is_configured()) {
return "";
} else if (t == 0) {
cout << "Error! predefined2012: tagger is undefined." << endl;
return "";
} else if (g == 0) {
cout << "Error! predefined2012: grammar is undefined." << endl;
return "";
}
{
if (is_verbose())
cout << "predefined2012: input: " << s->to_str() << endl;
}
string output;
if (s->get_mode() == QUESTION)
try_random_question(s->get_input(), output);
if (s->get_mode() == STATEMENT)
try_random_statement(s->get_input(), output);
{
if (is_verbose() && output.size() > 0)
cout << "predefined2012: random output: " << output << endl;
}
return output;
}
void parse_field_ids(DexFileFormat *dex, unsigned char *buf, int offset)
{
int i;
if (is_verbose() > 3)
printf("parse feild ids offset = %04x\n", offset + sizeof(DexHeader));
dex->field_id_item = malloc(sizeof(field_id_item) * dex->header->fieldIdsSize);
if (is_verbose() > 3)
printf("dex->header->fieldIdsSize = %d\n", dex->header->fieldIdsSize);
for (i = 0; i < dex->header->fieldIdsSize; i++) {
memcpy(&dex->field_id_item[i],
buf + i * sizeof(field_id_item) + offset,
sizeof(field_id_item));
if (is_verbose() > 3) {
printf(" field_id_item [%d], class_id = %d %s, type_id = %d %s, name_idx=%d %s\n",
i, dex->field_id_item[i].class_idx,
dex->string_data_item[
dex->type_id_item[
dex->field_id_item[i].class_idx].descriptor_idx].data,
dex->field_id_item[i].type_idx,
dex->string_data_item[
dex->type_id_item[
dex->field_id_item[i].type_idx].descriptor_idx].data,
dex->field_id_item[i].name_idx,
dex->string_data_item[dex->field_id_item[i].name_idx].data);
}
}
}
const string predefined::get_predefined_output(const string& input) {
if (!freehal_base::is_configured()) {
return "";
} else if (t == 0) {
cout << "Error! predefined2012: tagger is undefined." << endl;
return "";
} else if (g == 0) {
cout << "Error! predefined2012: grammar is undefined." << endl;
return "";
}
{
if (is_verbose())
cout << "predefined2012: input: " << input << endl;
}
string output;
try_greeting(input, output);
try_thanks(input, output);
{
if (is_verbose() && output.size() > 0)
cout << "predefined2012: predefined output: " << output << endl;
}
return output;
}
void parse_encoded_method(
DexFileFormat *dex,
unsigned char *buf, encoded_method *method )
{
int i = 0;
int offset = 0;
if ( is_verbose() > 3 ) {
printf("parse encoded method\n");
}
offset = method->code_off - sizeof(DexHeader);
memcpy( &method->code_item.registers_size, buf+offset, sizeof(ushort));
offset += sizeof(ushort);
memcpy( &method->code_item.ins_size, buf+offset, sizeof(ushort));
offset += sizeof(ushort);
memcpy( &method->code_item.outs_size, buf+offset, sizeof(ushort));
offset += sizeof(ushort);
memcpy( &method->code_item.tries_size, buf+offset, sizeof(ushort));
offset += sizeof(ushort);
memcpy( &method->code_item.debug_info_off, buf+offset, sizeof(uint));
offset += sizeof(uint);
memcpy( &method->code_item.insns_size, buf+offset, sizeof(uint));
offset += sizeof(uint);
if ( is_verbose() > 3 ) {
printf("registers_size = %d\n", method->code_item.registers_size );
printf("insns_size = %d\n", method->code_item.insns_size);
}
method->code_item.insns = malloc(sizeof(ushort) * method->code_item.insns_size);
memcpy( method->code_item.insns, buf+offset,
sizeof(ushort) * method->code_item.insns_size);
offset += sizeof(ushort) * method->code_item.insns_size;
}
void parse_proto_ids(DexFileFormat *dex, unsigned char *buf, int offset)
{
volatile int i = 0, j = 0;
int idx = 0;
if (is_verbose() > 3)
printf("parse proto ids offset = %04x\n", offset + sizeof(DexHeader));
dex->proto_id_item = malloc(
sizeof(proto_id_item) * dex->header->protoIdsSize);
dex->proto_type_list = malloc(
sizeof(type_list) * dex->header->protoIdsSize);
for (i = 0 ; i < dex->header->protoIdsSize; i++) {
memcpy(&dex->proto_id_item[i],
buf + i * sizeof(proto_id_item) + offset,
sizeof(proto_id_item));
memset(&dex->proto_type_list[i], 0, sizeof(type_list));
idx = dex->proto_id_item[i].return_type_idx;
if (is_verbose() > 3)
printf(" proto_id_item [%d], %s, type_id = %d %s, parameters_off = %08x\n", i,
dex->string_data_item[dex->proto_id_item[i].shorty_idx].data,
idx, get_type_item_name(dex, idx),
dex->proto_id_item[i].parameters_off);
if (dex->proto_id_item[i].parameters_off == 0)
continue;
if (is_verbose() > 3)
printf(" proto_typ_list[%d] offset %p ", i,
buf + dex->proto_id_item[i].parameters_off - sizeof(DexHeader));
memcpy(&dex->proto_type_list[i].size,
buf + dex->proto_id_item[i].parameters_off - sizeof(DexHeader),
sizeof(int));
if (is_verbose() > 3)
printf("proto_type_list[%d].size = %d\n", i,
dex->proto_type_list[i].size);
if (dex->proto_type_list[i].size > 0) {
dex->proto_type_list[i].type_item = (type_item *)
malloc(sizeof(type_item) * dex->proto_type_list[i].size);
for (j = 0 ; j < dex->proto_type_list[i].size ; j++) {
memset(&dex->proto_type_list[i].type_item[j], 0, sizeof(type_item));
type_item *item = &dex->proto_type_list[i].type_item[j];
memcpy(item,
buf
+ dex->proto_id_item[i].parameters_off
- sizeof(DexHeader)
+ 4
+ (sizeof(type_item) * j),
sizeof(type_item));
if (is_verbose() > 3)
printf("item[%d], type_idx = %d, type = %s\n",
j, item->type_idx,
get_type_item_name(dex, item->type_idx));
}
}
}
}
void parse_method_ids(DexFileFormat *dex, unsigned char *buf, int offset) {
int i = 0;
printf("parse method ids offset = %04x\n", offset + sizeof(DexHeader) );
dex->method_id_item= malloc(
sizeof( method_id_item) * dex->header.methodIdsSize );
for ( i = 0 ; i < dex->header.methodIdsSize ; i++ ) {
memcpy ( &dex->method_id_item[i],
buf + i*sizeof(method_id_item) + offset,
sizeof(method_id_item) );
if ( is_verbose() > 3 ) {
printf(" method[%d], cls_id = %d, proto_id = %d, name_id = %d, %s\n",
i,
dex->method_id_item[i].class_idx,
dex->method_id_item[i].proto_idx,
dex->method_id_item[i].name_idx,
dex->string_data_item[dex->method_id_item[i].name_idx].data
);
}
//printf("stinrg data offset[%d] = 0x%04x\n", i,
// dex->string_ids[i].string_data_off);
}
}
void parse_class_defs(DexFileFormat *dex, unsigned char *buf, int offset) {
int i = 0;
printf("parse class defs offset = %04x\n", offset + sizeof(DexHeader) );
if ( dex->header.classDefsSize <= 0 ) {
return ;
}
dex->class_def_item = malloc(
sizeof( class_def_item ) * dex->header.classDefsSize);
dex->class_data_item= malloc(
sizeof( class_data_item ) * dex->header.classDefsSize);
for ( i = 0 ; i < dex->header.classDefsSize; i++ ) {
memcpy ( &dex->class_def_item[i],
buf + i*sizeof(class_def_item) + offset,
sizeof(class_def_item) );
if ( is_verbose() > 3 ) {
printf(" class_defs[%d], cls_id = %d, data_off = 0x%04x, source_file_idx = %d\n",
i,
dex->class_def_item[i].class_idx,
dex->class_def_item[i].class_data_off,
dex->class_def_item[i].source_file_idx);
}
parse_class_data_item( dex, buf,
dex->class_def_item[i].class_data_off - sizeof(DexHeader), i ) ;
}
}
int java_lang_string_builder_to_string( DexFileFormat *dex, simple_dalvik_vm *vm, char*type )
{
invoke_parameters *p = &vm->p;
if ( is_verbose() ) {
printf("call java.lang.StringBuilder.toString\n");
}
use_buf = 1;
return 0;
}
void parse_type_ids(DexFileFormat *dex, unsigned char *buf, int offset)
{
int i = 0;
if (is_verbose() > 3)
printf("parse type ids offset = %04x\n", offset + sizeof(DexHeader));
dex->type_id_item = malloc(
sizeof(type_id_item) * dex->header->typeIdsSize);
for (i = 0; i < dex->header->typeIdsSize; i++) {
memcpy(&dex->type_id_item[i],
buf + i * sizeof(type_id_item) + offset,
sizeof(type_id_item));
if (is_verbose() > 3)
printf(" type_ids [%d], = %s\n", i,
dex->string_data_item[
dex->type_id_item[i].descriptor_idx].data);
}
}
//java.lang.StringBuilder.<init>
int java_lang_string_builder_init( DexFileFormat *dex, simple_dalvik_vm *vm, char*type )
{
invoke_parameters *p = &vm->p;
if ( is_verbose() ) {
printf("call java.lang.StringBuilder.<init>\n");
}
memset(buf,0,1024);
buf_ptr = 0;
return 0;
}
const t_renderer_plugin* renderer_2bit_creator ( void )
{
if ( is_verbose() )
{
fprintf(stderr,"[%s] renderer_2bit_creator: create renderer.\n",MODULE_NAME);
}
this_plugin.done = done;
this_plugin.generate = generate;
this_plugin.init = init_font_definition;
return &this_plugin;
}
/* Initialize the passed font definition \c fnt for the implemented renderer.
* The metrics of the generated glyphs is passed in \c metrics. Here we have to
* prepare the rendering of the glyph bitmaps into the final matrix bitmaps.
*/
static bool init_font_definition ( t_font_definition *fnt, const t_font_metrics *metrics, int from, int to )
{
int sz;
if ( !fnt || !metrics || from<0 || to<0 )
{
fprintf(stderr,"[%s] error: init_font_definition: illegal parameters\n",MODULE_NAME);
return false;
}
if ( is_verbose() )
fprintf(stderr,"[%s] init_font_definition: called\n",MODULE_NAME);
/* Remember the font metrics and save the range as start character and
* number of characters.
*/
fnt->metrics = metrics;
fnt->first = from;
fnt->num = to-from+1;
if ( fnt->num <= 0 )
{
fprintf(stderr,"[%s] error: init_font_definition: invalid number of entries (%d)\n",MODULE_NAME,fnt->num);
return false;
}
/* fill the renderer related values
*/
strncpy(fnt->renderer,MODULE_NAME,MAXNAME); fnt->renderer[MAXNAME]='\0';
fnt->matrix_width = 2*(metrics->matrix.width);
fnt->matrix_height = metrics->matrix.height;
/* calculate the number of bytes used to store a row inside the buffer.
*/
fnt->matrix_pitch = fnt->matrix_width/8;
if ( fnt->matrix_width%8 )
fnt->matrix_pitch++;
fnt->matrix_size = fnt->matrix_pitch * fnt->matrix_height;
// allocate buffer for all data bytes of the final matrices
sz = (fnt->matrix_size)*(fnt->num)*sizeof(uint8_t);
fnt->buffer = malloc(sz);
if ( !fnt->buffer )
{
fprintf(stderr,"[%s] error: init_font_definition: buffer allocation failed (%d)\n",MODULE_NAME,sz);
return false;
}
memset(fnt->buffer,0,sz);
#ifdef DEBUG
fprintf(stderr,"[%s] init_font_definition: width %d needs %d bytes. buffer-size=%d num=%d alloc=%d\n",MODULE_NAME,
metrics->matrix.width,fnt->matrix_pitch,fnt->matrix_size,fnt->num,sz);
#endif
return true;
}
//---------------------------------------------------------------------------
// 6. Initialize node activity and setup starter flag if needed
void
NaPNTeacher::initialize (bool& starter)
{
starter = false;
iUpdateCounter = 0;
// Assign parameters
*(NaStdBackPropParams*)bpe = lpar;
//qprop: *(NaQuickPropParams*)bpe = lpar;
if(is_verbose())
bpe->SetDebugLevel(2);
}
int invoke_java_lang_library(
DexFileFormat *dex, simple_dalvik_vm *vm,
char *cls_name, char *method_name, char *type )
{
java_lang_method *method = find_java_lang_method(cls_name,method_name);
if ( method != 0 ) {
if ( is_verbose() ) {
printf("invoke %s/%s %s\n",method->clzname,method->methodname,type);
}
method->method_runtime( dex, vm, type );
return 1;
}
return 0;
}
static void new_node(struct process *process, enum action_type type, const struct hash *data)
{
struct parents *parents = &process->parents;
// If there are no parents, skip node generation entirely. This should
// happen only from the initial action_execve call in waitless.c.
if (!parents->n)
return;
char buffer[SHOW_HASH_SIZE*parents->n + 3 + SHOW_HASH_SIZE + 1 + SHOW_NODE_SIZE];
char *p = buffer;
if (is_verbose()) {
p += snprintf(p, sizeof(buffer), "%d: ", getpid());
int i;
for (i = 0; i < parents->n; i++) {
p = show_hash(p, 8, parents->p+i);
*p++ = ' ';
}
p = stpcpy(p, "-> ");
}
// The new node's name is the hash of its parents' names.
// We store the new node's name as parents[0] since it will be
// the first parent of the following node.
subgraph_node_name(parents->p, parents->p, parents->n);
parents->n = 1;
subgraph_new_node(parents->p, type, data);
if (is_verbose()) {
p = show_hash(p, 8, parents->p+0);
p = stpcpy(p, ": ");
p = show_subgraph_node(p, type, data);
*p++ = '\n';
*p = 0;
write_str(STDERR_FILENO, buffer);
}
}
int java_lang_string_builder_append( DexFileFormat *dex, simple_dalvik_vm *vm, char*type )
{
invoke_parameters *p = &vm->p;
int string_id = 0;
if ( is_verbose() ) {
printf("call java.lang.StringBuilder.append\n");
}
load_reg_to(vm, p->reg_idx[1], (unsigned char*)&string_id);
if ( type != 0 ){
//printf("type = %s\n", type );
if ( strcmp(type, "Ljava/lang/String;") == 0 ) {
buf_ptr += snprintf( buf + buf_ptr, 1024,"%s", get_string_data(dex, string_id));
} else if ( strcmp(type,"I") == 0 ) {
buf_ptr += snprintf( buf + buf_ptr, 1024,"%d", string_id);
}
}
return 0;
}
int java_io_print_stream_println( DexFileFormat *dex, simple_dalvik_vm *vm, char*type )
{
invoke_parameters *p = &vm->p;
int i = 0;
int string_id = 0;
if ( is_verbose() ) {
printf("call java.io.PrintStream.println\n");
}
load_reg_to(vm, p->reg_idx[1], (unsigned char*)&string_id);
if ( use_buf == 1 ) {
printf("%s\n", buf);
use_buf = 0;
memset(buf,0,1024);
buf_ptr = 0;
} else {
printf("%s\n", get_string_data(dex, string_id));
}
return 0;
}
int main(int argc, char **argv)
{
memory_t *mem;
FILE *fin;
FILE *fout;
int verbose;
int limit;
if (argc < 3)
{
fprintf(stderr, "%s", USAGE);
exit(1);
}
verbose = is_verbose(argc, argv);
limit = step_limit(argc, argv);
if (!strcmp(argv[1], "emulate"))
{
fin = fopen(argv[2], "r");
mem = read_machine_code(fin, verbose);
emulate(mem, verbose, limit);
free_mem(mem);
fclose(fin);
}
else if (!strcmp(argv[1], "assemble"))
{
if (argc < 4)
{
fprintf(stderr, "Not enough arguments to assemble\n");
exit(1);
}
fin = fopen(argv[2], "r");
fout = fopen(argv[3], "w");
assemble(fin, fout, verbose);
fclose(fout);
fclose(fin);
}
else
{
printf("Unknown command %s\n", argv[1]);
}
return 0;
}
void
sighandler(int sig)
{
LOG L = new_logger("syslog");
switch(sig) {
case SIGHUP:
logger(L, "Received SIGHUP signal; reloading config.");
conf_reload(C);
break;
case SIGINT:
case SIGTERM:
errno = 0;
logger(L, "Shutting down [TERM].");
VERBOSE(is_verbose(C), "Stopping %s[pid=%d]", program_name, getpid());
exit(EXIT_SUCCESS);
break;
default:
break;
}
}
void SaveManager::save_loop () {
auto & server=Server::Get();
if (
lock.Execute([&] () mutable {
if (paused) return true;
save();
return false;
}) &&
is_verbose()
) server.WriteLog(
save_paused,
Service::LogType::Debug
);
try {
server.Pool().Enqueue(
frequency,
[this] () mutable { save_loop(); }
);
} catch (...) {
try {
server.Panic(std::current_exception());
} catch (...) { }
throw;
}
}
bool qbs_command::execute()
{
const auto& rcbdds = env->store<rcbdd>();
auto& circuits = env->store<circuit>();
if ( circuits.empty() || is_set( "new" ) )
{
circuits.extend();
}
const auto settings = make_settings();
auto esopmin_settings = std::make_shared<properties>();
esopmin_settings->set( "verbose", is_verbose() );
settings->set( "esopmin", esop_minimizer ? dd_based_exorcism_minimization_func( esopmin_settings ) : dd_based_esop_minimization_func( esopmin_settings ) );
qmdd_synthesis( circuits.current(), rcbdds.current(), settings, statistics );
std::cout << boost::format( "[i] run-time: %.2f secs" ) % statistics->get<double>( "runtime" ) << std::endl;
return true;
}
void SaveManager::save () {
auto & server=Server::Get();
try {
Timer timer(Timer::CreateAndStart());
for (auto & callback : callbacks) callback();
auto elapsed=timer.ElapsedNanoseconds();
this->elapsed+=elapsed;
++count;
if (is_verbose()) server.WriteLog(
String::Format(
save_complete,
elapsed,
frequency
),
Service::LogType::Debug
);
} catch (...) {
try {
server.Panic(std::current_exception());
} catch (...) { }
throw;
}
}
/*
*
* NOTE: an empty glyph matrix leads to a size (\c sz_buffer in \c gmatrices)
* of 0 and a buffer pointer (\c buffer in \c gmatrices) of NULL!
*
* @param fnt
* @param gmatrices the array with all glyph data and the (reduced) glyph matrix
*/
static bool generate ( t_font_definition *fnt, const t_glyph_matrix *gmatrices )
{
int offs; // offset into fnt->buffer
int idx; // index into gmatrices[]
uint8_t bit; // bitmask
int byte; // byte within row
uint8_t mbit; // bitmask for matrix
int mbyte; // byte within matrix row
int gx, gy; // pixel coordinates inside the glyph
int mx, my; // pixel coordinates inside the output matrix
if ( !fnt || !gmatrices )
{
fprintf(stderr,"[%s] error: generate: illegal parameters\n",MODULE_NAME);
return false;
}
if ( is_verbose() )
fprintf(stderr,"[%s] generate: called\n",MODULE_NAME);
for ( idx=0; idx<(fnt->num-1); idx++ )
{
if ( gmatrices[idx].buffer )
{
// render gmatrices[idx] into fnt->buffer[offs]
mx = gmatrices[idx].offset_x;
my = gmatrices[idx].offset_y;
#ifdef DEBUG
fprintf(stderr,"[%s] generate: #%d offs=%d/%d glyph=%d/%d base=%d\n",MODULE_NAME,
idx,mx,my,
gmatrices[idx].width,gmatrices[idx].height,
fnt->metrics->baseline);
#endif
for ( gy=0; gy<gmatrices[idx].height; gy++ )
{
for ( gx=0; gx<gmatrices[idx].width; gx++ )
{
byte = gx / 8;
bit = 0x80 >> (gx&7);
#ifdef DEBUG_OFF
if ( (gmatrices[idx].buffer[gy*gmatrices[idx].pitch+byte]&bit) )
printf("*");
else
printf(".");
#endif
if ( (gmatrices[idx].buffer[gy*gmatrices[idx].pitch+byte]&bit) )
{
// set the pixel[mx+gx|my+gy] inside the matrix and leave
// pixel[mx+gx+1|my+gy] untouched.
mbyte = ((mx+gx)*2) / 8;
mbit = 0x80 >> (((mx+gx)*2)&7);
offs = ((fnt->matrix_pitch)*(my+gy)+mbyte);
if ( offs >= fnt->matrix_size )
{
#ifdef DEBUG
fprintf(stderr,"[%s] fatal: generate: #%d access out of buffer for pixel[%d|%d] (absolute %d|%d)! (%d > %d)\n",
MODULE_NAME,idx,gx,gy,(mx+gx)*2,(my+gy),offs,fnt->matrix_size);
#else
fprintf(stderr,"[%s] fatal: generate: #%d access out of buffer for pixel[%d|%d]!\n",
MODULE_NAME,idx,gx,gy);
#endif
return false;
}
offs += (fnt->matrix_size) * idx;
fnt->buffer[offs] |= mbit;
}
}
#ifdef DEBUG_OFF
printf("\n");
#endif
}
#ifdef DEBUG_OFF
for ( my=0; my<(fnt->metrics->matrix.height); my++ )
{
for ( mx=0; mx<(fnt->metrics->matrix.width); mx++ )
{
offs = (fnt->matrix_size) * idx;
mbyte = mx / 8;
mbit = 0x80 >> (mx&7);
offs += (mpitch*(my)+mbyte);
if ( fnt->buffer[offs]&mbit )
printf("*");
else
printf(".");
}
printf("\n");
}
#endif
}
//---------------------------------------------------------------------------
// 8. True action of the node (if activate returned true)
void
NaPNTeacher::action ()
{
unsigned iLayer;
unsigned iInpLayer = pnn->get_nn_unit()->InputLayer();
// Take neural network state at the time it's feed forward calculation
NaNNUnit pastNN;
pnn->pop_nn(pastNN);
if(is_verbose()){
int i;
NaPrintLog("NaPNTeacher (%p, %s[%s]):\n NN input: ",
this, name(), pastNN.GetInstance());
for(i = 0; i < pastNN.Xinp0.dim(); ++i)
NaPrintLog(" %g", pastNN.Xinp0[i]);
if(errout.links() == 0){
NaPrintLog("\n NN target: ");
for(i = 0; i < desout.data().dim(); ++i)
NaPrintLog(" %g", desout.data()[i]);
}else{
NaPrintLog("\n NN error: ");
for(i = 0; i < errout.data().dim(); ++i)
NaPrintLog(" %g", errout.data()[i]);
}
NaPrintLog("\n");
}
if(bLearn){
// Let's calculate delta weight from the past NN
bpe->AttachNN(&pastNN);
// One more activations since last update
++nLastUpdate;
for(iLayer = pastNN.OutputLayer();
(int)iLayer >= (int)iInpLayer; --iLayer){
if(pastNN.OutputLayer() == iLayer){
// Output layer
if(errout.links() == 0){
// Input pack #1
// Doesn't really need nnout due to it's stored inside NN
bpe->DeltaRule(&desout.data()[0]);
}else{
// Input pack #2
bpe->DeltaRule(&errout.data()[0], true);
}
}else{
// Hidden layer
bpe->DeltaRule(iLayer, iLayer + 1);
}
}// backward step
// Compute error on input
if(errinp.links() > 0){
unsigned iInput;
NaVector &einp = errinp.data();
einp.init_zero();
for(iInput = 0; iInput < einp.dim(); ++iInput){
// Or may be += ??? I didn't recognize the difference...
einp[iInput] -= bpe->PartOfDeltaRule(iInpLayer, iInput);
}
}
// Now let's forget the past NN state since changes should be
// applied to the current neural net anyway
bpe->DetachNN();
// Autoupdate facility
if(0 != nAutoUpdateFreq && nLastUpdate >= nAutoUpdateFreq){
NaPrintLog("%s: Automatic update #%d of NN '%s' (%d sample)\n",
name(), iUpdateCounter,
bpe->nn().GetInstance()? bpe->nn().GetInstance(): "",
activations());
update_nn();
// Call procedure
if(NULL != auProc)
(*auProc)(iUpdateCounter, pData);
}// if bLearn is on
}
}
void parse_class_data_item (
DexFileFormat *dex,
unsigned char *buf, int offset, int index)
{
int i = 0;
int j = 0;
int size = 0;
int len = 0;
i = offset ;
dex->class_data_item[index].static_fields_size =
get_uleb128_len ( buf, i, &size );
i += size;
dex->class_data_item[index].instance_fields_size=
get_uleb128_len ( buf, i, &size );
i += size;
dex->class_data_item[index].direct_methods_size=
get_uleb128_len ( buf, i, &size );
i += size;
dex->class_data_item[index].virtual_methods_size=
get_uleb128_len ( buf, i, &size );
i += size;
if ( is_verbose() > 3 ) {
printf(" class_data_item[%d]", index);
printf(" , static_fields_size = %d\n",
dex->class_data_item[index].static_fields_size );
printf(" , instance_fields_size = %d\n",
dex->class_data_item[index].instance_fields_size );
printf(" , direct_method_size = %d\n",
dex->class_data_item[index].direct_methods_size );
printf(" , direct_method_size = %d\n",
dex->class_data_item[index].virtual_methods_size );
printf( "i = %d\n", i );
}
if ( dex->class_data_item[index].static_fields_size > 0 ) {
}
if ( dex->class_data_item[index].instance_fields_size > 0 ) {
}
if ( dex->class_data_item[index].direct_methods_size > 0 ) {
dex->class_data_item[index].direct_methods = (encoded_method*)
malloc( sizeof( encoded_method ) *
dex->class_data_item[index].direct_methods_size);
for ( j = 0 ; j < dex->class_data_item[index].direct_methods_size; j++ )
{
if ( is_verbose() > 3 ) {
printf("offset = %04x ", i + sizeof(DexHeader));
}
dex->class_data_item[index].direct_methods[j].method_idx_diff =
get_uleb128_len ( buf, i, &size );
i += size;
dex->class_data_item[index].direct_methods[j].access_flags=
get_uleb128_len ( buf, i, &size );
i += size;
dex->class_data_item[index].direct_methods[j].code_off=
get_uleb128_len ( buf, i, &size );
i += size;
if ( is_verbose() > 3 ) {
printf("ecoded_method, method_id = %d, access_flag = %04x, code_off = %04x\n",
dex->class_data_item[index].direct_methods[j].method_idx_diff,
dex->class_data_item[index].direct_methods[j].access_flags,
dex->class_data_item[index].direct_methods[j].code_off);
}
parse_encoded_method( dex, buf,
&dex->class_data_item[index].direct_methods[j]);
}
}
if ( dex->class_data_item[index].virtual_methods_size > 0 ) {
}
}
