Re: Load an object from a file

[Niklas Holsti <niklas.holsti@tidorum.invalid>]

Olivier Scalbert wrote:
> Hello everybody !
> 
> In my Ada self-study context, I was asking myself how can I create and 
> fill objects or records from a file.
> As an example, I have tried to represent a java class file format 
> structure and fill it with a .class java file.
> 
> The ClassFile structure is something like:
> 
>     ClassFile {
>         u4 magic;
>         u2 minor_version;
>         u2 major_version;
>         u2 constant_pool_count;
>         cp_info constant_pool[constant_pool_count-1];
>         u2 access_flags;
>         u2 this_class;
>         u2 super_class;
>         u2 interfaces_count;
>         u2 interfaces[interfaces_count];
>         u2 fields_count;
>         field_info fields[fields_count];
>         u2 methods_count;
>         method_info methods[methods_count];
>         u2 attributes_count;
>         attribute_info attributes[attributes_count];
>     }
> 
> 
> JVM Specs can be found there:
> http://java.sun.com/docs/books/jvms/second_edition/html/ClassFile.doc.html
> 
> I have no problem to represent and to fill from file, the first four 
> fields.
> But I do not know what is the best (Ada) way of representing the array 
> of info constant_pool as the size is only known at run time.(= 
> constant_pool_cout).

You could use suitable container structures, for example 
Ada.Containers.Vectors. That would hide the storage management from 
your problem space.

There are two more basic methods:

1. Make the size components discriminants of the record, not
    ordinary components:

    type Constant_Pool_T is array (Positive range <>) of cp_info;
    ... etc types for the other arrays.

    type Class_File_T (
       Constant_Pool_Count : u2;
       Interfaces_Count    : u2;
       Fields_Count        : u2;
       Attributes_Count    : u2)
    is record
       ...
       Constant_Pool : Constant_Pool_T (1 .. Constant_Pool_Count);
       ...
       Attributes : Attributes_T (1 .. Attributes_Count);
    end record;

    In this method, you must know the sizes of the arrays
    before you can create the Class_File_T object. This could
    be hard in your case -- I assume you must read the components
    from a file in the order given in the record type, so you
    would have to read all constant-pool items before reading
    interfaces_count, for example.

    In this method it is more convenient to index the
    arrays starting from 1, not 0, because you cannot do
    arithmetic on the discriminants to define the array
    bounds; the "-1" is forbidden here:

    type Class_File_T ( ... ) is record
       ...
       Constant_Pool :
          Constant_Pool_T (0 .. Constant_Pool_Count - 1);
       ...
    end record;

2. Use heap allocation and access types:

    type Constant_Pool_T is array Natural range <>) of cp_info;
    type Constant_Pool_Ref is access Constant_Pool_T;

    type Class_File_T is record
       ...
       Constant_Pool : Constant_Pool_Ref;
       ...
       Attributes : Attributes_Ref;
    end record;

    In this method, you can create the Class_File_T object
    before you know the array sizes. The components Constant_Pool
    etc. will initially be null. When you know the size, you
    can create arrays of the right size on the heap:

       CF.Constant_Pool :=
          new Constant_Pool_T (0 .. constant_pool_count - 1);

HTH,

-- 
Niklas Holsti
Tidorum Ltd
niklas holsti tidorum fi
       .      @       .