diff options
Diffstat (limited to 'tools/coder.c')
| -rw-r--r-- | tools/coder.c | 1306 |
1 files changed, 39 insertions, 1267 deletions
diff --git a/tools/coder.c b/tools/coder.c index 3606bea..5856d80 100644 --- a/tools/coder.c +++ b/tools/coder.c @@ -25,32 +25,23 @@ #include <assert.h> -#include <ctype.h> #include <fcntl.h> -#include <inttypes.h> #include <malloc.h> #include <regex.h> #include <stdint.h> #include <stdio.h> #include <string.h> #include <unistd.h> -#include <sys/param.h> +#include "helpers.h" -/* -------------------------- CONSTRUCTION SELON COMMANDES -------------------------- */ -/* Conversion des chaînes en chaînes */ -typedef struct _string_exch -{ - const char *src; /* Chaîne à trouver */ - const char *dest; /* Chaîne de remplacement */ +/* -------------------------- CONSTRUCTION SELON COMMANDES -------------------------- */ -} string_exch; -struct _encoding_spec; /* Suivi des constructions */ @@ -60,89 +51,24 @@ struct _rented_coder const char *arch; /* Architecture à traiter */ const char *header; /* En-tête pour les en-têtes */ - string_exch *macros; /* Remplacements de chaînes */ - size_t macros_count; /* Nombre de ces remplacements */ - - string_exch *encodings; /* Traductions d'encodages */ - size_t encodings_count; /* Nombre de ces traductions */ + pre_processor *pp; /* Pré-processeur avec macros */ char *copyright; /* Récupération des droits */ char *ins; /* Désignation humaine */ char *details; /* Eventuels compléments */ - struct _encoding_spec *specs; /* Définitions déjà en place */ + encoding_spec **specs; /* Définitions déjà en place */ size_t specs_count; /* Nombre de ces définitions */ - struct _encoding_spec *cur_spec; /* Définition courante */ + encoding_spec *cur_spec; /* Définition courante */ }; -/* Recherche l'existence d'une macro pour un remplacement. */ -static const char *find_macro_in_coder(const rented_coder *, const char *); - /* --------------------------- REPRESENTATION D'ENCODAGES --------------------------- */ -struct _dec_bitfield; -struct _syntax_item; -struct _conv_func; -struct _extra_rule; - - -/* Mémorisation d'un encodage complet */ -typedef struct _encoding_spec -{ - char *prefix; /* Distinction principale */ - unsigned int index; /* Distinction secondaire */ - - struct _dec_bitfield *bitfields; /* Champs de bits détectés */ - size_t bf_count; /* Nombre de ces champs */ - uint64_t bits; /* Bits invariables */ - uint64_t mask; /* Emplacement de ces bits */ - unsigned int curpos; /* Position pendant l'analyse */ - - struct _syntax_item *items; /* Eléments de la syntaxe */ - size_t items_count; /* Nombre de ces éléments */ - - struct _conv_func *conversions; /* Conversions des données */ - size_t conv_count; /* Nombre de ces conversions */ - - struct _extra_rule *rules; /* Régles supplémentaires */ - size_t rules_count; /* Nombre de ces règles */ - -} encoding_spec; - - -/* Libère de la mémoire une spécification d'encodage. */ -static void free_encoding_spec(encoding_spec *); - - - -/* ---------------------------- SYNTAXE DES INSTRUCTIONS ---------------------------- */ - - -/* Propriétés particulières pour les opérandes */ -typedef enum _SyntaxItemFlags -{ - SIF_NONE = (0 << 0), /* Aucune propriété */ - SIF_DECIMAL = (1 << 0) /* Affichage en décimal */ - -} SyntaxItemFlags; - -/* Elément défini dans une syntaxe */ -typedef struct _syntax_item -{ - char *name; /* Désignation humaine */ - bool internal; /* Enregistrement générique ? */ - SyntaxItemFlags flags; /* Propriétés supplémentaires */ - -} syntax_item; - - -/* Libère de la mémoire tous les éléments de syntaxe. */ -static void free_all_syntax_items_in_spec(encoding_spec *); @@ -161,11 +87,6 @@ typedef struct _dec_bitfield -/* Recherche un champ donné dans une définition. */ -static const dec_bitfield *find_named_field_in_spec(const encoding_spec *, const char *); - -/* Libère de la mémoire toutes les champs de bits définis. */ -static void free_all_bitfields_in_spec(encoding_spec *); @@ -182,67 +103,6 @@ typedef struct _conv_func } conv_func; -/* Libère de la mémoire toutes les conversions enregistrées. */ -static void free_all_conversion_in_spec(encoding_spec *); - -/* Recherche une fonction converrtissant une donnée brute. */ -static const conv_func *find_conversion_in_coder_spec(const encoding_spec *, const char *); - - - -/* --------------------------- CONDITIONS ET CONSEQUENCES --------------------------- */ - - -/* Expression d'une condition */ -struct _cond_expr -{ - bool is_simple; /* Sélection de champ */ - - union - { - struct - { - char *variable; /* Variable manipulée */ - CondCompType comp; /* Type de comparaison */ - char *bvalue; /* Valeur binaire comparée */ - - } simple; - - struct - { - cond_expr *a; /* Première sous-expression */ - CondOpType operator; /* Relation entre expressions */ - cond_expr *b; /* Seconde sous-expression */ - - } composed; - - }; - -}; - -/* Règles particulières */ -typedef struct _extra_rule -{ - cond_expr *expr; /* Expression de déclenchement */ - CondActionType action; /* Conséquence d'une validation*/ - char *details; /* Eventuel complément d'info. */ - -} extra_rule; - - -/* Libère de la mémoire une expression conditionnelle. */ -static void free_cond_expr(cond_expr *); - -/* Traduit en code une expression de condition. */ -static bool write_cond_expr(const encoding_spec *, int, const cond_expr *); - -/* Libère de la mémoire des règles. */ -static void free_all_coder_spec_rules(encoding_spec *); - -/* Traduit en code les éventuelles règles présentes. */ -static bool write_coder_spec_rules(const rented_coder *, int, const encoding_spec *, bool *); - - /* --------------------------- GENERATIONS DE CODE SOURCE --------------------------- */ @@ -253,23 +113,6 @@ static int create_code_file(const rented_coder *, const char *, const char *, co /* Ecrit une partie des fonctions issues des spécifications. */ static bool dump_all_matching_specs_in_coder(const rented_coder *, const string_exch *, int, int); -/* Traduit en code une sous-fonction de désassemblage. */ -static bool write_coder_spec_disass(const rented_coder *, int, const encoding_spec *, const char *, unsigned int); - - - -/* ---------------------------- MANIPULATIONS DE CHAINES ---------------------------- */ - - -/* Bascule toute une chaîne de caractères en (min|maj)uscules. */ -static char *_make_string_xxx(char *, int (* fn) (int)); - -#define make_string_lower(str) _make_string_xxx(str, tolower) -#define make_string_upper(str) _make_string_xxx(str, toupper) - -/* Traduit une chaîne en élément de fonction C. */ -static char *make_callable(const char *raw, bool); - /* ---------------------------------------------------------------------------------- */ @@ -295,7 +138,9 @@ rented_coder *create_coder(void) result = (rented_coder *)calloc(1, sizeof(rented_coder)); - result->cur_spec = (encoding_spec *)calloc(1, sizeof(encoding_spec)); + result->pp = create_pre_processor(); + + result->cur_spec = create_encoding_spec(); return result; @@ -318,11 +163,7 @@ void delete_coder(rented_coder *coder) { size_t i; /* Boucle de parcours */ - if (coder->macros != NULL) - free(coder->macros); - - if (coder->encodings != NULL) - free(coder->encodings); + delete_pre_processor(coder->pp); if (coder->ins != NULL) free(coder->ins); @@ -331,14 +172,12 @@ void delete_coder(rented_coder *coder) free(coder->details); for (i = 0; i < coder->specs_count; i++) - free_encoding_spec(&coder->specs[i]); + delete_encoding_spec(coder->specs[i]); if (coder->specs != NULL) free(coder->specs); - free_encoding_spec(coder->cur_spec); - - free(coder->cur_spec); + delete_encoding_spec(coder->cur_spec); free(coder); @@ -427,84 +266,18 @@ void set_coder_header_base(rented_coder *coder, const char *header) /****************************************************************************** * * * Paramètres : coder = gestion par la machine en remplacement de l'humain. * -* src = chaîne à remplacer dans les définitions. * -* dest = chaîne de remplacement. * * * -* Description : Enregistre une correspondance en matière d'encodage. * +* Description : Fournit le pré-processeur du compilateur. * * * -* Retour : - * +* Retour : Pré-processeur à manipuler. * * * * Remarques : - * * * ******************************************************************************/ -void register_encoding_in_coder(rented_coder *coder, const char *src, const char *dest) +pre_processor *get_coder_pre_proc(const rented_coder *coder) { - string_exch *encoding; /* Traduction à conserver */ - - coder->encodings = (string_exch *)realloc(coder->encodings, ++coder->encodings_count * sizeof(string_exch)); - - encoding = &coder->encodings[coder->encodings_count - 1]; - - encoding->src = src; - encoding->dest = dest; - -} - - -/****************************************************************************** -* * -* Paramètres : coder = gestion par la machine en remplacement de l'humain. * -* src = chaîne à remplacer dans les définitions. * -* dest = chaîne de remplacement. * -* * -* Description : Constitue la matière d'un système de macros. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -void define_macro_for_coder(rented_coder *coder, const char *src, const char *dest) -{ - string_exch *macro; /* Nouvelle macro à constituer */ - - coder->macros = (string_exch *)realloc(coder->macros, ++coder->macros_count * sizeof(string_exch)); - - macro = &coder->macros[coder->macros_count - 1]; - - macro->src = src; - macro->dest = dest; - -} - - -/****************************************************************************** -* * -* Paramètres : coder = gestion par la machine en remplacement de l'humain. * -* src = chaîne à remplacer dans les définitions. * -* * -* Description : Recherche l'existence d'une macro pour un remplacement. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static const char *find_macro_in_coder(const rented_coder *coder, const char *src) -{ - const char *result; /* Trouvaille à renvoyer */ - size_t i; /* Boucle de parcours */ - - result = NULL; - - for (i = 0; i < coder->macros_count && result == NULL; i++) - if (strcmp(coder->macros[i].src, src) == 0) - result = coder->macros[i].dest; - - return result; + return coder->pp; } @@ -542,599 +315,29 @@ void save_notes_for_coder(rented_coder *coder, char *copy, char *ins, const char /****************************************************************************** * * * Paramètres : coder = gestion par la machine en remplacement de l'humain. * -* prefix = distinction principale entre les définitions. * -* index = distinction secondaire entre les définitions. * -* * -* Description : Enregistre une définition supplémentaire. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -void push_encoding_spec(rented_coder *coder, char *prefix, unsigned int index) -{ - encoding_spec *spec; /* Définition à compléter */ - - spec = coder->cur_spec; - - spec->prefix = prefix; - spec->index = index; - - coder->specs = (encoding_spec *)realloc(coder->specs, ++coder->specs_count * sizeof(encoding_spec)); - - coder->specs[coder->specs_count - 1] = *spec; - - memset(spec, 0, sizeof(encoding_spec)); - -} - - -/****************************************************************************** -* * -* Paramètres : spec = spécification d'encodage en cours de libération. * -* * -* Description : Libère de la mémoire une spécification d'encodage. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void free_encoding_spec(encoding_spec *spec) -{ - free_all_syntax_items_in_spec(spec); - - free_all_bitfields_in_spec(spec); - - free_all_conversion_in_spec(spec); - - free_all_coder_spec_rules(spec); - -} - - - -/* ---------------------------------------------------------------------------------- */ -/* GESTION DES CHAMPS DE BITS */ -/* ---------------------------------------------------------------------------------- */ - - -/****************************************************************************** -* * -* Paramètres : coder = gestion par la machine en remplacement de l'humain. * -* name = désignation humaine du champ remarqué. * -* length = taille du champ à mémoriser. * -* * -* Description : Note la présence d'un champ remarquable dans une définition. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -void register_named_field_in_coder(rented_coder *coder, char *name, unsigned int length) -{ - encoding_spec *spec; /* Définition à compléter */ - dec_bitfield *field; /* Nouveau champ à constituer */ - - spec = coder->cur_spec; - - assert((spec->curpos + length) < 64); - - spec->bitfields = (dec_bitfield *)realloc(spec->bitfields, - ++spec->bf_count * sizeof(dec_bitfield)); - - field = &spec->bitfields[spec->bf_count - 1]; - - field->name = make_string_lower(name); - field->start = spec->curpos; - field->length = length; - - spec->curpos += length; - -} - - -/****************************************************************************** -* * -* Paramètres : spec = spécification d'encodage à parcourir. * -* name = désignation humaine du champ à retrouver. * -* * -* Description : Recherche un champ donné dans une définition. * -* * -* Retour : Structure associée au champ trouvé ou NULL en cas d'échec. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static const dec_bitfield *find_named_field_in_spec(const encoding_spec *spec, const char *name) -{ - dec_bitfield *result; /* Champ de bits à retourner */ - size_t i; /* Boucle de parcours */ - - result = NULL; - - for (i = 0; i < spec->bf_count && result == NULL; i++) - if (strcmp(spec->bitfields[i].name, name) == 0) - result = &spec->bitfields[i]; - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : coder = gestion par la machine en remplacement de l'humain. * -* val = valeur du bit à prendre en compte. * -* * -* Description : Note la présence d'un bit invariable dans une définition. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -void register_bit_in_coder(rented_coder *coder, int val) -{ - encoding_spec *spec; /* Définition à compléter */ - - spec = coder->cur_spec; - - assert(spec->curpos < 64); - - spec->bits |= (val ? 1 : 0) << spec->curpos; - spec->mask |= 1 << spec->curpos; - - spec->curpos++; - -} - - -/****************************************************************************** -* * -* Paramètres : spec = spécification d'encodage en cours de libération. * -* * -* Description : Libère de la mémoire toutes les champs de bits définis. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void free_all_bitfields_in_spec(encoding_spec *spec) -{ - size_t i; /* Boucle de parcours */ - - for (i = 0; i < spec->bf_count; i++) - free(spec->bitfields[i].name); - - if (spec->bitfields != NULL) - { - free(spec->bitfields); - spec->bitfields = NULL; - } - - spec->bf_count = 0; - - spec->bits = 0; - spec->mask = 0; - - spec->curpos = 0; - -} - - - -/****************************************************************************** -* * -* Paramètres : coder = gestion par la machine en remplacement de l'humain. * -* * -* Description : Indique le nombre de bits traités. * -* * -* Retour : Quantité, positive ou nulle. * -* * -* Remarques : - * -* * -******************************************************************************/ - -unsigned int count_coder_bits(const rented_coder *coder) -{ - return coder->cur_spec->curpos; - -} - - - -/* ---------------------------------------------------------------------------------- */ -/* SYNTAXE DES INSTRUCTIONS */ -/* ---------------------------------------------------------------------------------- */ - - -/****************************************************************************** -* * -* Paramètres : coder = gestion par la machine en remplacement d'humain. * -* name = désignation de l'opérande dans la spécification. * -* internal = précise si l'opérand est non générique ou non. * -* * -* Description : Enregistre la présence d'un nouvel opérande. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -void register_syntax_item_in_coder(rented_coder *coder, char *name, bool internal) -{ - encoding_spec *spec; /* Définition à compléter */ - syntax_item *item; /* Nouvelle prise en compte */ - size_t len; /* Taille du nom fourni */ - - spec = coder->cur_spec; - - spec->items = (syntax_item *)realloc(spec->items, ++spec->items_count * sizeof(syntax_item)); - - item = &spec->items[spec->items_count - 1]; - - /* Récupération des drapeaux */ - - item->flags = SIF_NONE; - - for (len = strlen(name); len > 0; len--) - switch (name[0]) - { - case '#': - item->flags |= SIF_DECIMAL; - memmove(name, name + 1, len); - break; - - default: - len = 1; - break; - - } - - item->name = make_string_lower(name); - item->internal = internal; - -} - - -/****************************************************************************** -* * -* Paramètres : spec = spécification d'encodage en cours de libération. * -* * -* Description : Libère de la mémoire tous les éléments de syntaxe. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void free_all_syntax_items_in_spec(encoding_spec *spec) -{ - size_t i; /* Boucle de parcours */ - - for (i = 0; i < spec->items_count; i++) - free(spec->items[i].name); - - if (spec->items != NULL) - { - free(spec->items); - spec->items = NULL; - } - - spec->items_count = 0; - -} - - - -/* ---------------------------------------------------------------------------------- */ -/* CONVERSION DES ARGUMENTS */ -/* ---------------------------------------------------------------------------------- */ - - -/****************************************************************************** -* * -* Paramètres : coder = gestion par la machine en remplacement de l'humain. * -* dest = désignation de la variable de destination. * -* func = nom de la fonction assurant le calcul de valeur. * -* arg = argument à fournir à cette fonction. * -* * -* Description : Enregistre la function de conversion du brut à l'utile. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -void register_conversion_in_coder(rented_coder *coder, char *dest, char *func, char *arg) -{ - encoding_spec *spec; /* Définition à compléter */ - conv_func *conv; /* Nouvelle prise en compte */ - - spec = coder->cur_spec; - - spec->conversions = (conv_func *)realloc(spec->conversions, ++spec->conv_count * sizeof(conv_func)); - - conv = &spec->conversions[spec->conv_count - 1]; - - conv->dest = make_string_lower(dest); - conv->func = func; - conv->arg = make_string_lower(arg); - -} - - -/****************************************************************************** -* * -* Paramètres : spec = spécification d'encodage en cours de libération. * -* * -* Description : Libère de la mémoire toutes les conversions enregistrées. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void free_all_conversion_in_spec(encoding_spec *spec) -{ - size_t i; /* Boucle de parcours */ - conv_func *conv; /* Conversion à traiter */ - - for (i = 0; i < spec->conv_count; i++) - { - conv = &spec->conversions[i]; - - free(conv->dest); - free(conv->func); - free(conv->arg); - - } - - if (spec->conversions != NULL) - { - free(spec->conversions); - spec->conversions = NULL; - } - - spec->conv_count = 0; - -} - - -/****************************************************************************** -* * -* Paramètres : spec = spécification d'un encodage à consulter. * -* dest = désignation d'une variable de destination. * -* * -* Description : Recherche une fonction converrtissant une donnée brute. * -* * -* Retour : Structure de conversion trouvée ou NULL en cas d'échec. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static const conv_func *find_conversion_in_coder_spec(const encoding_spec *spec, const char *dest) -{ - const conv_func *result; /* Conversion à renvoyer */ - size_t i; /* Boucle de parcours */ - - result = NULL; - - for (i = 0; i < spec->conv_count && result == NULL; i++) - if (strcmp(spec->conversions[i].dest, dest) == 0) - result = &spec->conversions[i]; - - return result; - -} - - - -/* ---------------------------------------------------------------------------------- */ -/* CONDITIONS ET CONSEQUENCES */ -/* ---------------------------------------------------------------------------------- */ - - -/****************************************************************************** -* * -* Paramètres : variable = désignation de la variable à manipuler. * -* comp = type de comparaison à utiliser. * -* bvalue = valeur binaire à comparer. * -* * -* Description : Crée une expression conditionnelle simple. * -* * -* Retour : Structure mise en place. * -* * -* Remarques : - * -* * -******************************************************************************/ - -cond_expr *build_simple_cond_expression(char *variable, CondCompType comp, char *bvalue) -{ - cond_expr *result; /* Structure à retourner */ - - result = (cond_expr *)calloc(1, sizeof(cond_expr)); - - result->is_simple = true; - - result->simple.variable = make_string_lower(variable); - result->simple.comp = comp; - result->simple.bvalue = bvalue; - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : a = première expression à intégrer. * -* operator = type de comparaison à utiliser. * -* b = second expression à intégrer. * * * -* Description : Crée une expression conditionnelle composée. * +* Description : Fournit un lien vers les spécifications courantes. * * * -* Retour : Structure mise en place. * +* Retour : Spécification en cours d'édition. * * * * Remarques : - * * * ******************************************************************************/ -cond_expr *build_composed_cond_expression(cond_expr *a, CondOpType operator, cond_expr *b) +encoding_spec *get_current_encoding_spec(const rented_coder *coder) { - cond_expr *result; /* Structure à retourner */ - - result = (cond_expr *)calloc(1, sizeof(cond_expr)); - - result->is_simple = false; - - result->composed.a = a; - result->composed.operator = operator; - result->composed.b = b; - - return result; + return coder->cur_spec; } /****************************************************************************** * * -* Paramètres : expr = représentation d'expression à traiter. * -* * -* Description : Libère de la mémoire une expression conditionnelle. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void free_cond_expr(cond_expr *expr) -{ - if (expr->is_simple) - { - free(expr->simple.variable); - free(expr->simple.bvalue); - } - else - { - free_cond_expr(expr->composed.a); - free_cond_expr(expr->composed.b); - } - - free(expr); - -} - - -/****************************************************************************** -* * -* Paramètres : spec = spécification d'un encodage à consulter. * -* fd = descripteur d'un flux ouvert en écriture. * -* expr = expression simple ou composée à transposer. * -* * -* Description : Traduit en code une expression de condition. * -* * -* Retour : Bilan de l'opération. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static bool write_cond_expr(const encoding_spec *spec, int fd, const cond_expr *expr) -{ - bool result; /* Bilan à renvoyer */ - const dec_bitfield *bf; /* Champ de bits de définition */ - - result = true; - - dprintf(fd, "("); - - if (expr->is_simple) - { - bf = find_named_field_in_spec(spec, expr->simple.variable); - if (bf == NULL) - { - fprintf(stderr, "Error: no bitfield defined the requested variable '%s'.\n", expr->simple.variable); - result = false; - goto wce_exit; - } - - if (bf->length != strlen(expr->simple.bvalue)) - { - fprintf(stderr, "Error: variable '%s' and provided value sizes do not match (%u vs %zu).\n", - expr->simple.variable, bf->length, strlen(expr->simple.bvalue)); - result = false; - goto wce_exit; - } - - dprintf(fd, "raw_%s", expr->simple.variable); - - switch (expr->simple.comp) - { - case CCT_EQUAL: - dprintf(fd, " == "); - break; - case CCT_DIFF: - dprintf(fd, " != "); - break; - } - - dprintf(fd, "b%s", expr->simple.bvalue); - - } - else - { - result = write_cond_expr(spec, fd, expr->composed.a); - if (!result) goto wce_exit; - - switch (expr->composed.operator) - { - case COT_AND: - dprintf(fd, " && "); - break; - case COT_OR: - dprintf(fd, " || "); - break; - } - - result = write_cond_expr(spec, fd, expr->composed.b); - if (!result) goto wce_exit; - - } - - dprintf(fd, ")"); - - wce_exit: - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : coder = gestion par la machine en remplacement de l'humain.* -* expr = représentation d'expression à conserver. * -* action = conséquence associée à la règle. * -* details = éventuel complément d'informations. * +* Paramètres : coder = gestion par la machine en remplacement de l'humain. * +* prefix = distinction principale entre les définitions. * +* index = distinction secondaire entre les définitions. * * * -* Description : Ajoute une règle complète à la définition d'un codage. * +* Description : Enregistre une définition supplémentaire. * * * * Retour : - * * * @@ -1142,129 +345,18 @@ static bool write_cond_expr(const encoding_spec *spec, int fd, const cond_expr * * * ******************************************************************************/ -void add_conditional_rule_to_coder(rented_coder *coder, cond_expr *expr, CondActionType action, const char *details) +void push_encoding_spec(rented_coder *coder, char *prefix, unsigned int index) { encoding_spec *spec; /* Définition à compléter */ - extra_rule *rule; /* Nouvelle prise en compte */ spec = coder->cur_spec; - spec->rules = (extra_rule *)realloc(spec->rules, ++spec->rules_count * sizeof(extra_rule)); + define_encoding_spec_code_name(spec, prefix, index); - rule = &spec->rules[spec->rules_count - 1]; + coder->specs = (encoding_spec **)realloc(coder->specs, ++coder->specs_count * sizeof(encoding_spec *)); + coder->specs[coder->specs_count - 1] = spec; - rule->expr = expr; - rule->action = action; - rule->details = make_callable(details, false); - -} - - -/****************************************************************************** -* * -* Paramètres : spec = spécification d'encodage à traiter. * -* * -* Description : Libère de la mémoire des règles. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void free_all_coder_spec_rules(encoding_spec *spec) -{ - size_t i; /* Boucle de parcours */ - - for (i = 0; i < spec->rules_count; i++) - { - free_cond_expr(spec->rules[i].expr); - - if (spec->rules[i].details) - free(spec->rules[i].details); - - } - - if (spec->rules != NULL) - { - free(spec->rules); - spec->rules = NULL; - } - - spec->rules_count = 0; - -} - - -/****************************************************************************** -* * -* Paramètres : coder = gestion par la machine en remplacement de l'humain. * -* fd = descripteur d'un flux ouvert en écriture. * -* spec = spécification servant de base à l'opération. * -* exit = exprime le besoin d'une voie de sortie. [OUT] * -* * -* Description : Traduit en code les éventuelles règles présentes. * -* * -* Retour : Bilan de l'opération. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static bool write_coder_spec_rules(const rented_coder *coder, int fd, const encoding_spec *spec, bool *exit) -{ - bool result; /* Bilan à remonter */ - const extra_rule *rule; /* Règle en cours d'écriture */ - size_t i; /* Boucle de parcours */ - - result = true; - - *exit = false; - - for (i = 0; i < spec->rules_count; i++) - { - rule = &spec->rules[i]; - - dprintf(fd, "\t\tif "); - - result = write_cond_expr(spec, fd, rule->expr); - if (!result) break; - - dprintf(fd, "\n"); - dprintf(fd, "\t\t{\n"); - - switch (rule->action) - { - case CAT_SEE: - - if (rule->details == NULL) - { - fprintf(stderr, "Error: directive 'see' must provide additional details.\n"); - result = false; - goto wcsr_exit; - } - - dprintf(fd, "\t\t\tinstr = armv7_read_instr_%s", rule->details); - - /* TODO : adapter les paramètres d'appel selon le 'coder' */ - dprintf(fd, "(_raw);\n"); - - dprintf(fd, "\t\t\tgoto quick_exit;\n"); - - *exit = true; - break; - - } - - dprintf(fd, "\t\t}\n"); - - dprintf(fd, "\n"); - - } - - wcsr_exit: - - return result; + coder->cur_spec = create_encoding_spec(); } @@ -1360,7 +452,7 @@ bool dump_all_routines_using_coder(const rented_coder *coder) { bool result; /* Bilan à retourner */ size_t i; /* Boucle de parcours */ - string_exch *encoding; /* Type d'encodage visé */ + const string_exch *encoding; /* Type d'encodage visé */ bool exist; /* Présence du fichier visé ? */ int header_fd; /* Fichier de déclarations */ char *dash; /* Présence d'un tiret ? */ @@ -1369,9 +461,9 @@ bool dump_all_routines_using_coder(const rented_coder *coder) result = true; - for (i = 0; i < coder->encodings_count && result; i++) + for (i = 0; i < count_encodings(coder->pp) && result; i++) { - encoding = &coder->encodings[i]; + encoding = find_encoding(coder->pp, i); /* Fichier de déclarations */ @@ -1462,6 +554,7 @@ static bool dump_all_matching_specs_in_coder(const rented_coder *coder, const st unsigned int wide; /* Taille des mots */ size_t i; /* Boucle de parcours */ encoding_spec *spec; /* Définition à traiter */ + coding_bits *bits; /* Gestionnaire de bits */ size_t maxlen; /* Taille à compléter */ result = true; @@ -1474,12 +567,13 @@ static bool dump_all_matching_specs_in_coder(const rented_coder *coder, const st for (i = 0; i < coder->specs_count; i++) { - spec = &coder->specs[i]; + spec = coder->specs[i]; - if (strcmp(encoding->src, spec->prefix) != 0) + if (!has_encoding_spec_prefix(spec, encoding->src)) continue; - wide = spec->curpos; + bits = get_bits_in_encoding_spec(spec); + wide = count_coded_bits(bits); break; } @@ -1532,12 +626,12 @@ static bool dump_all_matching_specs_in_coder(const rented_coder *coder, const st for (i = 0; i < coder->specs_count && result; i++) { - spec = &coder->specs[i]; + spec = coder->specs[i]; - if (strcmp(encoding->src, spec->prefix) != 0) + if (!has_encoding_spec_prefix(spec, encoding->src)) continue; - result = write_coder_spec_disass(coder, cfd, spec, keyword, wide); + result = write_encoding_spec_disass(spec, cfd, coder->arch, coder->ins, coder->details, wide, coder->pp); } @@ -1554,325 +648,3 @@ static bool dump_all_matching_specs_in_coder(const rented_coder *coder, const st return result; } - - -/****************************************************************************** -* * -* Paramètres : coder = gestion par la machine en remplacement de l'humain.* -* fd = descripteur d'un flux ouvert en écriture. * -* spec = spécification servant de base à l'opération. * -* keyword = nom clef de l'instruction utilisable dans du code. * -* wide = taille des mots manipulés (en bits). * -* * -* Description : Traduit en code une sous-fonction de désassemblage. * -* * -* Retour : Bilan de l'opération. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static bool write_coder_spec_disass(const rented_coder *coder, int fd, const encoding_spec *spec, const char *keyword, unsigned int wide) -{ - size_t i; /* Boucle de parcours */ - dec_bitfield *bf; /* Accès confortable à un champ*/ - bool exit; /* Inclusion de sortie rapide ?*/ - syntax_item *item; /* Lien vers un opérande */ - regex_t preg; /* Expression régulière */ - int ret; /* Bilan d'une manipulation */ - const conv_func *conv; /* Moyen de conversion du brut */ - const char *callable; /* Fonction à appeler */ - bool rebuild; /* Construction complexe */ - regmatch_t pmatch[3]; /* Correspondances de chaînes */ - size_t cmplen; /* Taille de comparaison */ - char *cast; /* Macro de transtypage */ - - dprintf(fd, "\tGArchInstruction *%s_decode_%s%s_%s%u(uint%u_t _raw)\n", - coder->arch, keyword, coder->details, spec->prefix, spec->index, wide); - - dprintf(fd, "\t{\n"); - - dprintf(fd, "\t\tGArchInstruction *instr;\n"); - - /* Déclaration des champs à retrouver */ - - for (i = 0; i < spec->bf_count; i++) - dprintf(fd, "\t\tuint%u_t raw_%s;\n", wide, spec->bitfields[i].name); - - for (i = 0; i < spec->items_count; i++) - if (!spec->items[i].internal) - { - dprintf(fd, "\t\tGArchOperand *op;\n"); - break; - } - - dprintf(fd, "\n"); - - /* Vérification que le décodage est possible */ - - dprintf(fd, "\t\tif ((raw & 0x%" PRIx64 ") != 0x%" PRIx64 ") return NULL;\n", spec->mask, spec->bits); - - dprintf(fd, "\n"); - - /* Définition des champs bruts */ - - for (i = 0; i < spec->bf_count; i++) - { - bf = &spec->bitfields[i]; - dprintf(fd, "\t\traw_%s = (_raw >> %u) & 0x%llx;\n", bf->name, bf->start, (1ull << bf->length) - 1); - } - - dprintf(fd, "\n"); - - /* Inclusion des éventuelles règles */ - - if (!write_coder_spec_rules(coder, fd, spec, &exit)) - return false; - - /* Création de l'instruction en elle-même */ - - dprintf(fd, "\t\tinstr = g_%s_instruction_new(\"%s\");\n", coder->arch, coder->ins); - - dprintf(fd, "\n"); - - /* Création des opérandes */ - - bool build_arg_if_needed(const conv_func *conv) - { - - /* TODO : concaténation... */ - - return false; - - } - - ret = regcomp(&preg, "(g_([a-z0-9]*)_instruction)", REG_EXTENDED); - if (ret != 0) - { - fprintf(stderr, "Internal error: bad regular expression.\n"); - return false; - } - - - for (i = 0; i < spec->items_count; i++) - { - item = &spec->items[i]; - - conv = find_conversion_in_coder_spec(spec, item->name); - if (conv == NULL) - { - fprintf(stderr, "Error: expected conversion for '%s'.\n", item->name); - return false; - } - - callable = find_macro_in_coder(coder, conv->func); - if (callable == NULL) - { - fprintf(stderr, "Error: expected function to store '%s'.\n", item->name); - return false; - } - - rebuild = build_arg_if_needed(conv); - - if (item->internal) - { - ret = regexec(&preg, callable, sizeof(pmatch) / sizeof(regmatch_t), pmatch, 0); - if (ret == REG_NOMATCH) - { - fprintf(stderr, "Internal error: bad function for dealing wih instruction: '%s'.\n", callable); - return false; - } - - /** - * La variable de résultat est de type 'GArchInstruction', - * donc toute fonction différente de g_arch_instruction_*() attend un transtypage... - */ - - cmplen = MAX(strlen(coder->arch), pmatch[2].rm_eo - pmatch[2].rm_so); - - if (strncmp("arch", &callable[pmatch[2].rm_so], cmplen) == 0) - dprintf(fd, "\t\tif (!%s(instr, %s%s))\n", - callable, rebuild ? "" : "raw_", rebuild ? item->name : conv->arg); - - else - { - cast = strndup(&callable[pmatch[1].rm_so], pmatch[1].rm_eo - pmatch[1].rm_so); - - cast = make_string_upper(cast); - - dprintf(fd, "\t\tif (!%s(%s(instr), %s%s))\n", - callable, cast, rebuild ? "" : "raw_", rebuild ? item->name : conv->arg); - - free(cast); - - } - - dprintf(fd, "\t\t\tgoto bad_exit;\n"); - - } - - else - { - if (strchr(callable, '(') == NULL) - dprintf(fd, "\t\top = %s(%s%s);\n", - callable, rebuild ? "" : "raw_", rebuild ? item->name : conv->arg); - else - dprintf(fd, "\t\top = %s%s%s);\n", - callable, rebuild ? "" : "raw_", rebuild ? item->name : conv->arg); - dprintf(fd, "\t\tif (op == NULL) goto bad_exit;\n"); - - dprintf(fd, "\n"); - - if (item->flags & SIF_DECIMAL) - dprintf(fd, "\t\tg_imm_operand_set_display(G_IMM_OPERAND(op), IOD_DEC);\n"); - - dprintf(fd, "\t\tg_arch_instruction_attach_extra_operand(instr, op);\n"); - - } - - dprintf(fd, "\n"); - - } - - regfree(&preg); - - /* Conclusion de la procédure */ - - if (exit) - { - dprintf(fd, "\t quick_exit:\n"); - dprintf(fd, "\n"); - } - - dprintf(fd, "\t\treturn instr;\n"); - - dprintf(fd, "\n"); - - dprintf(fd, "\t bad_exit:\n"); - - dprintf(fd, "\n"); - - dprintf(fd, "\t\tg_object_unref(G_OBJECT(instr));\n"); - dprintf(fd, "\t\treturn NULL;\n"); - - dprintf(fd, "\n"); - - dprintf(fd, "\t}\n"); - - dprintf(fd, "\n"); - - dprintf(fd, "\tif (result == NULL)\n"); - dprintf(fd, "\t\tresult = %s_decode_%s%s_%s%u(raw);\n", - coder->arch, keyword, coder->details, spec->prefix, spec->index); - - dprintf(fd, "\n"); - - return true; - -} - - - -/* ---------------------------------------------------------------------------------- */ -/* MANIPULATIONS DE CHAINES */ -/* ---------------------------------------------------------------------------------- */ - - -/****************************************************************************** -* * -* Paramètres : str = chaîne de caractères à manipuler. [OUT] * -* * -* Description : Bascule toute une chaîne de caractères en (min|maj)uscules. * -* * -* Retour : Pointeur sur la chaîne fournie. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static char *_make_string_xxx(char *str, int (* fn) (int)) -{ - size_t max; /* Empleur du parcours */ - size_t i; /* Boucle de parcours */ - - max = strlen(str); - - for (i = 0; i < max; i++) - str[i] = fn(str[i]); - - return str; - -} - - -/****************************************************************************** -* * -* Paramètres : raw = données brutes en provenance de l'analyseur. * -* details = indique la nature de la chaîne à traiter. * -* * -* Description : Traduit une chaîne en élément de fonction C. * -* * -* Retour : Chaîne à libérer de la mémoire après usage. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static char *make_callable(const char *raw, bool details) -{ - char *result; /* Nom formaté à retourner */ - size_t max; /* Empleur du parcours */ - size_t i; /* Boucle de parcours */ - - result = strdup(raw); - - max = strlen(result); - - /* Première passe : on vire les virgules */ - - for (i = 0; i < max; i++) - if (result[i] == ',') - { - memmove(result + i, result + i + 1, max - i - 1); - max--; - } - - result[max] = '\0'; - - /* Deuxième passe : on bascule en minuscules */ - - result = make_string_lower(result); - - /* Troisième passe : on remplace les mauvais caractères */ - - for (i = 0; i < max; i++) - switch (result[i]) - { - case 'a' ... 'z': - case '0' ... '9': - break; - case '-': - result[i] = '_'; - break; - default: - result[i] = (i + 1 == max ? '\0' : '_'); - break; - } - - /** - * Dernière passe : on s'assure que le premier caractère n'est pas une lettre. - * On ajoute ici le préfixe '_' utilisé lors de la génération de prototypes ; - * en cas d'absence de détails, on ne se retrouve ainsi pas avec un '_' isolé. - */ - - if (details && result[0] != '_') - { - max = strlen(result) + 1; - result = (char *)realloc(result, max); - memmove(result + 1, result, max - 1); - result[0] = '_'; - } - - return result; - -} |