Supported Dalvik VM / DEX (partially).

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

9 files changed, 660 insertions, 45 deletions

diff --git a/src/format/mangling/Makefile.am b/src/format/mangling/Makefile.am
index 994919d..6298743 100644
--- a/src/format/mangling/Makefile.am
+++ b/src/format/mangling/Makefile.am
@@ -1,11 +1,13 @@
 
-BUILT_SOURCES = itanium_gram.h
+BUILT_SOURCES = itanium_gram.h libjavamangling_la-java_gram.h
 
 AM_YFLAGS = -d
 
-noinst_LTLIBRARIES = libformatmangling.la
+noinst_LTLIBRARIES = libjavamangling.la libformatmangling.la
 
 libformatmangling_la_SOURCES =			\
+	context-int.h						\
+	context.h context.c					\
 	demangler.h demangler.c				\
 	itanium.h							\
 	itanium_gram.y						\
@@ -13,6 +15,23 @@ libformatmangling_la_SOURCES =			\
 
 libformatmangling_la_LDFLAGS = 
 
+libformatmangling_la_LIBADD =			\
+	libjavamangling.la
+
+
+# Partie Java
+
+libjavamangling_la_SOURCES =			\
+	java.h								\
+	java_gram.y							\
+	java_tok.l
+
+libjavamangling_la_YFLAGS = -d -p java_ -o y.tab.c
+
+libjavamangling_la_LFLAGS = -P java_ -o lex.yy.c
+
+
+
 
 INCLUDES = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS)
 
@@ -22,4 +41,5 @@ AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS)
 
 
 # Automake fait les choses à moitié
-CLEANFILES = itanium_gram.h itanium_gram.c itanium_tok.c
+CLEANFILES = itanium_gram.h itanium_gram.c itanium_tok.c	\
+			 java_gram.h java_gram.c libjavamangling_la-java_tok.c
diff --git a/src/format/mangling/context-int.h b/src/format/mangling/context-int.h
new file mode 100644
index 0000000..e8e6ec0
--- /dev/null
+++ b/src/format/mangling/context-int.h
@@ -0,0 +1,53 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * context.h - prototypes internes liés aux contextes de décodage
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA 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.
+ *
+ *  OpenIDA 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/>.
+ */
+
+
+#ifndef _FORMAT_MANGLING_CONTEXT_INT_H
+#define _FORMAT_MANGLING_CONTEXT_INT_H
+
+
+#include "context.h"
+
+
+
+/* Contexte de décodage (instance) */
+struct _GDemanglingContext
+{
+    GObject parent;                         /* A laisser en premier        */
+
+    union
+    {
+        GOpenidaType *type;                 /* Type décodé                 */
+    };
+
+};
+
+/* Contexte de décodage (classe) */
+struct _GDemanglingContextClass
+{
+    GObjectClass parent;                    /* A laisser en premier        */
+
+};
+
+
+
+#endif  /* _FORMAT_MANGLING_CONTEXT_INT_H */
diff --git a/src/format/mangling/context.c b/src/format/mangling/context.c
new file mode 100644
index 0000000..0d57937
--- /dev/null
+++ b/src/format/mangling/context.c
@@ -0,0 +1,95 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * context.c - fourniture de contexte aux phases de décodage
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA 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.
+ *
+ *  OpenIDA 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 "context.h"
+
+
+#include "context-int.h"
+
+
+
+/* Initialise la classe des contextes de décodage. */
+static void g_demangling_context_class_init(GDemanglingContextClass *);
+
+/* Initialise une instance de contexte pour décodage. */
+static void g_demangling_context_init(GDemanglingContext *);
+
+
+
+/* Indique le type défini pour un contexte de décodage. */
+G_DEFINE_TYPE(GDemanglingContext, g_demangling_context, G_TYPE_OBJECT);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des contextes de décodage.              *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_demangling_context_class_init(GDemanglingContextClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = instance à initialiser.                            *
+*                                                                             *
+*  Description : Initialise une instance de contexte pour décodage.           *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_demangling_context_init(GDemanglingContext *context)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = instance à consulter.                              *
+*                                                                             *
+*  Description : Fournit le type créé à l'issue du codage.                    *
+*                                                                             *
+*  Retour      : Instance en place ou NULL en cas d'erreur fatale.            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GOpenidaType *g_demangling_context_get_decoded_type(const GDemanglingContext *context)
+{
+    return context->type;
+
+}
diff --git a/src/format/mangling/context.h b/src/format/mangling/context.h
new file mode 100644
index 0000000..3ede4da
--- /dev/null
+++ b/src/format/mangling/context.h
@@ -0,0 +1,57 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * context.h - prototypes pour la fourniture de contexte aux phases de décodage
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA 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.
+ *
+ *  OpenIDA 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/>.
+ */
+
+
+#ifndef _FORMAT_MANGLING_CONTEXT_H
+#define _FORMAT_MANGLING_CONTEXT_H
+
+
+#include <glib-object.h>
+
+
+#include "../../analysis/routine.h"
+
+
+
+#define G_TYPE_DEMANGLING_CONTEXT               g_demangling_context_get_type()
+#define G_DEMANGLING_CONTEXT(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_demangling_context_get_type(), GDemanglingContext))
+#define G_IS_DEMANGLING_CONTEXT(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_demangling_context_get_type()))
+#define G_DEMANGLING_CONTEXT_GET_IFACE(inst)    (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_demangling_context_get_type(), GDemanglingContextIface))
+#define G_DEMANGLING_CONTEXT_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DEMANGLING_CONTEXT, GDemanglingContextClass))
+
+
+/* Contexte de décodage (instance) */
+typedef struct _GDemanglingContext GDemanglingContext;
+
+/* Contexte de décodage (classe) */
+typedef struct _GDemanglingContextClass GDemanglingContextClass;
+
+
+/* Indique le type défini pour un contexte de décodage. */
+GType g_demangling_context_get_type(void);
+
+/* Fournit le type créé à l'issue du codage. */
+GOpenidaType *g_demangling_context_get_decoded_type(const GDemanglingContext *);
+
+
+
+#endif  /* _FORMAT_MANGLING_CONTEXT_H */
diff --git a/src/format/mangling/demangler.c b/src/format/mangling/demangler.c
index e8b6b0f..47ffd36 100644
--- a/src/format/mangling/demangler.c
+++ b/src/format/mangling/demangler.c
@@ -29,79 +29,90 @@
 
 #include "demangler-int.h"
 #include "itanium.h"
+#include "java.h"
 
 
 
-static name_demangler **demanglers = NULL;
-static size_t demanglers_count = 0;
+/* Prépare de quoi effectuer un décodage. */
+typedef GDemanglingContext * (* create_context_fc) (void);
 
+/* Procède au décodage d'une chaîne de caractères. */
+typedef bool (* demangle_type_fc) (GDemanglingContext *, const char *);
 
 
-/* Enregistre un nouveau décodeur de noms. */
-void register_new_demangler(name_demangler *);
 
+/* Appels liés à un décodeur */
+typedef struct _demangling_properties
+{
+    create_context_fc create_context;       /* Création de contextes       */
 
+    demangle_type_fc demangle_type;         /* Décodage d'un type          */
 
+} demangling_properties;
 
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : -                                                            *
-*                                                                             *
-*  Description : Procède au chargement des différents décodeurs de noms.      *
-*                                                                             *
-*  Retour      : true pour indiquer un chargement réussi, false sinon.        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
 
-bool init_all_demanglers(void)
-{
-    register_new_demangler(create_itanium_demangler());
+/* Liste des décodeurs */
+static demangling_properties demanglers[DGT_COUNT] = {
 
-    return true;
+    [DGT_ITANIUM] = {
+        .create_context = (create_context_fc)NULL,
+        .demangle_type = (demangle_type_fc)NULL
+    },
+
+    [DGT_JAVA] = {
+        .create_context = (create_context_fc)g_java_dcontext_new,
+        .demangle_type = (demangle_type_fc)demangle_java_type
+    }
+
+};
 
-}
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : demangler = décodeur opérationnel.                           *
+*  Paramètres  : type = identifiant du décodeur visé.                         *
 *                                                                             *
-*  Description : Enregistre un nouveau décodeur de noms.                      *
+*  Description : Fournit la référence correspondant à un décodeur donné.      *
 *                                                                             *
-*  Retour      : -                                                            *
+*  Retour      : Adresse du décodeur trouvé ou NULL.                          *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-void register_new_demangler(name_demangler *demangler)
+name_demangler *get_demangler_by_type(DemanglerType type)
 {
-    demanglers = (name_demangler **)realloc(demanglers, ++demanglers_count * sizeof(name_demangler *));
-    demanglers[demanglers_count - 1] = demangler;
+    name_demangler *result;                 /* Adresse à retourner         */
+
+    result = NULL;//demanglers[0];
+
+    return result;
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : type = identifiant du décodeur visé.                         *
+*  Paramètres  : demangler = décodeur à utiliser.                             *
+*                name      = chaîne de caractères à décoder.                  *
 *                                                                             *
-*  Description : Fournit la référence correspondant à un décodeur donné.      *
+*  Description : Tente de décoder une chaîne de caractères donnée.            *
 *                                                                             *
-*  Retour      : Adresse du décodeur trouvé ou NULL.                          *
+*  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-name_demangler *get_demangler_by_type(DemanglerType type)
+GBinRoutine *try_to_demangle_routine(name_demangler *demangler, const char *name)
 {
-    name_demangler *result;                 /* Adresse à retourner         */
-
-    result = demanglers[0];
+    GBinRoutine *result;                    /* Construction à remonter     */
 
+    result = NULL;
+    /*
+    if (demangler->can_be_demangled(demangler, name))
+        result = demangler->demangle_routine(demangler, name);
+    */
     return result;
 
 }
@@ -109,8 +120,8 @@ name_demangler *get_demangler_by_type(DemanglerType type)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : demangler = décodeur à utiliser.                             *
-*                name      = chaîne de caractères à décoder.                  *
+*  Paramètres  : type = type de décodeur à utiliser.                          *
+*                desc = chaîne de caractères à décoder.                       *
 *                                                                             *
 *  Description : Tente de décoder une chaîne de caractères donnée.            *
 *                                                                             *
@@ -120,14 +131,26 @@ name_demangler *get_demangler_by_type(DemanglerType type)
 *                                                                             *
 ******************************************************************************/
 
-GBinRoutine *try_to_demangle_routine(name_demangler *demangler, const char *name)
+GOpenidaType *demangle_type(DemanglerType type, const char *desc)
 {
-    GBinRoutine *result;                    /* Construction à remonter     */
+    GOpenidaType *result;                   /* Construction à remonter     */
+    GDemanglingContext *context;            /* Contexte pour le décodage   */
 
     result = NULL;
-
+    /*
     if (demangler->can_be_demangled(demangler, name))
         result = demangler->demangle_routine(demangler, name);
+    */
+
+    context = demanglers[type].create_context();
+
+    if (demanglers[type].demangle_type(context, desc))
+    {
+        result = g_demangling_context_get_decoded_type(context);
+        g_object_ref(result);
+    }
+
+    g_object_unref(context);
 
     return result;
 
diff --git a/src/format/mangling/demangler.h b/src/format/mangling/demangler.h
index fb23f16..0cdadb5 100644
--- a/src/format/mangling/demangler.h
+++ b/src/format/mangling/demangler.h
@@ -35,7 +35,10 @@
 /* Identifiant des décodeurs existants */
 typedef enum _DemanglerType
 {
-    DGT_ITANIUM                             /* Gnu V3                      */
+    DGT_ITANIUM,                            /* Gnu V3                      */
+    DGT_JAVA,                               /* Java / DEX                  */
+
+    DGT_COUNT
 
 } DemanglerType;
 
@@ -45,9 +48,6 @@ typedef struct _name_demangler name_demangler;
 
 
 
-/* Procède au chargement des différents décodeurs de noms. */
-bool init_all_demanglers(void);
-
 /* Fournit la référence correspondant à un décodeur donné. */
 name_demangler *get_demangler_by_type(DemanglerType);
 
@@ -55,5 +55,9 @@ name_demangler *get_demangler_by_type(DemanglerType);
 GBinRoutine *try_to_demangle_routine(name_demangler *, const char *);
 
 
+/* Tente de décoder une chaîne de caractères donnée. */
+GOpenidaType *demangle_type(DemanglerType, const char *);
+
+
 
 #endif  /* _FORMAT_MANGLING_DEMANGLER_H */
diff --git a/src/format/mangling/java.h b/src/format/mangling/java.h
new file mode 100644
index 0000000..08dafe3
--- /dev/null
+++ b/src/format/mangling/java.h
@@ -0,0 +1,59 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * java.h - prototypes pour le décodage des noms d'éléments selon Java
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA 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.
+ *
+ *  OpenIDA 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/>.
+ */
+
+
+#ifndef _FORMAT_MANGLING_JAVA_H
+#define _FORMAT_MANGLING_JAVA_H
+
+
+#include <stdbool.h>
+
+
+#include "context.h"
+#include "demangler.h"
+
+
+
+/* ------------------------- CONTEXTE POUR LE DECODAGE JAVA ------------------------- */
+
+
+/* Contexte de décodage Java (instance) */
+typedef struct _GJavaDContext GJavaDContext;
+
+/* Contexte de décodage Java (classe) */
+typedef struct _GJavaDContextClass GJavaDContextClass;
+
+
+/* Prépare de quoi effectuer un décodage Java. */
+GDemanglingContext *g_java_dcontext_new(void);
+
+
+
+
+
+
+/* Procède au décodage d'une chaîne de caractères. */
+bool demangle_java_type(GJavaDContext *, const char *);
+
+
+
+#endif  /* _FORMAT_MANGLING_JAVA_H */
diff --git a/src/format/mangling/java_gram.y b/src/format/mangling/java_gram.y
new file mode 100644
index 0000000..3522b01
--- /dev/null
+++ b/src/format/mangling/java_gram.y
@@ -0,0 +1,271 @@
+
+%{
+
+
+
+#include "context-int.h"
+#include "demangler-int.h"
+#include "java.h"
+
+
+
+/* ------------------------- CONTEXTE POUR LE DECODAGE JAVA ------------------------- */
+
+
+#define G_TYPE_JAVA_DCONTEXT               g_java_dcontext_get_type()
+#define G_JAVA_DCONTEXT(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_java_dcontext_get_type(), GJavaDContext))
+#define G_IS_JAVA_DCONTEXT(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_java_dcontext_get_type()))
+#define G_JAVA_DCONTEXT_GET_IFACE(inst)    (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_java_dcontext_get_type(), GJavaDContextIface))
+#define G_JAVA_DCONTEXT_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_JAVA_DCONTEXT, GJavaDContextClass))
+
+
+/* Contexte de décodage Java (instance) */
+struct _GJavaDContext
+{
+    GDemanglingContext parent;              /* A laisser en premier        */
+
+};
+
+/* Contexte de décodage Java (classe) */
+struct _GJavaDContextClass
+{
+    GDemanglingContextClass parent;         /* A laisser en premier        */
+
+};
+
+
+/* Indique le type défini pour un contexte de décodage. */
+static GType g_java_dcontext_get_type(void);
+
+/* Initialise la classe des contextes de décodage. */
+static void g_java_dcontext_class_init(GJavaDContextClass *);
+
+/* Initialise une instance de contexte pour décodage. */
+static void g_java_dcontext_init(GJavaDContext *);
+
+
+
+
+
+
+
+%}
+
+
+%union {
+
+    void /*GOpenidaType*/ *type;
+
+    char *text;                             /* Chaîne de caractères        */
+
+}
+
+%parse-param { GJavaDContext *context }
+
+%token V Z B S C I J F D
+%token L SEMICOLON
+%token SLASH DOLLAR
+%token TEXT
+
+%type <type> type_descriptor field_type_descriptor non_array_field_type_descriptor full_class_name
+
+%type <text> TEXT
+
+
+%{
+
+/* De lexi.c... */
+/*int yylex(YYSTYPE *, YYLTYPE *);*/
+void java_restart(FILE *);
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+extern YY_BUFFER_STATE java__scan_string(const char *);
+extern void java__delete_buffer(YY_BUFFER_STATE);
+
+ extern int java_lex (void);
+
+
+/* Affiche un message d'erreur concernant l'analyse. */
+/*int yyerror(const YYLTYPE *, bool, char **, unsigned char *, char *);*/
+
+%}
+
+
+%%
+
+
+input:
+    type_descriptor                     { G_DEMANGLING_CONTEXT(context)->type = $1; }
+	;
+
+type_descriptor:
+    'V'                                 { $$ = g_basic_type_new(BTP_VOID); }
+    | field_type_descriptor             { $$ = $1; }
+    ;
+
+field_type_descriptor:
+	non_array_field_type_descriptor     { $$ = $1; }
+    ;
+
+non_array_field_type_descriptor:
+	Z                                   { $$ = g_basic_type_new(BTP_BOOL); }
+	| B                                 { $$ = g_basic_type_new(BTP_UCHAR); }
+	| S                                 { $$ = g_basic_type_new(BTP_SHORT); }
+	| C                                 { $$ = g_basic_type_new(BTP_CHAR); }
+	| I                                 { $$ = g_basic_type_new(BTP_INT); }
+	| J                                 { $$ = g_basic_type_new(BTP_LONG); }
+	| F                                 { $$ = g_basic_type_new(BTP_FLOAT); }
+	| D                                 { $$ = g_basic_type_new(BTP_DOUBLE); }
+	| L full_class_name SEMICOLON       { $$ = $2; }
+    ;
+
+full_class_name:
+    TEXT                                { $$ = g_class_enum_type_new(CET_CLASS, $1); }
+    | full_class_name SLASH TEXT        {
+                                            $$ = g_class_enum_type_new(CET_CLASS, $3);
+                                            g_openida_type_set_namespace($$, $1);
+                                            g_object_unref($1);
+                                        }
+    | full_class_name DOLLAR TEXT       {
+                                            $$ = g_class_enum_type_new(CET_CLASS, $3);
+                                            g_openida_type_set_namespace($$, $1);
+                                            g_object_unref($1);
+                                        }
+    ;
+
+
+%%
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                           CONTEXTE POUR LE DECODAGE JAVA                           */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour un contexte de décodage. */
+G_DEFINE_TYPE(GJavaDContext, g_java_dcontext, G_TYPE_DEMANGLING_CONTEXT);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des contextes de décodage.              *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_java_dcontext_class_init(GJavaDContextClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = instance à initialiser.                            *
+*                                                                             *
+*  Description : Initialise une instance de contexte pour décodage.           *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_java_dcontext_init(GJavaDContext *context)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Prépare de quoi effectuer un décodage Java.                  *
+*                                                                             *
+*  Retour      : Instance du contexte mis en place.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDemanglingContext *g_java_dcontext_new(void)
+{
+    GDemanglingContext *result;             /* Structure à retourner       */
+
+    result = g_object_new(G_TYPE_JAVA_DCONTEXT, NULL);
+
+    return result;
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * Affiche un message d'erreur concernant l'analyse.
+ * @param yyloc informations concernant les coordonnées du soucis.
+ * @param hunt indique le type de passe réalisée.
+ * @param ucode code résultant compilé.
+ * @param index indice de commande à mettre à jour.
+ * @param msg indications humaines sur l'événement.
+ * @return 0.
+ */
+int java_error(/*const YYLTYPE *yyloc, bool hunt, char **ucode, unsigned char *index, */char *msg)
+{
+
+
+
+	fprintf(stderr, "ERREUR !\n");
+	fprintf(stderr, "%s\n", msg);
+
+	return -1;
+
+}
+
+
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte de décodage à utiliser.                   *
+*                desc    = chaîne de caractères à décoder.                    *
+*                                                                             *
+*  Description : Procède au décodage d'une chaîne de caractères.              *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool demangle_java_type(GJavaDContext *context, const char *desc)
+{
+	YY_BUFFER_STATE buffer;                 /* Tampon pour bison           */
+	int ret;                                /* Bilan de l'appel            */
+
+	buffer = java__scan_string(desc);
+	ret = yyparse(context);
+	java__delete_buffer(buffer);
+
+    return (ret == 0);
+
+}
diff --git a/src/format/mangling/java_tok.l b/src/format/mangling/java_tok.l
new file mode 100644
index 0000000..06777f9
--- /dev/null
+++ b/src/format/mangling/java_tok.l
@@ -0,0 +1,33 @@
+
+%{
+
+#include "libjavamangling_la-java_gram.h" 
+
+%}
+
+
+%option noyywrap
+%option yylineno
+
+%x string
+
+
+%%
+
+V                       { return V; }
+Z                       { return Z; }
+B                       { return B; }
+S                       { return S; }
+C                       { return C; }
+I                       { return I; }
+J                       { return J; }
+F                       { return F; }
+D                       { return D; }
+L                       { printf("Got 'L'\n"); BEGIN(string); return L; }
+<string>[/]             { printf("Got '/'\n"); return SLASH; }
+<string>[$]             { printf("Got '$'\n"); return DOLLAR; }
+<string>[;]             { BEGIN(INITIAL); return SEMICOLON; }
+
+<string>[A-Za-z0-9]*    { java_lval.text = yytext; printf("Got text:'%s'\n", yytext); return TEXT; }
+
+%%