/* Chrysalide - Outil d'analyse de fichiers binaires
* delayed.c - conservation d'une correspondance entre attribut et binaire
*
* Copyright (C) 2019 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 .
*/
#include "delayed.h"
#include
#include
#include
#include "delayed-int.h"
#include "item.h"
#include "../parsers/attribute.h"
/* -------------------- DEFINITION D'UNE CORRESPONDANCE UNITAIRE -------------------- */
/* Initialise la classe des valeurs purement calculées. */
static void g_record_delayed_class_init(GRecordDelayedClass *);
/* Initialise une correspondance entre attribut et binaire. */
static void g_record_delayed_init(GRecordDelayed *);
/* Supprime toutes les références externes. */
static void g_record_delayed_dispose(GRecordDelayed *);
/* Procède à la libération totale de la mémoire. */
static void g_record_delayed_finalize(GRecordDelayed *);
/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
/* Calcule ou fournit la zone couverte par une correspondance. */
static void g_record_delayed_get_range(const GRecordDelayed *, mrange_t *);
/* ---------------------------------------------------------------------------------- */
/* DEFINITION D'UNE CORRESPONDANCE UNITAIRE */
/* ---------------------------------------------------------------------------------- */
/* Indique le type défini pour une valeur calculée selon des correspondances établies. */
G_DEFINE_TYPE(GRecordDelayed, g_record_delayed, G_TYPE_MATCH_RECORD);
/******************************************************************************
* *
* Paramètres : klass = classe à initialiser. *
* *
* Description : Initialise la classe des valeurs purement calculées. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
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_delayed_dispose;
object->finalize = (GObjectFinalizeFunc)g_record_delayed_finalize;
record = G_MATCH_RECORD_CLASS(klass);
record->get_range = (get_record_range_fc)g_record_delayed_get_range;
}
/******************************************************************************
* *
* Paramètres : delayed = instance à initialiser. *
* *
* Description : Initialise une correspondance entre attribut et binaire. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_record_delayed_init(GRecordDelayed *delayed)
{
init_record_scope(&delayed->locals, NULL);
delayed->real_record = NULL;
}
/******************************************************************************
* *
* Paramètres : delayed = instance d'objet GLib à traiter. *
* *
* Description : Supprime toutes les références externes. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_record_delayed_dispose(GRecordDelayed *delayed)
{
reset_record_scope(&delayed->locals);
G_OBJECT_CLASS(g_record_delayed_parent_class)->dispose(G_OBJECT(delayed));
}
/******************************************************************************
* *
* Paramètres : delayed = instance d'objet GLib à traiter. *
* *
* Description : Procède à la libération totale de la mémoire. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_record_delayed_finalize(GRecordDelayed *delayed)
{
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. *
* content = contenu binaire lié à la correspondance. *
* *
* Description : Crée une nouvelle valeur calculée à partir d'une instance. *
* *
* Retour : Instance mise en place ou NULL en cas d'échec. *
* *
* Remarques : - *
* *
******************************************************************************/
GRecordDelayed *g_record_delayed_new(GKaitaiInstance *inst, const kaitai_scope_t *locals, GBinContent *content)
{
GRecordDelayed *result; /* Structure à retourner */
result = g_object_new(G_TYPE_RECORD_DELAYED, NULL);
if (!g_record_delayed_create(result, inst, locals, content))
g_clear_object(&result);
return result;
}
/******************************************************************************
* *
* 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. *
* *
* Retour : Bilan de l'opération. *
* *
* Remarques : - *
* *
******************************************************************************/
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(delayed), G_KAITAI_PARSER(inst), content);
if (result)
copy_record_scope(&delayed->locals, locals);
return result;
}
/******************************************************************************
* *
* 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é. *
* *
* Retour : Bilan de l'opération. *
* *
* Remarques : - *
* *
******************************************************************************/
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(delayed));
assert(G_IS_KAITAI_ATTRIBUTE(parser));
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));
return result;
}
/******************************************************************************
* *
* 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é. *
* *
* Retour : Bilan de l'opération. *
* *
* Remarques : - *
* *
******************************************************************************/
bool g_record_delayed_compute_and_aggregate_value(GRecordDelayed *delayed, resolved_value_t *out)
{
bool result; /* Bilan à retourner */
sized_string_t converted; /* Conversion finale ? */
result = g_record_delayed_compute_value(delayed, out);
if (result)
{
/**
* Lorsque c'est possible, les tableaux Kaitai sont transformés en série
* d'octets.
*
* Même si les tableaux ont une grande portée en interne des règles
* Kaitai (par exemple pour constituer une table de constantes de
* référence), il en est différemment à l'extérieur du processus de
* traitement : les tableaux sont le plus souvent destinés à manipuler
* les octets représentés directement (par exemple :
* "contents: [0xca, 0xfe, 0xba, 0xbe]").
*
* Pour les valeurs d'instance dont le type n'est pas explicite,
* le choix est fait de tenter de simplifier la vie de l'utilisateur
* en lui fournissant directement les octets qu'il attend probablement
* plutôt qu'un tableau contenant des octets à extraire.
*/
if (out->type == GVT_ARRAY)
{
if (g_kaitai_array_convert_to_bytes(out->array, &converted))
{
EXIT_RESOLVED_VALUE(*out);
out->bytes = converted;
out->type = GVT_BYTES;
}
}
}
return result;
}
/* ---------------------------------------------------------------------------------- */
/* IMPLEMENTATION DES FONCTIONS DE CLASSE */
/* ---------------------------------------------------------------------------------- */
/******************************************************************************
* *
* Paramètres : delayed = 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_delayed_get_range(const GRecordDelayed *delayed, mrange_t *range)
{
copy_mrange(range, UNUSED_MRANGE_PTR);
}