Updated a little bit the Java part (welcome back).

git-svn-id: svn://svn.gna.org/svn/chrysalide/trunk@154 abbe820e-26c8-41b2-8c08-b7b2b41f8b0a

1 files changed, 55 insertions, 51 deletions

diff --git a/src/format/java/pool.c b/src/format/java/pool.c
index eec2918..c05abd5 100755
--- a/src/format/java/pool.c
+++ b/src/format/java/pool.c
@@ -35,10 +35,10 @@
 
 
 /* Charge les propriétés d'une constante du réservoir. */
-bool load_java_pool_entry(java_format *, constant_pool_entry *, off_t *);
+bool load_java_pool_entry(GJavaFormat *, constant_pool_entry *, off_t *);
 
 /* Fournit une entrée donnée du réservoir de constantes. */
-const constant_pool_entry *get_java_pool_entry(const java_format *, uint16_t, ConstantPoolTag);
+const constant_pool_entry *get_java_pool_entry(const GJavaFormat *, uint16_t, ConstantPoolTag);
 
 
 
@@ -55,35 +55,39 @@ const constant_pool_entry *get_java_pool_entry(const java_format *, uint16_t, Co
 *                                                                             *
 ******************************************************************************/
 
-bool load_java_pool(java_format *format, off_t *pos)
+bool load_java_pool(GJavaFormat *format, off_t *pos)
 {
     bool result;                            /* Bilan à remonter            */
     uint16_t count;                         /* Nombre d'éléments présents  */
     uint16_t i;                             /* Boucle de parcours          */
 
-    result = read_u16(&count, EXE_FORMAT(format)->content, pos,
-                      EXE_FORMAT(format)->length, SRE_BIG);
+    result = read_u16(&count, G_BIN_FORMAT(format)->content, pos,
+                      G_BIN_FORMAT(format)->length, SRE_BIG);
 
-    format->pool_len = count - 1;
-    format->pool = (constant_pool_entry *)calloc(count - 1, sizeof(constant_pool_entry));
+    printf("Alloc %hu entries (result=%d)\n", count, result);
+
+    format->header.pool_len = count - 1;
+    format->header.pool = (constant_pool_entry *)calloc(count - 1, sizeof(constant_pool_entry));
 
     for (i = 1; i < count && result; i++)
     {
-        result = load_java_pool_entry(format, &format->pool[i - 1], pos);
+        result = load_java_pool_entry(format, &format->header.pool[i - 1], pos);
 
-        if (format->pool[i - 1].tag == CONSTANT_LONG
-            || format->pool[i - 1].tag == CONSTANT_DOUBLE)
+        if (format->header.pool[i - 1].tag == CONSTANT_LONG
+            || format->header.pool[i - 1].tag == CONSTANT_DOUBLE)
         {
             i++;
 
             /* On n'est jamais trop prudent */
             if (i < count)
-                format->pool[i - 1].tag = CONSTANT_EMPTY;
+                format->header.pool[i - 1].tag = CONSTANT_EMPTY;
 
         }
 
     }
 
+    printf("stop at %hd  ||  pos :: %d - max %d\n", i, *pos, G_BIN_FORMAT(format)->length);
+
     return result;
 
 }
@@ -101,12 +105,12 @@ bool load_java_pool(java_format *format, off_t *pos)
 *                                                                             *
 ******************************************************************************/
 
-void unload_java_pool(java_format *format)
+void unload_java_pool(GJavaFormat *format)
 {
     uint16_t i;                             /* Boucle de parcours          */
 
-    for (i = 0; i < format->pool_len; i++)
-        switch (format->pool[i].tag)
+    for (i = 0; i < format->header.pool_len; i++)
+        switch (format->header.pool[i].tag)
         {
             case CONSTANT_EMPTY:
             case CONSTANT_CLASS:
@@ -122,12 +126,12 @@ void unload_java_pool(java_format *format)
                 break;
 
             case CONSTANT_UTF8:
-                free(format->pool[i].info.utf8.bytes);
+                free(format->header.pool[i].info.utf8.bytes);
                 break;
 
         }
 
-    free(format->pool);
+    free(format->header.pool);
 
 }
 
@@ -146,7 +150,7 @@ void unload_java_pool(java_format *format)
 *                                                                             *
 ******************************************************************************/
 
-bool load_java_pool_entry(java_format *format, constant_pool_entry *entry, off_t *pos)
+bool load_java_pool_entry(GJavaFormat *format, constant_pool_entry *entry, off_t *pos)
 {
     bool result;                            /* Bilan à retourner           */
     uint8_t tag;                            /* Type de l'élément           */
@@ -159,43 +163,43 @@ bool load_java_pool_entry(java_format *format, constant_pool_entry *entry, off_t
 	uint64_t mantissa64;                    /* Mantisse du nombre lu 64b   */
     uint16_t length;                        /* Taille d'une chaîne         */
 
-    result = read_u8(&tag, EXE_FORMAT(format)->content, pos,
-                     EXE_FORMAT(format)->length, SRE_BIG);
+    result = read_u8(&tag, G_BIN_FORMAT(format)->content, pos,
+                     G_BIN_FORMAT(format)->length, SRE_BIG);
 
     entry->tag = tag;
 
     switch (entry->tag)
     {
         case CONSTANT_CLASS:
-            result = read_u16(&entry->info.class.name_index, EXE_FORMAT(format)->content,
-                              pos, EXE_FORMAT(format)->length, SRE_BIG);
+            result = read_u16(&entry->info.class.name_index, G_BIN_FORMAT(format)->content,
+                              pos, G_BIN_FORMAT(format)->length, SRE_BIG);
             break;
 
         case CONSTANT_FIELD_REF:
         case CONSTANT_METHOD_REF:
         case CONSTANT_INTERFACE_METHOD_REF:
 
-            result = read_u16(&entry->info.ref.class_index, EXE_FORMAT(format)->content,
-                              pos, EXE_FORMAT(format)->length, SRE_BIG);
-            result &= read_u16(&entry->info.ref.name_and_type_index, EXE_FORMAT(format)->content,
-                               pos, EXE_FORMAT(format)->length, SRE_BIG);
+            result = read_u16(&entry->info.ref.class_index, G_BIN_FORMAT(format)->content,
+                              pos, G_BIN_FORMAT(format)->length, SRE_BIG);
+            result &= read_u16(&entry->info.ref.name_and_type_index, G_BIN_FORMAT(format)->content,
+                               pos, G_BIN_FORMAT(format)->length, SRE_BIG);
 
             break;
 
         case CONSTANT_STRING:
-            result = read_u16(&entry->info.string.string_index, EXE_FORMAT(format)->content,
-                              pos, EXE_FORMAT(format)->length, SRE_BIG);
+            result = read_u16(&entry->info.string.string_index, G_BIN_FORMAT(format)->content,
+                              pos, G_BIN_FORMAT(format)->length, SRE_BIG);
             break;
 
         case CONSTANT_INTEGER:
-            result = read_u32(&entry->info.int_val.val, EXE_FORMAT(format)->content,
-                              pos, EXE_FORMAT(format)->length, SRE_BIG);
+            result = read_u32(&entry->info.int_val.val, G_BIN_FORMAT(format)->content,
+                              pos, G_BIN_FORMAT(format)->length, SRE_BIG);
             break;
 
         case CONSTANT_FLOAT:
 
-            result = read_u32(&low_bytes, EXE_FORMAT(format)->content,
-                              pos, EXE_FORMAT(format)->length, SRE_BIG);
+            result = read_u32(&low_bytes, G_BIN_FORMAT(format)->content,
+                              pos, G_BIN_FORMAT(format)->length, SRE_BIG);
 
             if (result)
             {
@@ -232,10 +236,10 @@ bool load_java_pool_entry(java_format *format, constant_pool_entry *entry, off_t
 
         case CONSTANT_LONG:
 
-            result = read_u32(&high_bytes, EXE_FORMAT(format)->content,
-                              pos, EXE_FORMAT(format)->length, SRE_BIG);
-            result &= read_u32(&low_bytes, EXE_FORMAT(format)->content,
-                               pos, EXE_FORMAT(format)->length, SRE_BIG);
+            result = read_u32(&high_bytes, G_BIN_FORMAT(format)->content,
+                              pos, G_BIN_FORMAT(format)->length, SRE_BIG);
+            result &= read_u32(&low_bytes, G_BIN_FORMAT(format)->content,
+                               pos, G_BIN_FORMAT(format)->length, SRE_BIG);
 
             if (result)
             {
@@ -247,10 +251,10 @@ bool load_java_pool_entry(java_format *format, constant_pool_entry *entry, off_t
 
         case CONSTANT_DOUBLE:
 
-            result = read_u32(&high_bytes, EXE_FORMAT(format)->content,
-                              pos, EXE_FORMAT(format)->length, SRE_BIG);
-            result &= read_u32(&low_bytes, EXE_FORMAT(format)->content,
-                               pos, EXE_FORMAT(format)->length, SRE_BIG);
+            result = read_u32(&high_bytes, G_BIN_FORMAT(format)->content,
+                              pos, G_BIN_FORMAT(format)->length, SRE_BIG);
+            result &= read_u32(&low_bytes, G_BIN_FORMAT(format)->content,
+                               pos, G_BIN_FORMAT(format)->length, SRE_BIG);
 
             if (result)
             {
@@ -289,22 +293,22 @@ bool load_java_pool_entry(java_format *format, constant_pool_entry *entry, off_t
 
         case CONSTANT_NAME_AND_TYPE:
 
-            result = read_u16(&entry->info.name_type.name_index, EXE_FORMAT(format)->content,
-                              pos, EXE_FORMAT(format)->length, SRE_BIG);
-            result &= read_u16(&entry->info.name_type.descriptor_index, EXE_FORMAT(format)->content,
-                               pos, EXE_FORMAT(format)->length, SRE_BIG);
+            result = read_u16(&entry->info.name_type.name_index, G_BIN_FORMAT(format)->content,
+                              pos, G_BIN_FORMAT(format)->length, SRE_BIG);
+            result &= read_u16(&entry->info.name_type.descriptor_index, G_BIN_FORMAT(format)->content,
+                               pos, G_BIN_FORMAT(format)->length, SRE_BIG);
 
             break;
 
         case CONSTANT_UTF8:
 
-            result = read_u16(&length, EXE_FORMAT(format)->content,
-                              pos, EXE_FORMAT(format)->length, SRE_BIG);
+            result = read_u16(&length, G_BIN_FORMAT(format)->content,
+                              pos, G_BIN_FORMAT(format)->length, SRE_BIG);
 
             if (result)
             {
                 entry->info.utf8.bytes = (char *)calloc(length + 1, sizeof(char));
-                memcpy(entry->info.utf8.bytes, &EXE_FORMAT(format)->content[*pos], length);
+                memcpy(entry->info.utf8.bytes, &G_BIN_FORMAT(format)->content[*pos], length);
                 *pos += length;
             }
 
@@ -335,16 +339,16 @@ bool load_java_pool_entry(java_format *format, constant_pool_entry *entry, off_t
 *                                                                             *
 ******************************************************************************/
 
-const constant_pool_entry *get_java_pool_entry(const java_format *format, uint16_t index, ConstantPoolTag expected)
+const constant_pool_entry *get_java_pool_entry(const GJavaFormat *format, uint16_t index, ConstantPoolTag expected)
 {
     const constant_pool_entry *result;      /* Entrée à retourner          */
     constant_pool_entry *entry;             /* Entrée du réservoir visée   */
 
     result = NULL;
 
-    if (/*index < 0 && FIXME */index <= format->pool_len);
+    if (/*index < 0 && FIXME */index <= format->header.pool_len);
     {
-        entry = &format->pool[index - 1];
+        entry = &format->header.pool[index - 1];
 
         if (entry->tag == expected)
             result = entry;
@@ -370,7 +374,7 @@ const constant_pool_entry *get_java_pool_entry(const java_format *format, uint16
 *                                                                             *
 ******************************************************************************/
 
-char *build_reference_from_java_pool(const java_format *format, uint16_t index, JavaRefType expected)
+char *build_reference_from_java_pool(const GJavaFormat *format, uint16_t index, JavaRefType expected)
 {
     char *result;                           /* Chaîne humaine à retourner  */
     const constant_pool_entry *entry;       /* Entrée du réservoir visée 1 */
@@ -455,7 +459,7 @@ char *build_reference_from_java_pool(const java_format *format, uint16_t index,
 *                                                                             *
 ******************************************************************************/
 
-bool get_java_pool_ut8_string(const java_format *format, uint16_t index, const char **str)
+bool get_java_pool_ut8_string(const GJavaFormat *format, uint16_t index, const char **str)
 {
     bool result;                            /* Bilan à renvoyer            */
     const constant_pool_entry *entry;       /* Entrée du réservoir visée   */