summaryrefslogtreecommitdiff
path: root/src/format/mangling/itanium/abi.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/format/mangling/itanium/abi.c')
-rw-r--r--src/format/mangling/itanium/abi.c2444
1 files changed, 0 insertions, 2444 deletions
diff --git a/src/format/mangling/itanium/abi.c b/src/format/mangling/itanium/abi.c
deleted file mode 100644
index 5645a05..0000000
--- a/src/format/mangling/itanium/abi.c
+++ /dev/null
@@ -1,2444 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * abi.c - décodage des noms d'éléments selon l'ABI C++ Itanium
- *
- * Copyright (C) 2013-2017 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 Foobar. If not, see <http://www.gnu.org/licenses/>.
- */
-
-
-#include "abi.h"
-
-
-#include <ctype.h>
-#include <stdlib.h>
-
-
-
-#include "../../../analysis/types/basic.h"
-#include "../../../common/cpp.h"
-
-
-
-/* Liste des opérateurs reconnus */
-
-#define IDT_NL(s) s, sizeof(s) - 1
-
-const itanium_operator_info itanium_demangle_operators[] = {
-
- { "aN", IDT_NL("&="), 2 },
- { "aS", IDT_NL("="), 2 },
- { "aa", IDT_NL("&&"), 2 },
- { "ad", IDT_NL("&"), 1 },
- { "an", IDT_NL("&"), 2 },
- { "at", IDT_NL("alignof "), 1 },
- { "az", IDT_NL("alignof "), 1 },
- { "cc", IDT_NL("const_cast"), 2 },
- { "cl", IDT_NL("()"), 2 },
- { "cm", IDT_NL(","), 2 },
- { "co", IDT_NL("~"), 1 },
- { "dV", IDT_NL("/="), 2 },
- { "da", IDT_NL("delete[] "), 1 },
- { "dc", IDT_NL("dynamic_cast"), 2 },
- { "de", IDT_NL("*"), 1 },
- { "dl", IDT_NL("delete "), 1 },
- { "ds", IDT_NL(".*"), 2 },
- { "dt", IDT_NL("."), 2 },
- { "dv", IDT_NL("/"), 2 },
- { "eO", IDT_NL("^="), 2 },
- { "eo", IDT_NL("^"), 2 },
- { "eq", IDT_NL("=="), 2 },
- { "ge", IDT_NL(">="), 2 },
- { "gs", IDT_NL("::"), 1 },
- { "gt", IDT_NL(">"), 2 },
- { "ix", IDT_NL("[]"), 2 },
- { "lS", IDT_NL("<<="), 2 },
- { "le", IDT_NL("<="), 2 },
- { "li", IDT_NL("operator\"\" "), 1 },
- { "ls", IDT_NL("<<"), 2 },
- { "lt", IDT_NL("<"), 2 },
- { "mI", IDT_NL("-="), 2 },
- { "mL", IDT_NL("*="), 2 },
- { "mi", IDT_NL("-"), 2 },
- { "ml", IDT_NL("*"), 2 },
- { "mm", IDT_NL("--"), 1 },
- { "na", IDT_NL("new[]"), 3 },
- { "ne", IDT_NL("!="), 2 },
- { "ng", IDT_NL("-"), 1 },
- { "nt", IDT_NL("!"), 1 },
- { "nw", IDT_NL("new"), 3 },
- { "oR", IDT_NL("|="), 2 },
- { "oo", IDT_NL("||"), 2 },
- { "or", IDT_NL("|"), 2 },
- { "pL", IDT_NL("+="), 2 },
- { "pl", IDT_NL("+"), 2 },
- { "pm", IDT_NL("->*"), 2 },
- { "pp", IDT_NL("++"), 1 },
- { "ps", IDT_NL("+"), 1 },
- { "pt", IDT_NL("->"), 2 },
- { "qu", IDT_NL("?"), 3 },
- { "rM", IDT_NL("%="), 2 },
- { "rS", IDT_NL(">>="), 2 },
- { "rc", IDT_NL("reinterpret_cast"), 2 },
- { "rm", IDT_NL("%"), 2 },
- { "rs", IDT_NL(">>"), 2 },
- { "sc", IDT_NL("static_cast"), 2 },
- { "st", IDT_NL("sizeof "), 1 },
- { "sz", IDT_NL("sizeof "), 1 },
- { "tr", IDT_NL("throw"), 0 },
- { "tw", IDT_NL("throw "), 1 }
-};
-
-/* Substitutions standards */
-
-typedef struct _itanium_std_subst_info
-{
- char code; /* Identifiant associé */
-
- const char *simple; /* Représentation simple */
- size_t simple_len; /* Taille de cette représentat°*/
-
- const char *full; /* Représentation complète */
- size_t full_len; /* Taille de cette représentat°*/
-
- const char *last_name; /* Pour les (con|de)structeurs */
- size_t last_name_len; /* Taille de cette indication */
-
-} itanium_std_subst_info;
-
-const itanium_std_subst_info itanium_standard_substitutions[] = {
-
- {
- 't',
- IDT_NL("std"),
- IDT_NL("std"),
- NULL,
- 0
- },
- {
- 'a',
- IDT_NL("std::allocator"),
- IDT_NL("std::allocator"),
- IDT_NL("allocator")
- },
- {
- 'b',
- IDT_NL("std::basic_string"),
- IDT_NL("std::basic_string"),
- IDT_NL("basic_string")
- },
- {
- 's',
- IDT_NL("std::string"),
- IDT_NL("std::basic_string<char, std::char_traits<char>, std::allocator<char>>"),
- IDT_NL("basic_string")
- },
- {
- 'i',
- IDT_NL("std::istream"),
- IDT_NL("std::basic_istream<char, std::char_traits<char>>"),
- IDT_NL("basic_istream")
- },
- {
- 'o',
- IDT_NL("std::ostream"),
- IDT_NL("std::basic_ostream<char, std::char_traits<char>>"),
- IDT_NL("basic_ostream")
- },
- {
- 'd',
- IDT_NL("std::iostream"),
- IDT_NL("std::basic_iostream<char, std::char_traits<char>>"),
- IDT_NL("basic_iostream")
- }
-
-};
-
-
-
-/* Extrait un composant dans un contexte Itanium. */
-static itanium_component *itd_encoding(GItaniumDContext *);
-
-/* Extrait un composant dans un contexte Itanium. */
-static itanium_component *itd_name(GItaniumDContext *);
-
-/* Extrait un composant dans un contexte Itanium. */
-static itanium_component *itd_unscoped_name(GItaniumDContext *);
-
-/* Extrait un composant dans un contexte Itanium. */
-static itanium_component *itd_unscoped_template_name(GItaniumDContext *);
-
-/* Extrait un composant dans un contexte Itanium. */
-static itanium_component *itd_nested_name(GItaniumDContext *);
-
-/* Extrait un composant dans un contexte Itanium. */
-static itanium_component *itd_prefix(GItaniumDContext *);
-
-/* Extrait un composant dans un contexte Itanium. */
-static itanium_component *itd_template_prefix(GItaniumDContext *);
-
-/* Extrait un composant dans un contexte Itanium. */
-static itanium_component *itd_unqualified_name(GItaniumDContext *);
-
-/* Extrait un composant dans un contexte Itanium. */
-static itanium_component *itd_source_name(GItaniumDContext *);
-
-/* Extrait un composant dans un contexte Itanium. */
-static bool itd_number(GItaniumDContext *, ssize_t *);
-
-/* Extrait un composant dans un contexte Itanium. */
-static itanium_component *itd_identifier(GItaniumDContext *, size_t);
-
-/* Extrait un composant dans un contexte Itanium. */
-static itanium_component *itd_operator_name(GItaniumDContext *);
-
-/* Extrait un composant dans un contexte Itanium. */
-static itanium_component *itd_special_name(GItaniumDContext *);
-
-/* Extrait un composant dans un contexte Itanium. */
-static itanium_component *itd_call_offset(GItaniumDContext *);
-
-/* Extrait un composant dans un contexte Itanium. */
-static itanium_component *itd_nv_offset(GItaniumDContext *);
-
-/* Extrait un composant dans un contexte Itanium. */
-static itanium_component *itd_v_offset(GItaniumDContext *);
-
-/* Extrait un composant dans un contexte Itanium. */
-static itanium_component *itd_ctor_dtor_name(GItaniumDContext *);
-
-/* Extrait un composant dans un contexte Itanium. */
-static itanium_component *itd_type(GItaniumDContext *);
-
-/* Extrait une propriété de composant pour un contexte Itanium. */
-static TypeQualifier itd_cv_qualifiers(GItaniumDContext *);
-
-/* Extrait un composant dans un contexte Itanium. */
-static itanium_component *itd_builtin_type(GItaniumDContext *);
-
-/* Extrait un composant dans un contexte Itanium. */
-static itanium_component *itd_bare_function_type(GItaniumDContext *);
-
-/* Extrait un composant dans un contexte Itanium. */
-static itanium_component *itd_class_enum_type(GItaniumDContext *);
-
-
-
-/* Extrait un composant dans un contexte Itanium. */
-static itanium_component *itd_template_args(GItaniumDContext *);
-
-/* Extrait un composant dans un contexte Itanium. */
-static itanium_component *itd_template_arg(GItaniumDContext *);
-
-
-
-/* Extrait un composant dans un contexte Itanium. */
-static itanium_component *itd_value_to_string(GItaniumDContext *, bool);
-
-/* Extrait un composant dans un contexte Itanium. */
-static itanium_component *itd_expr_primary(GItaniumDContext *);
-
-
-
-
-/* Extrait un composant dans un contexte Itanium. */
-static bool itd_seq_id(GItaniumDContext *, char, size_t *);
-
-/* Extrait un composant dans un contexte Itanium. */
-static itanium_component *itd_substitution(GItaniumDContext *);
-
-
-
-
-
-
-#define itd_template_param(ctx) NULL
-
-
-#define itd_local_name(ctx) NULL
-
-
-
-
-#define itd_expression(ctx) NULL
-
-
-
-
-/******************************************************************************
-* *
-* Paramètres : context = contexte de décodage à utiliser. *
-* *
-* Description : Extrait un composant dans un contexte Itanium. *
-* *
-* Retour : Composant extrait ou NULL en cas d'échec. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-itanium_component *itd_mangled_name(GItaniumDContext *context)
-{
- itanium_component *result; /* Construction à retourner */
-
- /**
- * La règle traitée ici est la suivante :
- *
- * <mangled-name> ::= _Z <encoding>
- *
- */
-
- if (!g_itanium_dcontext_check_char(context, '_'))
- return NULL;
-
- if (!g_itanium_dcontext_check_char(context, 'Z'))
- return NULL;
-
- result = itd_encoding(context);
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : context = contexte de décodage à utiliser. *
-* *
-* Description : Extrait un composant dans un contexte Itanium. *
-* *
-* Retour : Composant extrait ou NULL en cas d'échec. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static itanium_component *itd_encoding(GItaniumDContext *context)
-{
- itanium_component *result; /* Construction à retourner */
- itd_state saved; /* Position d'analyse courante */
- itanium_component *func; /* Composant 'function name' */
- itanium_component *types; /* Composant 'bare-function...'*/
-
- /**
- * La règle traitée ici est la suivante :
- *
- * <encoding> ::= <function name> <bare-function-type>
- * ::= <data name>
- * ::= <special-name>
- *
- */
-
- result = NULL;
- g_itanium_dcontext_push_state(context, &saved);
-
- func = itd_name(context);
-
- if (func != NULL)
- {
- types = itd_bare_function_type(context);
-
- if (types != NULL)
- result = itd_make_binary(context, ICT_FUNCTION_ENCODING, func, types);
- else
- itd_unref_comp(func);
-
- }
- /*
- if (result == NULL)
- {
- g_itanium_dcontext_pop_state(context, &saved);
- result = itd_name(context);
- }
- */
- if (result == NULL)
- {
- g_itanium_dcontext_pop_state(context, &saved);
- result = itd_special_name(context);
- }
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : context = contexte de décodage à utiliser. *
-* *
-* Description : Extrait un composant dans un contexte Itanium. *
-* *
-* Retour : Composant extrait ou NULL en cas d'échec. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static itanium_component *itd_name(GItaniumDContext *context)
-{
- itanium_component *result; /* Construction à retourner */
- itd_state saved; /* Position d'analyse courante */
- itanium_component *tname; /* Composant '...template-name'*/
- itanium_component *targs; /* Composant 'template-args' */
-
- /**
- * La règle traitée ici est la suivante :
- *
- * <name> ::= <nested-name>
- * ::= <unscoped-name>
- * ::= <unscoped-template-name> <template-args>
- * ::= <local-name>
- *
- */
-
- g_itanium_dcontext_push_state(context, &saved);
-
- result = itd_nested_name(context);
-
- if (result == NULL)
- {
- g_itanium_dcontext_pop_state(context, &saved);
-
- tname = itd_unscoped_template_name(context);
-
- if (tname != NULL)
- {
- targs = itd_template_args(context);
-
- if (targs != NULL)
- {
- g_itanium_dcontext_add_substitution(context, tname);
- result = itd_make_binary(context, ICT_TEMPLATE_NAME_ARGS, tname, targs);
- }
-
- else
- itd_unref_comp(tname);
-
- }
-
- }
-
- /**
- * La règle <unscoped-name> doit être traitée après <unscoped-template-name>,
- * car ces deux dernières ont une base commune et la seconde peut avoir besoin
- * d'aller plus loin avec la règle <template-args>.
- *
- * On termine donc par moins gourmand si la règle la plus complexe n'a pas abouti.
- */
-
- if (result == NULL)
- {
- g_itanium_dcontext_pop_state(context, &saved);
- result = itd_unscoped_name(context);
- }
-
- if (result == NULL)
- {
- g_itanium_dcontext_pop_state(context, &saved);
- result = itd_local_name(context);
- }
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : context = contexte de décodage à utiliser. *
-* *
-* Description : Extrait un composant dans un contexte Itanium. *
-* *
-* Retour : Composant extrait ou NULL en cas d'échec. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static itanium_component *itd_unscoped_name(GItaniumDContext *context)
-{
- itanium_component *result; /* Construction à retourner */
-
- /**
- * La règle traitée ici est la suivante :
- *
- * <unscoped-name> ::= <unqualified-name>
- * ::= St <unqualified-name> # ::std::
- *
- */
-
-
- /* TODO : 'St' */
-
-
- result = itd_unqualified_name(context);
-
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : context = contexte de décodage à utiliser. *
-* *
-* Description : Extrait un composant dans un contexte Itanium. *
-* *
-* Retour : Composant extrait ou NULL en cas d'échec. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static itanium_component *itd_unscoped_template_name(GItaniumDContext *context)
-{
- itanium_component *result; /* Construction à retourner */
- itd_state saved; /* Position d'analyse courante */
-
- /**
- * La règle traitée ici est la suivante :
- *
- * <unscoped-template-name> ::= <unscoped-name>
- * ::= <substitution>
- *
- */
-
- g_itanium_dcontext_push_state(context, &saved);
-
- result = itd_unscoped_name(context);
-
- if (result == NULL)
- {
- g_itanium_dcontext_pop_state(context, &saved);
- result = itd_substitution(context);
- }
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : context = contexte de décodage à utiliser. *
-* *
-* Description : Extrait un composant dans un contexte Itanium. *
-* *
-* Retour : Composant extrait ou NULL en cas d'échec. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static itanium_component *itd_nested_name(GItaniumDContext *context)
-{
- itanium_component *result; /* Construction à retourner */
- TypeQualifier qualifier; /* Propriétés supplémentaires */
- itd_state saved; /* Position d'analyse courante */
- itanium_component *left; /* Première partie */
- itanium_component *right; /* Seconde partie */
-
- static int inner = 0;
-
- int val = inner++;
-
- printf("\n ### (%d) NESTED>> '%s'\n", val,
- g_itanium_dcontext_get_string(context, (size_t []){ 0 }));
-
- /**
- * La règle traitée ici est la suivante :
- *
- * <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
- * ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
- *
- */
-
- if (!g_itanium_dcontext_check_char(context, 'N'))
- return NULL;
-
- qualifier = itd_cv_qualifiers(context);
-
- result = NULL;
-
- g_itanium_dcontext_push_state(context, &saved);
-
-
- printf("\n ----- (%d) nested prefix '%s'\n", val, g_itanium_dcontext_get_string(context, (size_t []){ 0 }));
-
-
-
- left = itd_prefix(context);
-
- if (left != NULL)
- {
- if (itd_get_component_type(left) != ICT_EMPTY)
- g_itanium_dcontext_add_substitution(context, left);
-
- right = itd_unqualified_name(context);
-
- if (right != NULL)
- {
- if (g_itanium_dcontext_check_char(context, 'E'))
- result = itd_make_binary(context, ICT_NESTED_NAME, left, right);
- else
- printf("=== (%d) nested/prefix : BAD E\n\n", val);
-
- //result = itd_make_binary(context, ICT_NESTED_NAME, left, right);
-
- }
- else
- itd_unref_comp(left);
-
- printf(" ---- (%d) nested prefix --> %p\n\n", val, result);
-
- }
-
-
- if (result == NULL)
- {
- printf("\n ----- (%d) nested template_arg '%s'\n", val, g_itanium_dcontext_get_string(context, (size_t []){ 0 }));
-
- g_itanium_dcontext_pop_state(context, &saved);
-
- left = itd_template_prefix(context);
-
- if (left != NULL)
- {
- g_itanium_dcontext_add_substitution(context, left);
-
- right = itd_template_args(context);
-
- if (right != NULL)
- {
- if (g_itanium_dcontext_check_char(context, 'E'))
- result = itd_make_binary(context, ICT_NESTED_NAME, left, right);
- else
- printf("=== (%d) nested/prefix : BAD E\n\n", val);
- }
- else
- itd_unref_comp(left);
-
- }
-
- printf(" ---- (%d) nested template_arg --> %p\n\n", val, result);
-
- }
-
-
-
- printf("(%d) nested/E >> '%s'\n", val, g_itanium_dcontext_get_string(context, (size_t []){ 0 }));
-
- /*
- if (!g_itanium_dcontext_check_char(context, 'E'))
- {
- printf("=== (%d) NESTED : BAD E\n\n", val);
-
- if (result != NULL)
- itd_unref_comp(result);
- return NULL;
- }
- */
-
- if (result != NULL)
- printf("=== (%d) NESTED OK (%p)\n\n", val, result);
-
- inner--;
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : context = contexte de décodage à utiliser. *
-* *
-* Description : Extrait un composant dans un contexte Itanium. *
-* *
-* Retour : Composant extrait ou NULL en cas d'échec. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static itanium_component *itd_prefix(GItaniumDContext *context)
-{
- itanium_component *result; /* Construction à retourner */
- itanium_component *looping_rule; /* Extraction d'une boucle */
- itd_state saved; /* Position d'analyse courante */
- itanium_component *left; /* Première partie */
- itanium_component *right; /* Seconde partie */
-
- itd_state next_name_saved; /* Position d'analyse courante */
- itanium_component *next_name; /* Eventuel complément #1 */
- itd_state next_targs_saved; /* Position d'analyse courante */
- itanium_component *next_targs; /* Eventuel complément #2 */
-
-
-
- itd_state expected_saved; /* Position d'analyse suivante */
- itanium_component *expected; /* Nom non-qualifié en réserve */
-
-
-
- /**
- * Les deux règles traitées ici sont les suivantes :
- *
- * <prefix> ::= <prefix> <unqualified-name>
- * ::= <template-prefix> <template-args>
- * ::= <template-param>
- * ::= # empty
- * ::= <substitution>
- *
- * <template-prefix> ::= <prefix> <template unqualified-name>
- * ::= <template-param>
- * ::= <substitution>
- *
- * Pour éviter une récursivité qui ferait exploser la pile, on les fusionne
- * en une nouvelle règle <prefix> étendue :
- *
- * <prefix> ::= <prefix> <unqualified-name>
- * ::= <prefix> <unqualified-name> <template-args>
- * ::= <template-param> <template-args>
- * ::= <substitution> <template-args>
- * ::= <template-param>
- * ::= # empty
- * ::= <substitution>
- *
- * On découpe ainsi les traitements en deux parties :
- * - extraction du socle non récursif.
- * - extraction éventuelle d'un complément <unqualified-name> [<template-args>]
- */
-
- result = NULL;
-
- while (1)
- {
- printf("loop....\n");
-
- looping_rule = NULL;
-
- /**
- * Première partie.
- */
-
- g_itanium_dcontext_push_state(context, &saved);
-
- /* <template-param> <template-args> */
-
- left = itd_template_param(context);
-
- if (left != NULL)
- {
- g_itanium_dcontext_add_substitution(context, left);
-
- right = itd_template_args(context);
-
- if (right != NULL)
- looping_rule = itd_make_binary(context, ICT_PREFIX_BINARY, left, right);
- else
- itd_unref_comp(left);
-
- }
-
- /* <substitution> <template-args> */
-
- if (looping_rule != NULL)
- {
- g_itanium_dcontext_pop_state(context, &saved);
-
- left = itd_substitution(context);
-
- if (left != NULL)
- {
- right = itd_template_args(context);
-
- if (right != NULL)
- looping_rule = itd_make_binary(context, ICT_PREFIX_BINARY, left, right);
- else
- itd_unref_comp(left);
-
- }
-
- }
-
- /* <template-param> */
-
- if (looping_rule == NULL)
- {
- g_itanium_dcontext_pop_state(context, &saved);
- looping_rule = itd_template_param(context);
- }
-
- /* <substitution> */
-
- if (looping_rule == NULL)
- {
- g_itanium_dcontext_pop_state(context, &saved);
- looping_rule = itd_substitution(context);
- }
-
- printf("looping_rule = %p\n", looping_rule);
-
- if (looping_rule != NULL)
- {
- if (result == NULL)
- result = looping_rule;
- else
- result = itd_make_binary(context, ICT_PREFIX_BINARY, result, looping_rule);
- }
-
- /**
- * Seconde partie (1/3) : recherche d'un éventuel complément.
- */
-
- if (looping_rule == NULL)
- g_itanium_dcontext_pop_state(context, &saved);
-
- /* <unqualified-name> */
-
- g_itanium_dcontext_push_state(context, &next_name_saved);
-
- next_name = itd_unqualified_name(context);
-
- if (next_name == NULL)
- {
- /**
- * Si on n'obtient pas de <unqualified-name> ici, rien ne sert de
- * continuer. On se dirige donc vers la sortie avec ce que l'on a.
- */
-
- return NULL;
-
- break;
-
- }
-
- /* <template-args> */
-
- g_itanium_dcontext_push_state(context, &next_targs_saved);
-
- next_targs = itd_template_args(context);
-
- g_itanium_dcontext_pop_state(context, &next_targs_saved);
-
- /**
- * Seconde partie (2/3) : validation de la présence d'un jeton
- * <unqualified-name> en réserve pour la règle <nested-name> parente.
- */
-
- g_itanium_dcontext_push_state(context, &expected_saved);
-
- expected = itd_unqualified_name(context);
-
- if (expected == NULL)
- {
- /**
- * La lecture a été trop loin ici.
- *
- * Le dernier <unqualified-name> valide pour la règle parente est
- * donc celui lu à une fin de recherche de complément.
- *
- * On revient donc à ce stade avant de se diriger vers la sortie.
- */
-
- itd_unref_comp(next_name);
-
- if (next_targs != NULL)
- itd_unref_comp(next_targs);
-
- g_itanium_dcontext_pop_state(context, &next_name_saved);
-
- break;
-
- }
-
- g_itanium_dcontext_pop_state(context, &expected_saved);
-
- /**
- * Seconde partie (3/3) : pleine inscription des composants extraits.
- *
- * On s'est manifestement retrouvé dans un des deux cas suivants :
- * - <prefix> ::= <prefix> <unqualified-name>
- * - <prefix> ::= <prefix> <template unqualified-name> <template-args>
- *
- * Or <prefix> est un candidat pour des substitutions futures, donc on
- * procède à son enregistrement, s'il n'est pas nul.
- */
-
- if (result != NULL)
- g_itanium_dcontext_add_substitution(context, result);
-
- printf("result = %p - next_name = %p\n", result, next_name);
-
-
- if (result == NULL)
- result = next_name;
- else
- result = itd_make_binary(context, ICT_PREFIX_BINARY, result, next_name);
-
- if (next_targs != NULL)
- result = itd_make_binary(context, ICT_PREFIX_BINARY, result, next_targs);
-
-
- printf(" > result = %p\n", result);
-
- }
-
- if (result == NULL)
- result = itd_make_empty(context);
- /*
- if (itd_get_component_type(result) != ICT_PREFIX_BINARY)
- result = itd_make_unary(context, ICT_PREFIX_UNARY, result);
- */
- //printf("<prefix> : %p\n", result);
-
- printf("### FIN DE PREFIX ### '%s'\n",
- g_itanium_dcontext_get_string(context, (size_t []){ 0 }));
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : context = contexte de décodage à utiliser. *
-* *
-* Description : Extrait un composant dans un contexte Itanium. *
-* *
-* Retour : Composant extrait ou NULL en cas d'échec. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static itanium_component *itd_template_prefix(GItaniumDContext *context)
-{
- itanium_component *result; /* Construction à retourner */
- itd_state saved; /* Position d'analyse courante */
- itanium_component *prefix; /* Premier d'un couple de comp.*/
- itanium_component *name; /* Second d'un couple de comp. */
-
- /**
- * La règle traitée ici est la suivante :
- *
- * <template-prefix> ::= <prefix> <template unqualified-name>
- * ::= <template-param>
- * ::= <substitution>
- *
- */
-
- result = NULL;
- g_itanium_dcontext_push_state(context, &saved);
-
- prefix = itd_prefix(context);
-
- if (prefix != NULL)
- {
- name = itd_unqualified_name(context);
-
- if (name != NULL)
- result = itd_make_binary(context, ICT_TPREFIX_BINARY, prefix, name);
- else
- itd_unref_comp(prefix);
-
- }
-
- if (result == NULL)
- {
- g_itanium_dcontext_pop_state(context, &saved);
- result = itd_template_param(context);
- }
-
- if (result == NULL)
- {
- g_itanium_dcontext_pop_state(context, &saved);
- result = itd_substitution(context);
- }
-
- if (result != NULL && itd_get_component_type(result) != ICT_TPREFIX_BINARY)
- result = itd_make_unary(context, ICT_TPREFIX_UNARY, result);
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : context = contexte de décodage à utiliser. *
-* *
-* Description : Extrait un composant dans un contexte Itanium. *
-* *
-* Retour : Composant extrait ou NULL en cas d'échec. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static itanium_component *itd_unqualified_name(GItaniumDContext *context)
-{
- itanium_component *result; /* Construction à retourner */
- itd_state saved; /* Position d'analyse courante */
-
- /**
- * La règle traitée ici est la suivante :
- *
- * <unqualified-name> ::= <operator-name>
- * ::= <ctor-dtor-name>
- * ::= <source-name>
- *
- */
-
- g_itanium_dcontext_push_state(context, &saved);
-
- result = itd_operator_name(context);
-
- if (result == NULL)
- {
- g_itanium_dcontext_pop_state(context, &saved);
- result = itd_ctor_dtor_name(context);
- }
-
- if (result == NULL)
- {
- g_itanium_dcontext_pop_state(context, &saved);
- result = itd_source_name(context);
- }
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : context = contexte de décodage à utiliser. *
-* *
-* Description : Extrait un composant dans un contexte Itanium. *
-* *
-* Retour : Composant extrait ou NULL en cas d'échec. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static itanium_component *itd_source_name(GItaniumDContext *context)
-{
- itanium_component *result; /* Construction à retourner */
- ssize_t number; /* Taille positive */
-
- /**
- * La règle traitée ici est la suivante :
- *
- * <source-name> ::= <positive length number> <identifier>
- *
- */
-
- if (!itd_number(context, &number))
- return NULL;
-
- if (number <= 0)
- return NULL;
-
- result = itd_identifier(context, number);
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : context = contexte de décodage à utiliser. *
-* size = taille positive ou non lue. [OUT] *
-* *
-* Description : Extrait un composant dans un contexte Itanium. *
-* *
-* Retour : Bilan de l'opération (un chifre lu au moins). *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static bool itd_number(GItaniumDContext *context, ssize_t *size)
-{
- bool result; /* Validité à renvoyer */
- bool negative; /* Taille négative ? */
- char peek; /* Prochain caractère lu */
-
- /**
- * La règle traitée ici est la suivante :
- *
- * <number> ::= [n] <non-negative decimal integer>
- *
- */
-
- result = false;
-
- negative = false;
-
- peek = g_itanium_dcontext_peek_char(context);
-
- if (peek == 'n')
- {
- negative = true;
- g_itanium_dcontext_advance(context, 1);
- peek = g_itanium_dcontext_peek_char(context);
- }
-
- *size = 0;
-
- while (isdigit(peek))
- {
- result = true;
- *size = *size * 10 + peek - '0';
- g_itanium_dcontext_advance(context, 1);
- peek = g_itanium_dcontext_peek_char(context);
- }
-
- if (negative)
- *size *= -1;
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : context = contexte de décodage à utiliser. *
-* length = taille de l'identifiant à retrouver. *
-* *
-* Description : Extrait un composant dans un contexte Itanium. *
-* *
-* Retour : Composant extrait ou NULL en cas d'échec. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static itanium_component *itd_identifier(GItaniumDContext *context, size_t length)
-{
- itanium_component *result; /* Construction à retourner */
- const char *data; /* Données restantes */
- size_t remaining; /* Quantité d'octets */
-
- /**
- * La règle traitée ici est la suivante :
- *
- * <identifier> ::= <unqualified source code identifier>
- *
- */
-
- data = g_itanium_dcontext_get_string(context, &remaining);
-
- if (length > remaining)
- return NULL;
-
- result = itd_make_name(context, data, length);
-
- if (result != NULL)
- g_itanium_dcontext_advance(context, length);
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : context = contexte de décodage à utiliser. *
-* *
-* Description : Extrait un composant dans un contexte Itanium. *
-* *
-* Retour : Composant extrait ou NULL en cas d'échec. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static itanium_component *itd_operator_name(GItaniumDContext *context)
-{
- itanium_component *result; /* Construction à retourner */
- char code[2]; /* Code à venir lire */
- itanium_operator_info info; /* Clef des informations */
- itanium_operator_info *found; /* Informations complètes */
-
- /**
- * La règle traitée ici est la suivante :
- *
- * <operator-name> ::= nw # new
- * ::= na # new[]
- * ::= dl # delete
- * ::= da # delete[]
- * ::= ps # + (unary)
- * ::= ng # - (unary)
- * ::= ad # & (unary)
- * ::= de # * (unary)
- * ::= co # ~
- * ::= pl # +
- * ::= mi # -
- * ::= ml # *
- * ::= dv # /
- * ::= rm # %
- * ::= an # &
- * ::= or # |
- * ::= eo # ^
- * ::= aS # =
- * ::= pL # +=
- * ::= mI # -=
- * ::= mL # *=
- * ::= dV # /=
- * ::= rM # %=
- * ::= aN # &=
- * ::= oR # |=
- * ::= eO # ^=
- * ::= ls # <<
- * ::= rs # >>
- * ::= lS # <<=
- * ::= rS # >>=
- * ::= eq # ==
- * ::= ne # !=
- * ::= lt # <
- * ::= gt # >
- * ::= le # <=
- * ::= ge # >=
- * ::= nt # !
- * ::= aa # &&
- * ::= oo # ||
- * ::= pp # ++
- * ::= mm # --
- * ::= cm # ,
- * ::= pm # ->*
- * ::= pt # ->
- * ::= cl # ()
- * ::= ix # []
- * ::= qu # ?
- * ::= st # sizeof (a type)
- * ::= sz # sizeof (an expression)
- * ::= cv <type> # (cast)
- * ::= v <digit> <source-name> # vendor extended operator
- *
- */
-
- result = NULL;
-
- code[0] = g_itanium_dcontext_next_char(context);
-
- if (code[0] == 'v')
- {
-
- result = NULL; /* TODO */
-
- goto itd_operator_name_exit;
-
-
- }
-
- code[1] = g_itanium_dcontext_next_char(context);
-
- if (code[0] == 'c' && code[1] == 'v')
- {
-
- result = NULL; /* TODO */
-
- goto itd_operator_name_exit;
-
-
- }
-
- /* Recherche dans la liste des opérateurs reconnus */
-
- info.code = code;
-
- int comp_itanium_operators(const itanium_operator_info *a, const itanium_operator_info *b)
- {
- int result; /* Bilan à renvoyer */
-
- if (a->code[0] < b->code[0])
- result = -1;
- else if (a->code[0] > b->code[0])
- result = 1;
- else
- {
- if (a->code[1] < b->code[1])
- result = -1;
- else if (a->code[1] > b->code[1])
- result = 1;
- else
- result = 0;
- }
-
- return result;
-
- }
-
- found = bsearch(&info, itanium_demangle_operators,
- ARRAY_SIZE(itanium_demangle_operators),
- sizeof(itanium_operator_info), (__compar_fn_t)comp_itanium_operators);
-
- if (found != NULL)
- result = itd_make_operator(context, found);
-
- itd_operator_name_exit:
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : context = contexte de décodage à utiliser. *
-* *
-* Description : Extrait un composant dans un contexte Itanium. *
-* *
-* Retour : Composant extrait ou NULL en cas d'échec. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static itanium_component *itd_special_name(GItaniumDContext *context)
-{
- itanium_component *result; /* Construction à retourner */
- char next; /* Caractère suivant */
- char peek; /* Prochain caractère lu */
- itanium_component *offset1; /* Décalage extrait #1 */
- itanium_component *encoding; /* Encodage suivant */
-
- /**
- * La règle traitée ici est la suivante :
- *
- * <special-name> ::= T <call-offset> <base encoding>
- * # base is the nominal target function of thunk
- */
-
- result = NULL;
-
- next = g_itanium_dcontext_next_char(context);
-
- if (next == 'T')
- {
- peek = g_itanium_dcontext_peek_char(context);
-
- switch (peek)
- {
- case 'V':
- result = NULL; /* TODO */
- break;
-
- case 'T':
- result = NULL; /* TODO */
- break;
-
- case 'I':
- result = NULL; /* TODO */
- break;
-
- case 'S':
- result = NULL; /* TODO */
- break;
-
- case 'c':
- result = NULL; /* TODO */
- break;
-
-
- default:
-
- offset1 = itd_call_offset(context);
- if (offset1 == NULL) break;
-
- encoding = itd_encoding(context);
-
- if (encoding == NULL)
- itd_unref_comp(offset1);
- else
- result = itd_make_binary(context, ICT_FUNCTION_THUNK, offset1, encoding);
-
- break;
-
- }
-
- }
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : context = contexte de décodage à utiliser. *
-* *
-* Description : Extrait un composant dans un contexte Itanium. *
-* *
-* Retour : Composant extrait ou NULL en cas d'échec. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static itanium_component *itd_call_offset(GItaniumDContext *context)
-{
- itanium_component *result; /* Construction à retourner */
- char next; /* Caractère suivant */
-
- /**
- * La règle traitée ici est la suivante :
- *
- * <call-offset> ::= h <nv-offset> _
- * ::= v <v-offset> _
- */
-
- next = g_itanium_dcontext_next_char(context);
-
- switch (next)
- {
- case 'h':
- result = itd_nv_offset(context);
- break;
-
- case 'v':
- result = itd_v_offset(context);
- break;
-
- default:
- result = NULL;
- break;
-
- }
-
- if (result != NULL && !g_itanium_dcontext_check_char(context, '_'))
- {
- itd_unref_comp(result);
- result = NULL;
- }
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : context = contexte de décodage à utiliser. *
-* *
-* Description : Extrait un composant dans un contexte Itanium. *
-* *
-* Retour : Composant extrait ou NULL en cas d'échec. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static itanium_component *itd_nv_offset(GItaniumDContext *context)
-{
- itanium_component *result; /* Construction à retourner */
- ssize_t offset; /* Décalage obtenu */
-
- /**
- * La règle traitée ici est la suivante :
- *
- * <nv-offset> ::= <offset number>
- * # non-virtual base override
- */
-
- if (!itd_number(context, &offset))
- return NULL;
-
- result = itd_make_offset(context, ICT_NON_VIRTUAL_OFFSET, offset);
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : context = contexte de décodage à utiliser. *
-* *
-* Description : Extrait un composant dans un contexte Itanium. *
-* *
-* Retour : Composant extrait ou NULL en cas d'échec. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static itanium_component *itd_v_offset(GItaniumDContext *context)
-{
- itanium_component *result; /* Construction à retourner */
- ssize_t offset; /* Décalage obtenu #1 */
- ssize_t voffset; /* Décalage obtenu #2 */
-
- /**
- * La règle traitée ici est la suivante :
- *
- * <v-offset> ::= <offset number> _ <virtual offset number>
- * # virtual base override, with vcall offset
- */
-
- if (!itd_number(context, &offset))
- return NULL;
-
- if (!g_itanium_dcontext_check_char(context, '_'))
- return NULL;
-
- if (!itd_number(context, &voffset))
- return NULL;
-
- result = itd_make_binary(context, ICT_VIRTUAL_OFFSET,
- itd_make_offset(context, ICT_NON_VIRTUAL_OFFSET, offset),
- itd_make_offset(context, ICT_VIRTUAL_OFFSET, voffset));
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : context = contexte de décodage à utiliser. *
-* *
-* Description : Extrait un composant dans un contexte Itanium. *
-* *
-* Retour : Composant extrait ou NULL en cas d'échec. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static itanium_component *itd_ctor_dtor_name(GItaniumDContext *context)
-{
- itanium_component *result; /* Construction à retourner */
- char next; /* Caractère suivant */
- ItaniumComponentType type; /* Type de composant */
-
- /**
- * La règle traitée ici est la suivante :
- *
- * <ctor-dtor-name> ::= C1 # complete object constructor
- * ::= C2 # base object constructor
- * ::= C3 # complete object allocating constructor
- * ::= D0 # deleting destructor
- * ::= D1 # complete object destructor
- * ::= D2 # base object destructor
- */
-
- next = g_itanium_dcontext_peek_char(context);
-
- if (next == 'C')
- type = ICT_CONSTRUCTOR;
- else if (next == 'D')
- type = ICT_DESSTRUCTOR;
- else
- return NULL;
-
- g_itanium_dcontext_advance(context, 1);
-
- next = g_itanium_dcontext_peek_char(context);
-
- if (next != '0' && next != '1' && next != '2')
- return NULL;
-
- g_itanium_dcontext_advance(context, 1);
-
- result = itd_make_empty(context);
- itd_set_type(result, type);
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : context = contexte de décodage à utiliser. *
-* *
-* Description : Extrait un composant dans un contexte Itanium. *
-* *
-* Retour : Composant extrait ou NULL en cas d'échec. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static itanium_component *itd_type(GItaniumDContext *context)
-{
- itanium_component *result; /* Construction à retourner */
- TypeQualifier qualifier; /* Propriétés supplémentaires */
- itanium_component *sub; /* Sous-type lié à associer */
- itd_state saved; /* Position d'analyse courante */
-
- /**
- * La règle traitée ici est la suivante :
- *
- * <type> ::= <builtin-type>
- * ::= <function-type>
- * ::= <class-enum-type>
- * ::= <array-type>
- * ::= <pointer-to-member-type>
- * ::= <template-param>
- * ::= <template-template-param> <template-args>
- * ::= <substitution> # See Compression below
- * ::= <CV-qualifiers> <type>
- * ::= P <type> # pointer-to
- * ::= R <type> # reference-to
- * ::= O <type> # rvalue reference-to (C++0x)
- * ::= C <type> # complex pair (C 2000)
- * ::= G <type> # imaginary (C 2000)
- * ::= U <source-name> <type> # vendor extended type qualifier
- *
- */
-
- result = NULL;
-
- qualifier = itd_cv_qualifiers(context);
-
- switch (g_itanium_dcontext_peek_char(context))
- {
- case 'P':
-
- g_itanium_dcontext_advance(context, 1);
-
- sub = itd_type(context);
- if (sub == NULL) return NULL;
-
- result = itd_make_unary(context, ICT_POINTER_TO, sub);
- break;
-
- case 'R':
-
- g_itanium_dcontext_advance(context, 1);
-
- sub = itd_type(context);
- if (sub == NULL) return NULL;
-
- result = itd_make_unary(context, ICT_REFERENCE_TO, sub);
- break;
-
- case 'O':
-
- g_itanium_dcontext_advance(context, 1);
-
- sub = itd_type(context);
- if (sub == NULL) return NULL;
-
- result = itd_make_unary(context, ICT_RVALUE_REFERENCE_TO, sub);
- break;
-
- case 'C':
-
- g_itanium_dcontext_advance(context, 1);
-
- sub = itd_type(context);
- if (sub == NULL) return NULL;
-
- result = itd_make_unary(context, ICT_COMPLEX_PAIR, sub);
- break;
-
- case 'G':
-
- g_itanium_dcontext_advance(context, 1);
-
- sub = itd_type(context);
- if (sub == NULL) return NULL;
-
- result = itd_make_unary(context, ICT_IMAGINARY, sub);
- break;
-
- case 'U':
-
- g_itanium_dcontext_advance(context, 1);
- /* TODO */
- return NULL;
- break;
-
- }
-
- if (result != NULL) goto itd_type_end;
-
- g_itanium_dcontext_push_state(context, &saved);
-
- result = itd_builtin_type(context);
- if (result != NULL) goto itd_type_end;
-
- g_itanium_dcontext_pop_state(context, &saved);
-
- result = itd_class_enum_type(context);
- if (result != NULL) goto itd_type_end;
-
-
- g_itanium_dcontext_pop_state(context, &saved);
-
- result = itd_substitution(context);
- if (result != NULL) goto itd_type_end;
-
-
-
-
- itd_type_end:
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : context = contexte de décodage à utiliser. *
-* *
-* Description : Extrait une propriété de composant pour un contexte Itanium. *
-* *
-* Retour : Indication extraite. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static TypeQualifier itd_cv_qualifiers(GItaniumDContext *context)
-{
- TypeQualifier result; /* Valeur à remonter */
-
- /**
- * La règle traitée ici est la suivante :
- *
- * <CV-qualifiers> ::= [r] [V] [K] # restrict (C99), volatile, const
- *
- */
-
- result = TQF_NONE;
-
- while (1)
- switch (g_itanium_dcontext_peek_char(context))
- {
- case 'r':
- result = TQF_RESTRICT;
- g_itanium_dcontext_advance(context, 1);
- break;
-
- case 'V':
- result = TQF_VOLATILE;
- g_itanium_dcontext_advance(context, 1);
- break;
-
- case 'K':
- result = TQF_CONST;
- g_itanium_dcontext_advance(context, 1);
- break;
-
- default:
- goto itd_cv_qualifiers_exit;
- break;
-
- }
-
- itd_cv_qualifiers_exit:
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : context = contexte de décodage à utiliser. *
-* *
-* Description : Extrait un composant dans un contexte Itanium. *
-* *
-* Retour : Composant extrait ou NULL en cas d'échec. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static itanium_component *itd_builtin_type(GItaniumDContext *context)
-{
- itanium_component *result; /* Construction à retourner */
- BaseType type; /* Type reconnu ou BTP_INVALID */
- GDataType *builtin; /* Type construit */
-
- /**
- * La règle traitée ici est la suivante :
- *
- * <builtin-type> ::= v # void
- * ::= w # wchar_t
- * ::= b # bool
- * ::= c # char
- * ::= a # signed char
- * ::= h # unsigned char
- * ::= s # short
- * ::= t # unsigned short
- * ::= i # int
- * ::= j # unsigned int
- * ::= l # long
- * ::= m # unsigned long
- * ::= x # long long, __int64
- * ::= y # unsigned long long, __int64
- * ::= n # __int128
- * ::= o # unsigned __int128
- * ::= f # float
- * ::= d # double
- * ::= e # long double, __float80
- * ::= g # __float128
- * ::= z # ellipsis
- * ::= u <source-name> # vendor extended type
- *
- */
-
- switch (g_itanium_dcontext_peek_char(context))
- {
- case 'v':
- type = BTP_VOID;
- break;
- case 'w':
- type = BTP_WCHAR_T;
- break;
- case 'b':
- type = BTP_BOOL;
- break;
- case 'c':
- type = BTP_CHAR;
- break;
- case 'a':
- type = BTP_SCHAR;
- break;
- case 'h':
- type = BTP_UCHAR;
- break;
- case 's':
- type = BTP_SHORT;
- break;
- case 't':
- type = BTP_USHORT;
- break;
- case 'i':
- type = BTP_INT;
- break;
- case 'j':
- type = BTP_UINT;
- break;
- case 'l':
- type = BTP_LONG;
- break;
- case 'm':
- type = BTP_ULONG;
- break;
- case 'x':
- type = BTP_LONG_LONG;
- break;
- case 'y':
- type = BTP_ULONG_LONG;
- break;
- case 'n':
- type = BTP_INT128;
- break;
- case 'o':
- type = BTP_UINT128;
- break;
- case 'f':
- type = BTP_FLOAT;
- break;
- case 'd':
- type = BTP_DOUBLE;
- break;
- case 'e':
- type = BTP_LONG_DOUBLE;
- break;
- case 'g':
- type = BTP_FLOAT128;
- break;
- case 'z':
- type = BTP_ELLIPSIS;
- break;
- case 'u':
- type = BTP_OTHER;
- /* FIXME */
- /* <source-name> # vendor extended type */
- break;
- default:
- type = BTP_INVALID;
- break;
- }
-
- if (type != BTP_INVALID)
- {
- builtin = g_basic_type_new(type);
- result = itd_make_type(context, builtin);
- g_itanium_dcontext_advance(context, 1);
- }
- else
- result = NULL;
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : context = contexte de décodage à utiliser. *
-* *
-* Description : Extrait un composant dans un contexte Itanium. *
-* *
-* Retour : Composant extrait ou NULL en cas d'échec. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static itanium_component *itd_bare_function_type(GItaniumDContext *context)
-{
- itanium_component *result; /* Construction à retourner */
- itanium_component *type; /* Nouvel élément à intégrer */
- itd_state saved; /* Position d'analyse courante */
-
- /**
- * La règle traitée ici est la suivante :
- *
- * <bare-function-type> ::= <signature type>+
- * # types are possible return type, then parameter types
- *
- */
-
- type = itd_type(context);
- if (type == NULL) return NULL;
-
- result = itd_append_right_to_binary(context, ICT_TYPES_LIST, NULL, type);
-
- while (1)
- {
- g_itanium_dcontext_push_state(context, &saved);
-
- type = itd_type(context);
- if (type == NULL)
- {
- g_itanium_dcontext_pop_state(context, &saved);
- break;
- }
-
- result = itd_append_right_to_binary(context, ICT_TYPES_LIST, result, type);
-
- }
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : context = contexte de décodage à utiliser. *
-* *
-* Description : Extrait un composant dans un contexte Itanium. *
-* *
-* Retour : Composant extrait ou NULL en cas d'échec. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static itanium_component *itd_class_enum_type(GItaniumDContext *context)
-{
- itanium_component *result; /* Construction à retourner */
-
- /**
- * La règle traitée ici est la suivante :
- *
- * <class-enum-type> ::= <name>
- *
- */
-
- result = itd_name(context);
-
- return result;
-
-}
-
-
-
-
-
-
-
-
-/******************************************************************************
-* *
-* Paramètres : context = contexte de décodage à utiliser. *
-* *
-* Description : Extrait un composant dans un contexte Itanium. *
-* *
-* Retour : Composant extrait ou NULL en cas d'échec. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static itanium_component *itd_template_args(GItaniumDContext *context)
-{
- itanium_component *result; /* Construction à retourner */
- itanium_component *arg; /* Nouvel argument extrait */
- itd_state saved; /* Position d'analyse courante */
-
- printf(">>> TA>> '%s'\n", g_itanium_dcontext_get_string(context, (size_t []){ 0 }));
-
- /**
- * La règle traitée ici est la suivante :
- *
- * <template-args> ::= I <template-arg>+ E
- *
- */
-
- if (!g_itanium_dcontext_check_char(context, 'I'))
- return NULL;
-
- arg = itd_template_arg(context);
- if (arg == NULL) return NULL;
-
- result = itd_append_right_to_binary(context, ICT_TYPES_LIST, NULL, arg);
-
- while (1)
- {
- g_itanium_dcontext_push_state(context, &saved);
-
- arg = itd_template_arg(context);
- if (arg == NULL)
- {
- g_itanium_dcontext_pop_state(context, &saved);
- break;
- }
-
- result = itd_append_right_to_binary(context, ICT_TYPES_LIST, result, arg);
-
- }
-
- //printf(" ta/E >> '%s'\n", g_itanium_dcontext_get_string(context, (size_t []){ 0 }));
-
- if (!g_itanium_dcontext_check_char(context, 'E'))
- {
- //printf("=== TA : BAD E\n\n");
-
- if (result != NULL)
- itd_unref_comp(result);
- return NULL;
- }
-
- //printf("=== TA >> %p\n\n", result);
-
- result = itd_make_unary(context, ICT_TEMPLATE_ARGS, result);
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : context = contexte de décodage à utiliser. *
-* *
-* Description : Extrait un composant dans un contexte Itanium. *
-* *
-* Retour : Composant extrait ou NULL en cas d'échec. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static itanium_component *itd_template_arg(GItaniumDContext *context)
-{
- itanium_component *result; /* Construction à retourner */
- itd_state saved; /* Position d'analyse courante */
-
- /**
- * La règle traitée ici est la suivante :
- *
- * <template-arg> ::= <type> # type or template
- * ::= X <expression> E # expression
- * ::= <expr-primary> # simple expressions
- *
- */
-
- g_itanium_dcontext_push_state(context, &saved);
-
- result = itd_type(context);
-
- if (result == NULL)
- {
- g_itanium_dcontext_pop_state(context, &saved);
-
- if (g_itanium_dcontext_check_char(context, 'X'))
- {
- result = itd_expression(context);
-
- if (result != NULL && !g_itanium_dcontext_check_char(context, 'E'))
- {
- itd_unref_comp(result);
- result = NULL;
- }
-
- }
-
- }
-
- if (result == NULL)
- {
- g_itanium_dcontext_pop_state(context, &saved);
- result = itd_expr_primary(context);
- }
-
- return result;
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-/******************************************************************************
-* *
-* Paramètres : context = contexte de décodage à utiliser. *
-* hex = prise en compte des caractères hexadécimaux ? *
-* *
-* Description : Extrait un composant dans un contexte Itanium. *
-* *
-* Retour : Composant extrait ou NULL en cas d'échec. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static itanium_component *itd_value_to_string(GItaniumDContext *context, bool hex)
-{
- itanium_component *result; /* Construction à retourner */
- const char *data; /* Données restantes */
- itd_state saved; /* Position d'analyse initiale */
- itd_state cur; /* Position d'analyse courante */
- char peek; /* Prochain caractère lu */
-
- /**
- * Les règles traitées ici sont les suivantes :
- *
- * <value number> # integer literal
- * <value float> # floating literal
- *
- */
-
- result = NULL;
-
- data = g_itanium_dcontext_get_string(context, (size_t []) { 0 });
-
- g_itanium_dcontext_push_state(context, &saved);
-
- while (1)
- {
- peek = g_itanium_dcontext_peek_char(context);
-
- switch (peek)
- {
- case '0' ... '9':
- g_itanium_dcontext_advance(context, 1);
- break;
-
- case 'a' ... 'f':
- if (hex)
- g_itanium_dcontext_advance(context, 1);
- else
- goto exit_iits;
- break;
-
- case 'E':
- goto exit_loop;
- break;
-
- default:
- goto exit_iits;
-
- }
-
- }
-
- exit_loop:
-
- g_itanium_dcontext_push_state(context, &cur);
-
- if ((cur.pos - saved.pos) > 0)
- result = itd_make_name(context, data, cur.pos - saved.pos);
-
- exit_iits:
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : context = contexte de décodage à utiliser. *
-* *
-* Description : Extrait un composant dans un contexte Itanium. *
-* *
-* Retour : Composant extrait ou NULL en cas d'échec. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static itanium_component *itd_expr_primary(GItaniumDContext *context)
-{
- itanium_component *result; /* Construction à retourner */
- itd_state saved; /* Position d'analyse courante */
- itanium_component *type; /* Type de valeur extrait */
- itd_state saved_value; /* Position d'analyse courante */
-
- /**
- * La règle traitée ici est la suivante :
- *
- * <expr-primary> ::= L <type> <value number> E # integer literal
- * ::= L <type> <value float> E # floating literal
- * ::= L <mangled-name> E # external name
- *
- */
-
- printf("PRIMARY :: no L\n");
-
- if (!g_itanium_dcontext_check_char(context, 'L'))
- return NULL;
-
- g_itanium_dcontext_push_state(context, &saved);
-
- type = itd_type(context);
-
- if (type != NULL)
- {
- g_itanium_dcontext_push_state(context, &saved_value);
-
- /* Règle <type> <value number> */
-
- result = itd_value_to_string(context, false);
-
- if (result != NULL && !g_itanium_dcontext_check_char(context, 'E'))
- {
- itd_unref_comp(result);
- result = NULL;
- }
-
- /* Règle <type> <value float> */
-
- if (result == NULL)
- {
- g_itanium_dcontext_pop_state(context, &saved_value);
-
- result = itd_value_to_string(context, true);
-
- if (result != NULL && !g_itanium_dcontext_check_char(context, 'E'))
- {
- itd_unref_comp(result);
- result = NULL;
- }
-
- }
-
- itd_unref_comp(type);
-
- }
- else
- result = NULL;
-
- /* Règle <mangled-name> */
-
- if (result == NULL)
- {
- g_itanium_dcontext_pop_state(context, &saved);
- result = itd_mangled_name(context);
-
- if (result != NULL && !g_itanium_dcontext_check_char(context, 'E'))
- {
- itd_unref_comp(result);
- result = NULL;
- }
-
- }
-
- printf("PRIMARY :: %p\n", result);
-
- return result;
-
-}
-
-
-
-
-
-
-
-
-/******************************************************************************
-* *
-* Paramètres : context = contexte de décodage à utiliser. *
-* cur = caractère courant. *
-* id = identifiant lu en cas de succès. [OUT] *
-* *
-* Description : Extrait un composant dans un contexte Itanium. *
-* *
-* Retour : Bilan de l'opération. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static bool itd_seq_id(GItaniumDContext *context, char cur, size_t *id)
-{
- /**
- * La règle traitée ici est la suivante :
- *
- * <seq-id>
- *
- */
-
- *id = 0;
-
- /**
- * La fonction n'est appelée que si un début de séquence est détecté.
- * (ie, cur == '_' || isdigit(cur) || isupper(cur)).
- */
-
- if (cur != '_')
- {
- do
- {
- if (isdigit(cur))
- *id = *id * 36 + cur - '0';
- else if (isupper(cur))
- *id = *id * 36 + cur - 'A' + 10;
- else
- return false;
-
- cur = g_itanium_dcontext_next_char(context);
-
- }
- while (cur != '_');
-
- (*id)++;
-
- }
-
- return true;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : context = contexte de décodage à utiliser. *
-* *
-* Description : Extrait un composant dans un contexte Itanium. *
-* *
-* Retour : Composant extrait ou NULL en cas d'échec. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-static itanium_component *itd_substitution(GItaniumDContext *context)
-{
- itanium_component *result; /* Construction à retourner */
- char cur; /* Caractère analysé */
- size_t id; /* Identifiant de substitution */
- char peek; /* Prochain caractère lu */
- bool verbose; /* Sélection du rendu idéal */
- size_t i; /* Boucle de parcours */
-
- /**
- * La règle traitée ici est la suivante :
- *
- * <substitution> ::= S <seq-id> _
- * ::= S_
- * ::= St # ::std::
- * ::= Sa # ::std::allocator
- * ::= Sb # ::std::basic_string
- * ::= Ss # ::std::basic_string<char, ::std::char_traits<char>, ::std::allocator<char>>
- * ::= Si # ::std::basic_istream<char, std::char_traits<char>>
- * ::= So # ::std::basic_ostream<char, std::char_traits<char>>
- * ::= Sd # ::std::basic_iostream<char, std::char_traits<char>>
- *
- */
-
- peek = g_itanium_dcontext_peek_char(context);
-
- if (!g_itanium_dcontext_check_char(context, 'S'))
- return NULL;
-
- cur = g_itanium_dcontext_next_char(context);
-
- if (cur == '_' || isdigit(cur) || isupper(cur))
- {
- if (!itd_seq_id(context, cur, &id))
- return NULL;
-
- printf("requesting... %zu\n", id);
-
- result = g_itanium_dcontext_get_substitution(context, id);
-
- }
- else
- {
- result = NULL;
-
- peek = g_itanium_dcontext_peek_char(context);
- verbose = (peek == 'C' || peek == 'D'); /* TODO : prefixe ? */
-
- for (i = 0; i < ARRAY_SIZE(itanium_standard_substitutions); i++)
- if (itanium_standard_substitutions[i].code == cur)
- {
- /* TODO : constructeur... */
-
- if (verbose)
- result = itd_make_name(context,
- itanium_standard_substitutions[i].full,
- itanium_standard_substitutions[i].full_len);
- else
- result = itd_make_name(context,
- itanium_standard_substitutions[i].simple,
- itanium_standard_substitutions[i].simple_len);
-
- itd_set_type(result, ICT_STD_SUBST);
-
- break;
-
- }
-
- }
-
- return result;
-
-}