/* Chrysalide - Outil d'analyse de fichiers binaires * java.c - sorties en langage Java * * Copyright (C) 2010-2013 Cyrille Bagard * * This file is part of Chrysalide. * * 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 . */ #include "java.h" #include "../output-int.h" #include "../../analysis/type.h" /* TODO : remme */ /* Sortie selon le langage Java (instance) */ struct _GJavaOutput { GLangOutput parent; /* A laisser en premier */ }; /* Sortie selon le langage Java (classe) */ struct _GJavaOutputClass { GLangOutputClass parent; /* A laisser en premier */ }; /* Initialise la classe des sorties en langage Java. */ static void g_java_output_class_init(GJavaOutputClass *); /* Initialise une instance de sortie en langage Java. */ static void g_java_output_init(GJavaOutput *); /* Marque le début d'une série de commentaires. */ static GBufferLine *g_java_output_start_comments(GJavaOutput *, GCodeBuffer *); /* Poursuit l'ajout d'une ligne de commentaires. */ static GBufferLine *g_java_output_continue_comments(GJavaOutput *, GCodeBuffer *, const char *, size_t); /* Marque la fin d'une série de commentaires. */ static GBufferLine *g_java_output_end_comments(GJavaOutput *, GCodeBuffer *); /* Ajoute un commentaire à un tampon donné. */ static GBufferLine *g_java_output_write_comments(GJavaOutput *, GCodeBuffer *, const char *, size_t); /* Imprime dans un tampon donné une méthode de comparaison. */ static void g_java_output_write_comp_sign(GJavaOutput *, GBufferLine *, CompSignType); /* Imprime dans un tampon donné un opérateur logique. */ static void g_java_output_write_cond_operator(GLangOutput *, GBufferLine *, CondOperatorType); /* Débute la définition d'une classe. */ static GBufferLine *g_java_output_start_class(GJavaOutput *, GCodeBuffer *, const GDataType *); /* Termine la définition d'une classe. */ static void g_java_output_end_class(GJavaOutput *, GCodeBuffer *); /* Débute la définition d'une routine. */ static GBufferLine *g_java_output_start_routine_prototype(GJavaOutput *, GCodeBuffer *, const GDataType *); /* Termine la définition d'une routine. */ static void g_java_output_end_routine_prototype(GJavaOutput *, GCodeBuffer *, GBufferLine *); /* Commence la définition du corps d'une routine. */ static void g_java_output_start_routine_body(GJavaOutput *, GCodeBuffer *, GBufferLine *); /* Termine la définition du corps d'une routine. */ static void g_java_output_end_routine_body(GJavaOutput *, GCodeBuffer *); /* Commence la définition d'un bloc de code. */ static GBufferLine *g_java_output_start_code_block(GJavaOutput *, GCodeBuffer *, GBufferLine *, size_t); /* Termine la définition d'un bloc de code. */ static GBufferLine *g_java_output_end_code_block(GJavaOutput *, GCodeBuffer *, GBufferLine *, size_t); /* Emballe une expression conditionelle. */ static GBufferLine *g_java_output_encapsulate_condition(GLangOutput *, GCodeBuffer *, GBufferLine *, bool); /* Indique le type défini pour une sortie en langage Java. */ G_DEFINE_TYPE(GJavaOutput, g_java_output, G_TYPE_LANG_OUTPUT); /****************************************************************************** * * * Paramètres : klass = classe à initialiser. * * * * Description : Initialise la classe des sorties en langage Java. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void g_java_output_class_init(GJavaOutputClass *klass) { } /****************************************************************************** * * * Paramètres : output = instance à initialiser. * * * * Description : Initialise une instance de sortie en langage Java. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void g_java_output_init(GJavaOutput *output) { GLangOutput *lang; /* Autre version de l'objet */ lang = G_LANG_OUTPUT(output); lang->start_comments = (rlgbuf_fc)g_java_output_start_comments; lang->cont_comments = (write_comments_fc)g_java_output_continue_comments; lang->end_comments = (rlgbuf_fc)g_java_output_end_comments; lang->write_comments = (write_comments_fc)g_java_output_write_comments; lang->comp_sign = (write_comp_sign_fc)g_java_output_write_comp_sign; lang->cond_op = (write_cond_op_fc)g_java_output_write_cond_operator; lang->start_class = (rlgbuftp_fc)g_java_output_start_class; lang->end_class = (lgbuf_fc)g_java_output_end_class; lang->start_routine_proto = (rlgbuftp_fc)g_java_output_start_routine_prototype; lang->end_routine_proto = (lgbufln_fc)g_java_output_end_routine_prototype; lang->start_routine_body = (lgbufln_fc)g_java_output_start_routine_body; lang->end_routine_body = (lgbuf_fc)g_java_output_end_routine_body; lang->start_code_block = (rlgbuflnsz_fc)g_java_output_start_code_block; lang->end_code_block = (rlgbuflnsz_fc)g_java_output_end_code_block; lang->encaps_cond = (lo_buf_ln_bool_fc)g_java_output_encapsulate_condition; } /****************************************************************************** * * * Paramètres : - * * * * Description : Crée une nouvelle sortie en langage Java. * * * * Retour : Imprimeur créé. * * * * Remarques : - * * * ******************************************************************************/ GLangOutput *g_java_output_new(void) { GBufferLine *result; /* Composant à retourner */ result = g_object_new(G_TYPE_JAVA_OUTPUT, NULL); return G_LANG_OUTPUT(result); } /****************************************************************************** * * * Paramètres : output = encadrant de l'impression en langage de prog. * * buffer = tampon de sortie à disposition. * * * * Description : Marque le début d'une série de commentaires. * * * * Retour : Nouvelle ligne constituée. * * * * Remarques : - * * * ******************************************************************************/ static GBufferLine *g_java_output_start_comments(GJavaOutput *output, GCodeBuffer *buffer) { GBufferLine *result; /* Nouvelle ligne à retourner */ result = g_code_buffer_append_new_line_fixme(buffer); g_buffer_line_append_text(result, BLC_COMMENTS, "/**", 3, RTT_COMMENT, NULL); return result; } /****************************************************************************** * * * Paramètres : output = encadrant de l'impression en langage de prog. * * buffer = tampon de sortie à disposition. * * text = texte à insérer dans l'existant. * * length = taille du texte à traiter. * * * * Description : Poursuit l'ajout d'une ligne de commentaires. * * * * Retour : Ligne nouvellement créée. * * * * Remarques : - * * * ******************************************************************************/ static GBufferLine *g_java_output_continue_comments(GJavaOutput *output, GCodeBuffer *buffer, const char *text, size_t length) { GBufferLine *result; /* Adresse nouvelle à remonter */ result = g_code_buffer_append_new_line_fixme(buffer); g_buffer_line_append_text(result, BLC_COMMENTS, " * ", 3, RTT_COMMENT, NULL); if (length > 0) g_buffer_line_append_text(result, BLC_COMMENTS, text, length, RTT_COMMENT, NULL); return result; } /****************************************************************************** * * * Paramètres : output = encadrant de l'impression en langage de prog. * * buffer = tampon de sortie à disposition. * * * * Description : Marque la fin d'une série de commentaires. * * * * Retour : Nouvelle ligne constituée. * * * * Remarques : - * * * ******************************************************************************/ static GBufferLine *g_java_output_end_comments(GJavaOutput *output, GCodeBuffer *buffer) { GBufferLine *result; /* Nouvelle ligne à retourner */ result = g_code_buffer_append_new_line_fixme(buffer); g_buffer_line_append_text(result, BLC_COMMENTS, " */", 3, RTT_COMMENT, NULL); return result; } /****************************************************************************** * * * Paramètres : output = encadrant de l'impression en langage de prog. * * buffer = tampon de sortie à disposition. * * text = texte à insérer dans l'existant. * * length = taille du texte à traiter. * * * * Description : Ajoute un commentaire à un tampon donné. * * * * Retour : Ligne nouvellement créée. * * * * Remarques : - * * * ******************************************************************************/ static GBufferLine *g_java_output_write_comments(GJavaOutput *output, GCodeBuffer *buffer, const char *text, size_t length) { GBufferLine *result; /* Adresse nouvelle à remonter */ result = g_code_buffer_append_new_line_fixme(buffer); g_buffer_line_append_text(result, BLC_COMMENTS, "// ", 3, RTT_COMMENT, NULL); if (length > 0) g_buffer_line_append_text(result, BLC_COMMENTS, text, length, RTT_COMMENT, NULL); return result; } /****************************************************************************** * * * Paramètres : output = encadrant de l'impression en langage de prog. * * line = tampon de sortie à disposition. * * sign = méthode de comparaison à imprimer. * * * * Description : Imprime dans un tampon donné une méthode de comparaison. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void g_java_output_write_comp_sign(GJavaOutput *output, GBufferLine *line, CompSignType sign) { g_buffer_line_append_text(line, BLC_ASSEMBLY_HEAD, " ", 1, RTT_RAW, NULL); switch (sign) { case CST_EQ: g_buffer_line_append_text(line, BLC_ASSEMBLY_HEAD, "==", 2, RTT_SIGNS, NULL); break; case CST_NE: g_buffer_line_append_text(line, BLC_ASSEMBLY_HEAD, "!=", 2, RTT_SIGNS, NULL); break; case CST_LT: g_buffer_line_append_text(line, BLC_ASSEMBLY_HEAD, "<", 1, RTT_SIGNS, NULL); break; case CST_GE: g_buffer_line_append_text(line, BLC_ASSEMBLY_HEAD, ">=", 2, RTT_SIGNS, NULL); break; case CST_GT: g_buffer_line_append_text(line, BLC_ASSEMBLY_HEAD, ">", 1, RTT_SIGNS, NULL); break; case CST_LE: g_buffer_line_append_text(line, BLC_ASSEMBLY_HEAD, "<=", 2, RTT_SIGNS, NULL); break; default: g_buffer_line_append_text(line, BLC_ASSEMBLY_HEAD, "?", 1, RTT_SIGNS, NULL); break; } g_buffer_line_append_text(line, BLC_ASSEMBLY_HEAD, " ", 1, RTT_RAW, NULL); } /****************************************************************************** * * * Paramètres : output = encadrant de l'impression en langage de prog. * * line = tampon de sortie à disposition. * * op = opérateur logique à imprimer. * * * * Description : Imprime dans un tampon donné un opérateur logique. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void g_java_output_write_cond_operator(GLangOutput *output, GBufferLine *line, CondOperatorType op) { g_buffer_line_append_text(line, BLC_ASSEMBLY_HEAD, " ", 1, RTT_RAW, NULL); switch (op) { case COT_AND: g_buffer_line_append_text(line, BLC_ASSEMBLY_HEAD, "&&", 2, RTT_SIGNS, NULL); break; case COT_OR: g_buffer_line_append_text(line, BLC_ASSEMBLY_HEAD, "||", 2, RTT_SIGNS, NULL); break; default: g_buffer_line_append_text(line, BLC_ASSEMBLY_HEAD, "??", 2, RTT_SIGNS, NULL); break; } g_buffer_line_append_text(line, BLC_ASSEMBLY_HEAD, " ", 1, RTT_RAW, NULL); } /****************************************************************************** * * * Paramètres : output = encadrant de l'impression en langage de prog. * * buffer = tampon de sortie à disposition. * * type = désignation de la classe à définir. * * * * Description : Débute la définition d'une classe. * * * * Retour : Ligne nouvellement créée. * * * * Remarques : - * * * ******************************************************************************/ static GBufferLine *g_java_output_start_class(GJavaOutput *output, GCodeBuffer *buffer, const GDataType *type) { GBufferLine *result; /* Adresse nouvelle à remonter */ char *name; /* Désignation humaine */ result = g_code_buffer_append_new_line_fixme(buffer); g_buffer_line_append_text(result, BLC_ASSEMBLY_HEAD, "class", 5, RTT_KEY_WORD, NULL); g_buffer_line_append_text(result, BLC_ASSEMBLY_HEAD, " ", 1, RTT_RAW, NULL); name = _g_data_type_to_string(type, true); g_buffer_line_append_text(result, BLC_ASSEMBLY_HEAD, name, strlen(name), RTT_RAW, NULL); free(name); g_buffer_line_append_text(result, BLC_ASSEMBLY_HEAD, " ", 1, RTT_RAW, NULL); g_buffer_line_append_text(result, BLC_ASSEMBLY_HEAD, "{", 1, RTT_HOOK, NULL); result = g_code_buffer_append_new_line_fixme(buffer); g_code_buffer_inc_indentation(buffer); return result; } /****************************************************************************** * * * Paramètres : output = encadrant de l'impression en langage de prog. * * buffer = tampon de sortie à disposition. * * * * Description : Termine la définition d'une classe. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void g_java_output_end_class(GJavaOutput *output, GCodeBuffer *buffer) { GBufferLine *result; /* Adresse nouvelle à remonter */ g_code_buffer_dec_indentation(buffer); result = g_code_buffer_append_new_line_fixme(buffer); g_buffer_line_append_text(result, BLC_ASSEMBLY_HEAD, "}", 1, RTT_HOOK, NULL); result = g_code_buffer_append_new_line_fixme(buffer); return result; } /****************************************************************************** * * * Paramètres : output = encadrant de l'impression en langage de prog. * * buffer = tampon de sortie à disposition. * * ret = type de retour de la routine traitée. * * * * Description : Débute la définition d'une routine. * * * * Retour : Ligne nouvellement créée. * * * * Remarques : - * * * ******************************************************************************/ static GBufferLine *g_java_output_start_routine_prototype(GJavaOutput *output, GCodeBuffer *buffer, const GDataType *ret) { GBufferLine *result; /* Adresse nouvelle à remonter */ result = g_code_buffer_append_new_line_fixme(buffer); /* TODO */ g_buffer_line_append_text(result, BLC_ASSEMBLY_HEAD, "XXX", 3, RTT_RAW, NULL); return result; } /****************************************************************************** * * * Paramètres : output = encadrant de l'impression en langage de prog. * * buffer = tampon de sortie à disposition. * * line = ligne contenant le prototype de la routine traitée. * * * * Description : Termine la définition d'une routine. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void g_java_output_end_routine_prototype(GJavaOutput *output, GCodeBuffer *buffer, GBufferLine *line) { g_buffer_line_append_text(line, BLC_ASSEMBLY_HEAD, ";", 1, RTT_PUNCT, NULL); } /****************************************************************************** * * * Paramètres : output = encadrant de l'impression en langage de prog. * * buffer = tampon de sortie à disposition. * * line = ligne contenant le prototype de la routine traitée. * * * * Description : Commence la définition du corps d'une routine. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void g_java_output_start_routine_body(GJavaOutput *output, GCodeBuffer *buffer, GBufferLine *line) { /* g_buffer_line_append_text(line, BLC_ASSEMBLY_HEAD, " ", 1, RTT_RAW, NULL); g_buffer_line_append_text(line, BLC_ASSEMBLY_HEAD, "{", 1, RTT_HOOK, NULL); g_code_buffer_inc_indentation(buffer); */ } /****************************************************************************** * * * Paramètres : output = encadrant de l'impression en langage de prog. * * buffer = tampon de sortie à disposition. * * * * Description : Termine la définition du corps d'une routine. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void g_java_output_end_routine_body(GJavaOutput *output, GCodeBuffer *buffer) { GBufferLine *line; /* Nouvelle ligne à constituer */ /* g_code_buffer_dec_indentation(buffer); line = g_code_buffer_append_new_line_fixme(buffer); g_buffer_line_append_text(line, BLC_ASSEMBLY_HEAD, "}", 1, RTT_HOOK, NULL); */ } /****************************************************************************** * * * Paramètres : output = encadrant de l'impression en langage de prog. * * buffer = tampon de sortie à disposition. * * line = ligne contenant le prototype de la routine traitée. * * count = nombre d'éléments du bloc. * * * * Description : Commence la définition d'un bloc de code. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static GBufferLine *g_java_output_start_code_block(GJavaOutput *output, GCodeBuffer *buffer, GBufferLine *line, size_t count) { GBufferLine *result; /* Nouvelle ligne à utiliser */ if (count > 1) { g_buffer_line_append_text(line, BLC_ASSEMBLY_HEAD, " ", 1, RTT_RAW, NULL); g_buffer_line_append_text(line, BLC_ASSEMBLY_HEAD, "{", 1, RTT_HOOK, NULL); } g_code_buffer_inc_indentation(buffer); result = g_code_buffer_append_new_line_fixme(buffer); /* FIXME : n° de ligne */ return result; } /****************************************************************************** * * * Paramètres : output = encadrant de l'impression en langage de prog. * * buffer = tampon de sortie à disposition. * * line = ligne contenant le prototype de la routine traitée. * * count = nombre d'éléments du bloc. * * * * Description : Termine la définition d'un bloc de code. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static GBufferLine *g_java_output_end_code_block(GJavaOutput *output, GCodeBuffer *buffer, GBufferLine *line, size_t count) { GBufferLine *result; /* Nouvelle ligne à constituer */ g_code_buffer_dec_indentation(buffer); result = g_code_buffer_append_new_line_fixme(buffer); if (count > 1) { g_buffer_line_append_text(result, BLC_ASSEMBLY_HEAD, "}", 1, RTT_HOOK, NULL); g_buffer_line_append_text(result, BLC_ASSEMBLY_HEAD, " ", 1, RTT_RAW, NULL); } return result; } /****************************************************************************** * * * Paramètres : output = encadrant de l'impression en langage de prog. * * buffer = tampon de sortie à disposition. * * line = ligne contenant le prototype de la routine traitée.* * opening = précise si la condition débute ou se termine. * * * * Description : Emballe une expression conditionelle. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static GBufferLine *g_java_output_encapsulate_condition(GLangOutput *output, GCodeBuffer *buffer, GBufferLine *line, bool opening) { GBufferLine *result; /* Nouvelle ligne à utiliser */ result = line; if (opening) g_buffer_line_append_text(result, BLC_ASSEMBLY_HEAD, "(", 1, RTT_HOOK, NULL); else g_buffer_line_append_text(result, BLC_ASSEMBLY_HEAD, ")", 1, RTT_HOOK, NULL); return result; }