summaryrefslogtreecommitdiff
path: root/plugins/kaitai/records
diff options
context:
space:
mode:
Diffstat (limited to 'plugins/kaitai/records')
-rw-r--r--plugins/kaitai/records/Makefile.am8
-rw-r--r--plugins/kaitai/records/bits-int.h59
-rw-r--r--plugins/kaitai/records/bits.c283
-rw-r--r--plugins/kaitai/records/bits.h62
-rw-r--r--plugins/kaitai/records/delayed-int.h (renamed from plugins/kaitai/records/value-int.h)19
-rw-r--r--plugins/kaitai/records/delayed.c (renamed from plugins/kaitai/records/value.c)128
-rw-r--r--plugins/kaitai/records/delayed.h (renamed from plugins/kaitai/records/value.h)32
7 files changed, 508 insertions, 83 deletions
diff --git a/plugins/kaitai/records/Makefile.am b/plugins/kaitai/records/Makefile.am
index c11e823..3884bfb 100644
--- a/plugins/kaitai/records/Makefile.am
+++ b/plugins/kaitai/records/Makefile.am
@@ -2,6 +2,10 @@
noinst_LTLIBRARIES = libkaitairecords.la
libkaitairecords_la_SOURCES = \
+ bits-int.h \
+ bits.h bits.c \
+ delayed-int.h \
+ delayed.h delayed.c \
empty-int.h \
empty.h empty.c \
group-int.h \
@@ -9,9 +13,7 @@ libkaitairecords_la_SOURCES = \
item-int.h \
item.h item.c \
list-int.h \
- list.h list.c \
- value-int.h \
- value.h value.c
+ list.h list.c
libkaitairecords_la_CFLAGS = $(TOOLKIT_CFLAGS) $(LIBXML_CFLAGS) -I$(top_srcdir)/src
diff --git a/plugins/kaitai/records/bits-int.h b/plugins/kaitai/records/bits-int.h
new file mode 100644
index 0000000..7b03911
--- /dev/null
+++ b/plugins/kaitai/records/bits-int.h
@@ -0,0 +1,59 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * bits-int.h - prototypes internes pour la conservation d'un champ de bits entre attribut et binaire
+ *
+ * Copyright (C) 2023 Cyrille Bagard
+ *
+ * This file is part of Chrysalide.
+ *
+ * Chrysalide is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Chrysalide is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Chrysalide. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _PLUGINS_KAITAI_RECORDS_BITS_INT_H
+#define _PLUGINS_KAITAI_RECORDS_BITS_INT_H
+
+
+#include "bits.h"
+
+
+#include "../record-int.h"
+
+
+
+/* Correspondance de bits établie entre un attribut et du binaire (instance) */
+struct _GRecordBitField
+{
+ GMatchRecord parent; /* A laisser en premier */
+
+ ext_vmpa_t epos; /* Point de départ */
+ uint8_t size; /* Quantité de bits concernés */
+ SourceEndian endian; /* Boutisme des données imposé */
+
+};
+
+/* Correspondance de bits établie entre un attribut et du binaire (classe) */
+struct _GRecordBitFieldClass
+{
+ GMatchRecordClass parent; /* A laisser en premier */
+
+};
+
+
+/* Met en place une correspondance entre attribut et binaire. */
+bool g_record_bit_field_create(GRecordBitField *, GKaitaiAttribute *, GBinContent *, const ext_vmpa_t *, uint8_t, SourceEndian);
+
+
+
+#endif /* _PLUGINS_KAITAI_RECORDS_BITS_INT_H */
diff --git a/plugins/kaitai/records/bits.c b/plugins/kaitai/records/bits.c
new file mode 100644
index 0000000..d224112
--- /dev/null
+++ b/plugins/kaitai/records/bits.c
@@ -0,0 +1,283 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * bits.c - conservation d'un champ de bits entre attribut et binaire
+ *
+ * Copyright (C) 2023 Cyrille Bagard
+ *
+ * This file is part of Chrysalide.
+ *
+ * Chrysalide is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Chrysalide is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Chrysalide. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "bits.h"
+
+
+#include <assert.h>
+#include <string.h>
+
+
+#include "bits-int.h"
+
+
+
+/* -------------------- DEFINITION D'UNE CORRESPONDANCE UNITAIRE -------------------- */
+
+
+/* Initialise la classe des correspondances attribut/binaire. */
+static void g_record_bit_field_class_init(GRecordBitFieldClass *);
+
+/* Initialise une correspondance entre attribut et binaire. */
+static void g_record_bit_field_init(GRecordBitField *);
+
+/* Supprime toutes les références externes. */
+static void g_record_bit_field_dispose(GRecordBitField *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_record_bit_field_finalize(GRecordBitField *);
+
+
+
+/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
+
+
+/* Calcule ou fournit la zone couverte par une correspondance. */
+static void g_record_bit_field_get_range(const GRecordBitField *, mrange_t *);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/* DEFINITION D'UNE CORRESPONDANCE UNITAIRE */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour une correspondance entre un attribut et du binaire. */
+G_DEFINE_TYPE(GRecordBitField, g_record_bit_field, G_TYPE_MATCH_RECORD);
+
+
+/******************************************************************************
+* *
+* Paramètres : klass = classe à initialiser. *
+* *
+* Description : Initialise la classe des correspondances attribut/binaire. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_record_bit_field_class_init(GRecordBitFieldClass *klass)
+{
+ GObjectClass *object; /* Autre version de la classe */
+ GMatchRecordClass *record; /* Version parente de la classe*/
+
+ object = G_OBJECT_CLASS(klass);
+
+ object->dispose = (GObjectFinalizeFunc/* ! */)g_record_bit_field_dispose;
+ object->finalize = (GObjectFinalizeFunc)g_record_bit_field_finalize;
+
+ record = G_MATCH_RECORD_CLASS(klass);
+
+ record->get_range = (get_record_range_fc)g_record_bit_field_get_range;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : field = instance à initialiser. *
+* *
+* Description : Initialise une correspondance entre attribut et binaire. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_record_bit_field_init(GRecordBitField *field)
+{
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : field = instance d'objet GLib à traiter. *
+* *
+* Description : Supprime toutes les références externes. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_record_bit_field_dispose(GRecordBitField *field)
+{
+ G_OBJECT_CLASS(g_record_bit_field_parent_class)->dispose(G_OBJECT(field));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : field = instance d'objet GLib à traiter. *
+* *
+* Description : Procède à la libération totale de la mémoire. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_record_bit_field_finalize(GRecordBitField *field)
+{
+ G_OBJECT_CLASS(g_record_bit_field_parent_class)->finalize(G_OBJECT(field));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : attrib = analyseur à l'origine de la correspondance. *
+* content = contenu binaire lié à la correspondance. *
+* epos = tête de lecture avec granularité en bits. *
+* size = quantité de bits à prendre en compte. *
+* endian = boustime des données à respecter. *
+* *
+* Description : Crée une nouvelle correspondance entre attribut et binaire. *
+* *
+* Retour : Instance mise en place ou NULL en cas d'échec. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GMatchRecord *g_record_bit_field_new(GKaitaiAttribute *attrib, GBinContent *content, const ext_vmpa_t *epos, uint8_t size, SourceEndian endian)
+{
+ GMatchRecord *result; /* Structure à retourner */
+
+ result = g_object_new(G_TYPE_RECORD_BIT_FIELD, NULL);
+
+ if (!g_record_bit_field_create(G_RECORD_BIT_FIELD(result), attrib, content, epos, size, endian))
+ g_clear_object(&result);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : field = correspondance à initialiser pleinement. *
+* attrib = analyseur à l'origine de la correspondance. *
+* content = contenu binaire lié à la correspondance. *
+* epos = tête de lecture avec granularité en bits. *
+* size = quantité de bits à prendre en compte. *
+* endian = boustime des données à respecter. *
+* *
+* Description : Met en place une correspondance entre attribut et binaire. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool g_record_bit_field_create(GRecordBitField *field, GKaitaiAttribute *attrib, GBinContent *content, const ext_vmpa_t *epos, uint8_t size, SourceEndian endian)
+{
+ bool result; /* Bilan à retourner */
+
+ result = g_match_record_create(G_MATCH_RECORD(field), G_KAITAI_PARSER(attrib), content);
+
+ if (result)
+ {
+ copy_evmpa(&field->epos, epos);
+ field->size = size;
+ field->endian = endian;
+
+ }
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : field = correspondance à consulter. *
+* out = valeur à sauvegarder sous une forme générique. [OUT] *
+* *
+* Description : Lit la valeur d'un élément Kaitai entier représenté. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool g_record_bit_field_get_value(const GRecordBitField *field, resolved_value_t *out)
+{
+ bool result; /* Bilan à retourner */
+ GKaitaiParser *parser; /* Attribut associé à l'élément*/
+
+ parser = g_match_record_get_creator(G_MATCH_RECORD(field));
+ assert(G_IS_KAITAI_ATTRIBUTE(parser));
+
+ result = g_kaitai_attribute_read_bit_field_value(G_KAITAI_ATTRIBUTE(parser),
+ G_MATCH_RECORD(field)->content,
+ &field->epos, field->size,
+ field->endian, out);
+
+ g_object_unref(G_OBJECT(parser));
+
+ return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/* IMPLEMENTATION DES FONCTIONS DE CLASSE */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+* *
+* Paramètres : record = correspondance à consulter. *
+* range = zone de couverture déterminée. [OUT] *
+* *
+* Description : Calcule ou fournit la zone couverte par une correspondance. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_record_bit_field_get_range(const GRecordBitField *record, mrange_t *range)
+{
+ phys_t len; /* Taille en octets */
+
+ len = record->size / 8;
+
+ if (record->size % 8 > 0)
+ len ++;
+
+ init_mrange(range, &record->epos.base, len);
+
+}
diff --git a/plugins/kaitai/records/bits.h b/plugins/kaitai/records/bits.h
new file mode 100644
index 0000000..923e8e3
--- /dev/null
+++ b/plugins/kaitai/records/bits.h
@@ -0,0 +1,62 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * bits.h - prototypes pour la conservation d'un champ de bits entre attribut et binaire
+ *
+ * Copyright (C) 2023 Cyrille Bagard
+ *
+ * This file is part of Chrysalide.
+ *
+ * Chrysalide is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Chrysalide is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Chrysalide. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _PLUGINS_KAITAI_RECORDS_BITS_H
+#define _PLUGINS_KAITAI_RECORDS_BITS_H
+
+
+#include <glib-object.h>
+
+
+#include "../record.h"
+#include "../parsers/attribute.h"
+
+
+
+#define G_TYPE_RECORD_BIT_FIELD g_record_bit_field_get_type()
+#define G_RECORD_BIT_FIELD(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_RECORD_BIT_FIELD, GRecordBitField))
+#define G_IS_RECORD_BIT_FIELD(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_RECORD_BIT_FIELD))
+#define G_RECORD_BIT_FIELD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_RECORD_BIT_FIELD, GRecordBitFieldClass))
+#define G_IS_RECORD_BIT_FIELD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_RECORD_BIT_FIELD))
+#define G_RECORD_BIT_FIELD_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_RECORD_BIT_FIELD, GRecordBitFieldClass))
+
+
+/* Correspondance de bits établie entre un attribut et du binaire (instance) */
+typedef struct _GRecordBitField GRecordBitField;
+
+/* Correspondance de bits établie entre un attribut et du binaire (classe) */
+typedef struct _GRecordBitFieldClass GRecordBitFieldClass;
+
+
+/* Indique le type défini pour une correspondance entre un attribut et du binaire. */
+GType g_record_bit_field_get_type(void);
+
+/* Crée une nouvelle correspondance entre attribut et binaire. */
+GMatchRecord *g_record_bit_field_new(GKaitaiAttribute *, GBinContent *, const ext_vmpa_t *, uint8_t, SourceEndian);
+
+/* Lit la valeur d'un élément Kaitai entier représenté. */
+bool g_record_bit_field_get_value(const GRecordBitField *, resolved_value_t *);
+
+
+
+#endif /* _PLUGINS_KAITAI_RECORDS_BITS_H */
diff --git a/plugins/kaitai/records/value-int.h b/plugins/kaitai/records/delayed-int.h
index 6a84a7f..9275500 100644
--- a/plugins/kaitai/records/value-int.h
+++ b/plugins/kaitai/records/delayed-int.h
@@ -1,6 +1,6 @@
/* Chrysalide - Outil d'analyse de fichiers binaires
- * value-int.h - prototypes internes pour la conservation d'une instance virtuelle
+ * delayed-int.h - prototypes internes pour la conservation d'une instance virtuelle
*
* Copyright (C) 2019 Cyrille Bagard
*
@@ -21,11 +21,11 @@
*/
-#ifndef _PLUGINS_KAITAI_RECORDS_VALUE_INT_H
-#define _PLUGINS_KAITAI_RECORDS_VALUE_INT_H
+#ifndef _PLUGINS_KAITAI_RECORDS_DELAYED_INT_H
+#define _PLUGINS_KAITAI_RECORDS_DELAYED_INT_H
-#include "value.h"
+#include "delayed.h"
#include "../record-int.h"
@@ -33,16 +33,19 @@
/* Valeur calculée selon des correspondances parallèles (instance) */
-struct _GRecordValue
+struct _GRecordDelayed
{
GMatchRecord parent; /* A laisser en premier */
kaitai_scope_t locals; /* Sauvegarde de contexte */
+ bool has_value; /* Port d'une valeur directe ? */
+ GMatchRecord *real_record; /* Enregistrement effectif */
+
};
/* Valeur calculée selon des correspondances parallèles (classe) */
-struct _GRecordValueClass
+struct _GRecordDelayedClass
{
GMatchRecordClass parent; /* A laisser en premier */
@@ -50,8 +53,8 @@ struct _GRecordValueClass
/* Met en place une valeur calculée selon des correspondances. */
-bool g_record_value_create(GRecordValue *, GKaitaiInstance *, const kaitai_scope_t *);
+bool g_record_delayed_create(GRecordDelayed *, GKaitaiInstance *, const kaitai_scope_t *, GBinContent *);
-#endif /* _PLUGINS_KAITAI_RECORDS_VALUE_INT_H */
+#endif /* _PLUGINS_KAITAI_RECORDS_DELAYED_INT_H */
diff --git a/plugins/kaitai/records/value.c b/plugins/kaitai/records/delayed.c
index cafe5c3..8c1395c 100644
--- a/plugins/kaitai/records/value.c
+++ b/plugins/kaitai/records/delayed.c
@@ -1,6 +1,6 @@
/* Chrysalide - Outil d'analyse de fichiers binaires
- * value.c - conservation d'une correspondance entre attribut et binaire
+ * delayed.c - conservation d'une correspondance entre attribut et binaire
*
* Copyright (C) 2019 Cyrille Bagard
*
@@ -21,7 +21,7 @@
*/
-#include "value.h"
+#include "delayed.h"
#include <assert.h>
@@ -29,7 +29,8 @@
#include <string.h>
-#include "value-int.h"
+#include "delayed-int.h"
+#include "item.h"
#include "../parsers/attribute.h"
@@ -38,16 +39,16 @@
/* Initialise la classe des valeurs purement calculées. */
-static void g_record_value_class_init(GRecordValueClass *);
+static void g_record_delayed_class_init(GRecordDelayedClass *);
/* Initialise une correspondance entre attribut et binaire. */
-static void g_record_value_init(GRecordValue *);
+static void g_record_delayed_init(GRecordDelayed *);
/* Supprime toutes les références externes. */
-static void g_record_value_dispose(GRecordValue *);
+static void g_record_delayed_dispose(GRecordDelayed *);
/* Procède à la libération totale de la mémoire. */
-static void g_record_value_finalize(GRecordValue *);
+static void g_record_delayed_finalize(GRecordDelayed *);
@@ -55,7 +56,7 @@ static void g_record_value_finalize(GRecordValue *);
/* Calcule ou fournit la zone couverte par une correspondance. */
-static void g_record_value_get_range(const GRecordValue *, mrange_t *);
+static void g_record_delayed_get_range(const GRecordDelayed *, mrange_t *);
@@ -65,7 +66,7 @@ static void g_record_value_get_range(const GRecordValue *, mrange_t *);
/* Indique le type défini pour une valeur calculée selon des correspondances établies. */
-G_DEFINE_TYPE(GRecordValue, g_record_value, G_TYPE_MATCH_RECORD);
+G_DEFINE_TYPE(GRecordDelayed, g_record_delayed, G_TYPE_MATCH_RECORD);
/******************************************************************************
@@ -80,26 +81,26 @@ G_DEFINE_TYPE(GRecordValue, g_record_value, G_TYPE_MATCH_RECORD);
* *
******************************************************************************/
-static void g_record_value_class_init(GRecordValueClass *klass)
+static void g_record_delayed_class_init(GRecordDelayedClass *klass)
{
GObjectClass *object; /* Autre version de la classe */
GMatchRecordClass *record; /* Version parente de la classe*/
object = G_OBJECT_CLASS(klass);
- object->dispose = (GObjectFinalizeFunc/* ! */)g_record_value_dispose;
- object->finalize = (GObjectFinalizeFunc)g_record_value_finalize;
+ object->dispose = (GObjectFinalizeFunc/* ! */)g_record_delayed_dispose;
+ object->finalize = (GObjectFinalizeFunc)g_record_delayed_finalize;
record = G_MATCH_RECORD_CLASS(klass);
- record->get_range = (get_record_range_fc)g_record_value_get_range;
+ record->get_range = (get_record_range_fc)g_record_delayed_get_range;
}
/******************************************************************************
* *
-* Paramètres : value = instance à initialiser. *
+* Paramètres : delayed = instance à initialiser. *
* *
* Description : Initialise une correspondance entre attribut et binaire. *
* *
@@ -109,16 +110,18 @@ static void g_record_value_class_init(GRecordValueClass *klass)
* *
******************************************************************************/
-static void g_record_value_init(GRecordValue *value)
+static void g_record_delayed_init(GRecordDelayed *delayed)
{
- init_record_scope(&value->locals, NULL);
+ init_record_scope(&delayed->locals, NULL);
+
+ delayed->real_record = NULL;
}
/******************************************************************************
* *
-* Paramètres : value = instance d'objet GLib à traiter. *
+* Paramètres : delayed = instance d'objet GLib à traiter. *
* *
* Description : Supprime toutes les références externes. *
* *
@@ -128,18 +131,18 @@ static void g_record_value_init(GRecordValue *value)
* *
******************************************************************************/
-static void g_record_value_dispose(GRecordValue *value)
+static void g_record_delayed_dispose(GRecordDelayed *delayed)
{
- reset_record_scope(&value->locals);
+ reset_record_scope(&delayed->locals);
- G_OBJECT_CLASS(g_record_value_parent_class)->dispose(G_OBJECT(value));
+ G_OBJECT_CLASS(g_record_delayed_parent_class)->dispose(G_OBJECT(delayed));
}
/******************************************************************************
* *
-* Paramètres : value = instance d'objet GLib à traiter. *
+* Paramètres : delayed = instance d'objet GLib à traiter. *
* *
* Description : Procède à la libération totale de la mémoire. *
* *
@@ -149,17 +152,18 @@ static void g_record_value_dispose(GRecordValue *value)
* *
******************************************************************************/
-static void g_record_value_finalize(GRecordValue *value)
+static void g_record_delayed_finalize(GRecordDelayed *delayed)
{
- G_OBJECT_CLASS(g_record_value_parent_class)->finalize(G_OBJECT(value));
+ G_OBJECT_CLASS(g_record_delayed_parent_class)->finalize(G_OBJECT(delayed));
}
/******************************************************************************
* *
-* Paramètres : inst = analyseur à l'origine de la correspondance. *
-* locals = correspondances courantes pour résolutions. *
+* Paramètres : inst = analyseur à l'origine de la correspondance. *
+* locals = correspondances courantes pour résolutions. *
+* content = contenu binaire lié à la correspondance. *
* *
* Description : Crée une nouvelle valeur calculée à partir d'une instance. *
* *
@@ -169,13 +173,13 @@ static void g_record_value_finalize(GRecordValue *value)
* *
******************************************************************************/
-GRecordValue *g_record_value_new(GKaitaiInstance *inst, const kaitai_scope_t *locals)
+GRecordDelayed *g_record_delayed_new(GKaitaiInstance *inst, const kaitai_scope_t *locals, GBinContent *content)
{
- GRecordValue *result; /* Structure à retourner */
+ GRecordDelayed *result; /* Structure à retourner */
- result = g_object_new(G_TYPE_RECORD_VALUE, NULL);
+ result = g_object_new(G_TYPE_RECORD_DELAYED, NULL);
- if (!g_record_value_create(result, inst, locals))
+ if (!g_record_delayed_create(result, inst, locals, content))
g_clear_object(&result);
return result;
@@ -185,9 +189,10 @@ GRecordValue *g_record_value_new(GKaitaiInstance *inst, const kaitai_scope_t *lo
/******************************************************************************
* *
-* Paramètres : value = correspondance à initialiser pleinement. *
-* inst = analyseur à l'origine de la correspondance. *
-* locals = correspondances courantes pour résolutions. *
+* Paramètres : delayed = correspondance à initialiser pleinement. *
+* inst = analyseur à l'origine de la correspondance. *
+* locals = correspondances courantes pour résolutions. *
+* content = contenu binaire lié à la correspondance. *
* *
* Description : Met en place une valeur calculée à partir d'une instance. *
* *
@@ -197,14 +202,14 @@ GRecordValue *g_record_value_new(GKaitaiInstance *inst, const kaitai_scope_t *lo
* *
******************************************************************************/
-bool g_record_value_create(GRecordValue *value, GKaitaiInstance *inst, const kaitai_scope_t *locals)
+bool g_record_delayed_create(GRecordDelayed *delayed, GKaitaiInstance *inst, const kaitai_scope_t *locals, GBinContent *content)
{
bool result; /* Bilan à retourner */
- result = g_match_record_create(G_MATCH_RECORD(value), G_KAITAI_PARSER(inst), NULL);
+ result = g_match_record_create(G_MATCH_RECORD(delayed), G_KAITAI_PARSER(inst), content);
if (result)
- copy_record_scope(&value->locals, locals);
+ copy_record_scope(&delayed->locals, locals);
return result;
@@ -213,8 +218,8 @@ bool g_record_value_create(GRecordValue *value, GKaitaiInstance *inst, const kai
/******************************************************************************
* *
-* Paramètres : value = correspondance à consulter. *
-* value = valeur à sauvegarder sous une forme générique. [OUT] *
+* Paramètres : delayed = correspondance à consulter. *
+* out = valeur à sauvegarder sous forme générique. [OUT] *
* *
* Description : Détermine la valeur d'un élément Kaitai calculé. *
* *
@@ -224,17 +229,36 @@ bool g_record_value_create(GRecordValue *value, GKaitaiInstance *inst, const kai
* *
******************************************************************************/
-bool g_record_value_compute_value(const GRecordValue *value, resolved_value_t *out)
+bool g_record_delayed_compute_value(GRecordDelayed *delayed, resolved_value_t *out)
{
bool result; /* Bilan à retourner */
GKaitaiParser *parser; /* Instance liée à l'élément */
- parser = g_match_record_get_creator(G_MATCH_RECORD(value));
+ parser = g_match_record_get_creator(G_MATCH_RECORD(delayed));
assert(G_IS_KAITAI_ATTRIBUTE(parser));
- result = g_kaitai_instance_compute_value(G_KAITAI_INSTANCE(parser),
- &value->locals,
- out);
+ if (G_MATCH_RECORD(delayed)->content == NULL)
+ result = g_kaitai_instance_compute_value(G_KAITAI_INSTANCE(parser),
+ &delayed->locals,
+ out);
+
+ else
+ {
+ if (delayed->real_record == NULL)
+ delayed->real_record = g_kaitai_instance_compute_real_record(G_KAITAI_INSTANCE(parser),
+ &delayed->locals,
+ G_MATCH_RECORD(delayed)->content);
+
+ if (delayed->real_record == NULL)
+ result = false;
+
+ else
+ {
+ assert(G_IS_RECORD_ITEM(delayed->real_record));
+ result = g_record_item_get_value(G_RECORD_ITEM(delayed->real_record), out);
+ }
+
+ }
g_object_unref(G_OBJECT(parser));
@@ -245,8 +269,8 @@ bool g_record_value_compute_value(const GRecordValue *value, resolved_value_t *o
/******************************************************************************
* *
-* Paramètres : value = correspondance à consulter. *
-* value = valeur à sauvegarder sous une forme générique. [OUT] *
+* Paramètres : delayed = correspondance à consulter. *
+* out = valeur à sauvegarder sous forme générique. [OUT] *
* *
* Description : Détermine et ajuste la valeur d'un élément Kaitai calculé. *
* *
@@ -256,20 +280,12 @@ bool g_record_value_compute_value(const GRecordValue *value, resolved_value_t *o
* *
******************************************************************************/
-bool g_record_value_compute_and_aggregate_value(const GRecordValue *value, resolved_value_t *out)
+bool g_record_delayed_compute_and_aggregate_value(GRecordDelayed *delayed, resolved_value_t *out)
{
bool result; /* Bilan à retourner */
- GKaitaiParser *parser; /* Instance liée à l'élément */
sized_string_t converted; /* Conversion finale ? */
- parser = g_match_record_get_creator(G_MATCH_RECORD(value));
- assert(G_IS_KAITAI_ATTRIBUTE(parser));
-
- result = g_kaitai_instance_compute_value(G_KAITAI_INSTANCE(parser),
- &value->locals,
- out);
-
- g_object_unref(G_OBJECT(parser));
+ result = g_record_delayed_compute_value(delayed, out);
if (result)
{
@@ -318,7 +334,7 @@ bool g_record_value_compute_and_aggregate_value(const GRecordValue *value, resol
/******************************************************************************
* *
-* Paramètres : value = correspondance à consulter. *
+* Paramètres : delayed = correspondance à consulter. *
* range = zone de couverture déterminée. [OUT] *
* *
* Description : Calcule ou fournit la zone couverte par une correspondance. *
@@ -329,7 +345,7 @@ bool g_record_value_compute_and_aggregate_value(const GRecordValue *value, resol
* *
******************************************************************************/
-static void g_record_value_get_range(const GRecordValue *value, mrange_t *range)
+static void g_record_delayed_get_range(const GRecordDelayed *delayed, mrange_t *range)
{
copy_mrange(range, UNUSED_MRANGE_PTR);
diff --git a/plugins/kaitai/records/value.h b/plugins/kaitai/records/delayed.h
index 8ee9cdd..e88bb6c 100644
--- a/plugins/kaitai/records/value.h
+++ b/plugins/kaitai/records/delayed.h
@@ -1,6 +1,6 @@
/* Chrysalide - Outil d'analyse de fichiers binaires
- * value.h - prototypes pour la conservation d'une correspondance entre attribut et binaire
+ * delayed.h - prototypes pour la conservation d'une correspondance entre attribut et binaire
*
* Copyright (C) 2019 Cyrille Bagard
*
@@ -21,8 +21,8 @@
*/
-#ifndef _PLUGINS_KAITAI_RECORDS_VALUE_H
-#define _PLUGINS_KAITAI_RECORDS_VALUE_H
+#ifndef _PLUGINS_KAITAI_RECORDS_DELAYED_H
+#define _PLUGINS_KAITAI_RECORDS_DELAYED_H
#include <glib-object.h>
@@ -33,33 +33,33 @@
-#define G_TYPE_RECORD_VALUE g_record_value_get_type()
-#define G_RECORD_VALUE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_RECORD_VALUE, GRecordValue))
-#define G_IS_RECORD_VALUE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_RECORD_VALUE))
-#define G_RECORD_VALUE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_RECORD_VALUE, GRecordValueClass))
-#define G_IS_RECORD_VALUE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_RECORD_VALUE))
-#define G_RECORD_VALUE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_RECORD_VALUE, GRecordValueClass))
+#define G_TYPE_RECORD_DELAYED g_record_delayed_get_type()
+#define G_RECORD_DELAYED(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_RECORD_DELAYED, GRecordDelayed))
+#define G_IS_RECORD_DELAYED(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_RECORD_DELAYED))
+#define G_RECORD_DELAYED_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_RECORD_DELAYED, GRecordDelayedClass))
+#define G_IS_RECORD_DELAYED_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_RECORD_DELAYED))
+#define G_RECORD_DELAYED_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_RECORD_DELAYED, GRecordDelayedClass))
/* Valeur calculée selon des correspondances parallèles (instance) */
-typedef struct _GRecordValue GRecordValue;
+typedef struct _GRecordDelayed GRecordDelayed;
/* Valeur calculée selon des correspondances parallèles (classe) */
-typedef struct _GRecordValueClass GRecordValueClass;
+typedef struct _GRecordDelayedClass GRecordDelayedClass;
/* Indique le type défini pour une valeur calculée selon des correspondances établies. */
-GType g_record_value_get_type(void);
+GType g_record_delayed_get_type(void);
/* Crée une nouvelle valeur calculée à partir d'une instance. */
-GRecordValue *g_record_value_new(GKaitaiInstance *, const kaitai_scope_t *);
+GRecordDelayed *g_record_delayed_new(GKaitaiInstance *, const kaitai_scope_t *, GBinContent *);
/* Détermine la valeur d'un élément Kaitai entier calculé. */
-bool g_record_value_compute_value(const GRecordValue *, resolved_value_t *);
+bool g_record_delayed_compute_value(GRecordDelayed *, resolved_value_t *);
/* Détermine et ajuste la valeur d'un élément Kaitai calculé. */
-bool g_record_value_compute_and_aggregate_value(const GRecordValue *, resolved_value_t *);
+bool g_record_delayed_compute_and_aggregate_value(GRecordDelayed *, resolved_value_t *);
-#endif /* _PLUGINS_KAITAI_RECORDS_VALUE_H */
+#endif /* _PLUGINS_KAITAI_RECORDS_DELAYED_H */
generated by cgit v0.11.2-87-g4458 at 2024-12-27 09:21:01 (GMT)