gtk_compile.c

Go to the documentation of this file.

/*
 
  $Id: gtk_compile.c 23065 2016-03-02 09:05:50Z coelho $
 
  Copyright 1989-2016 MINES ParisTech
 
  This file is part of PIPS.
 
  PIPS 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
  any later version.
 
  PIPS 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 PIPS.  If not, see <http://www.gnu.org/licenses/>.
 
*/
#ifdef HAVE_CONFIG_H
    #include "pips_config.h"
#endif
 
#include <stdlib.h>
#include <stdio.h>
 
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "ri-util.h"
#include "misc.h"
#include "phases.h"
#include "database.h"
#include "pipsdbm.h"
#include "pipsmake.h"
#include "top-level.h"
#include "preprocessor.h"
 
// imports gtk
#undef test_undefined // also defined in glib included from gtk
#include <gtk/gtk.h>
#include "gpips.h"
 
#define HPFC_COMPILE "Compile an HPF program"
#define HPFC_MAKE "Make an HPF program"
#define HPFC_RUN "Run an HPF program"
 
static GtkWidget *compile_menu, *compile_menu_item;
static GtkWidget *dynamic_hpf_output_files_menu,
                *dynamic_hpf_output_files_menu_item;
 
void apply_on_each_compile_item(void(* function_to_apply_on_each_menu_item)(
                GtkWidget *)) {
        guint i;
 
        GtkWidget * child;
        GList * compile_menu_children = gtk_container_get_children(GTK_CONTAINER(
                        compile_menu));
        for (i = 0; i < g_list_length(compile_menu_children); i++) {
                child = (GtkWidget *) g_list_nth_data(compile_menu_children, i);
                if (!GTK_IS_MENU_ITEM(child))
                        continue;
                if (GTK_IS_SEPARATOR(child))
                        continue;
                function_to_apply_on_each_menu_item(child);
        }
        g_list_free(compile_menu_children);
}
 
void disable_compile_selection() {
        apply_on_each_compile_item(disable_item);
}
 
void enable_compile_selection() {
        apply_on_each_compile_item(enable_item);
}
 
void notify_hpfc_file_view(GtkWidget * widget, gpointer data) {
        const char * file_name = gpips_gtk_menu_item_get_label(widget);
        char * path_name = hpfc_generate_path_name_of_file_name(file_name);
 
        (void) alloc_first_initialized_window(FALSE);
 
        gpips_file_view(path_name, file_name, "HPFC File", "HPFC", "HPFC");
        user_log("HPFC View of \"%s\" done.\n", file_name);
}
 
void generate_a_menu_with_HPF_output_files(GtkWidget * widget, gpointer data) {
        guint i;
        GtkWidget * menu_item;
 
        gen_array_t file_names = gen_array_make(0);
        int file_number = 0;
 
        int return_code;
        char *hpfc_directory;
 
        /* Create a new menu with the content of the hpfc directory: */
 
        if (dynamic_hpf_output_files_menu != NULL)
                /* First, free the old menu if it exist: */
                /* We can remove all the menu it now: */
                gtk_menu_item_remove_submenu(GTK_MENU_ITEM(
                                dynamic_hpf_output_files_menu_item));
 
        return_code = hpfc_get_file_list(file_names, &hpfc_directory);
 
        dynamic_hpf_output_files_menu = gtk_menu_new();
 
        if (return_code == -1) {
                user_warning("generate_a_menu_with_HPF_output_files",
                                "Directory \"%s\" not found... \n"
                                        " Have you run the HPFC compiler from the Compile menu?\n",
                                hpfc_directory);
 
                menu_item = gtk_menu_item_new_with_label(
                                "*** No HPFC directory found ! ***");
                gtk_menu_shell_append(GTK_MENU_SHELL(dynamic_hpf_output_files_menu),
                                menu_item);
        } else if (file_number == 0) {
                user_warning("generate_a_menu_with_HPF_output_files",
                                "No file found in the directory \"%s\"... \n"
                                        " Have you run the HPFC compiler from the Compile menu?\n",
                                hpfc_directory);
 
                menu_item
                                = gtk_menu_item_new_with_label("*** No HPFC file found ! ***");
                gtk_menu_shell_append(GTK_MENU_SHELL(dynamic_hpf_output_files_menu),
                                menu_item);
        } else {
                for (i = 0; i < file_number; i++) {
                        menu_item = gtk_menu_item_new_with_label(gen_array_item(file_names,
                                        i));
                        gtk_menu_append(GTK_MENU(dynamic_hpf_output_files_menu), menu_item);
                        g_signal_connect(G_OBJECT(menu_item), "activate", G_CALLBACK(
                                        notify_hpfc_file_view), NULL);
                }
 
                gen_array_full_free(file_names);
        }
        gtk_menu_item_set_submenu(
                        GTK_MENU_ITEM(dynamic_hpf_output_files_menu_item),
                        dynamic_hpf_output_files_menu);
}
 
/* quick fix around pipsmake, FC, 23/10/95
 */
static bool gpips_hpfc_install_was_performed_hack = FALSE;
 
void initialize_gpips_hpfc_hack_for_fabien_and_from_fabien() {
        gpips_hpfc_install_was_performed_hack = FALSE;
}
 
void hpfc_notify(GtkWidget * menu_item, gpointer data) {
        const char *label;
    char *modulename;
 
        modulename = db_get_current_module_name();
        if (!modulename) {
                prompt_user("No module selected");
                return;
        }
 
        label = gpips_gtk_menu_item_get_label(menu_item);
 
        /* I apply the installation only once, whatever...
         * Quick fix because the right dependences expressed for pipsmake
         * do not seem to work. It seems that the verification of up to date
         * resources is too clever... FC.
         */
        if (!gpips_hpfc_install_was_performed_hack) {
                safe_apply(BUILDER_HPFC_INSTALL, modulename);
                gpips_hpfc_install_was_performed_hack = TRUE;
        }
 
        if (same_string_p(label, HPFC_COMPILE))
                ;
        else if (same_string_p(label, HPFC_MAKE))
                safe_apply_outside_the_notifyer(BUILDER_HPFC_MAKE, modulename);
        else if (same_string_p(label, HPFC_RUN))
                safe_apply_outside_the_notifyer(BUILDER_HPFC_RUN, modulename);
        else
                pips_internal_error("Bad choice: %s", label);
}
 
void create_compile_menu() {
        GtkWidget *hpfc_compile_menu_item, *hpfc_make_menu_item,
                        *hpfc_run_menu_item;
 
        compile_menu = gtk_menu_new();
 
        hpfc_compile_menu_item = gtk_menu_item_new_with_label(HPFC_COMPILE);
        hpfc_make_menu_item = gtk_menu_item_new_with_label(HPFC_MAKE);
        hpfc_run_menu_item = gtk_menu_item_new_with_label(HPFC_RUN);
 
        g_signal_connect(G_OBJECT(hpfc_compile_menu_item), "activate",
                        G_CALLBACK(hpfc_notify), NULL);
        g_signal_connect(G_OBJECT(hpfc_make_menu_item), "activate",
                        G_CALLBACK(hpfc_notify), NULL);
        g_signal_connect(G_OBJECT(hpfc_run_menu_item), "activate",
                        G_CALLBACK(hpfc_notify), NULL);
 
        gtk_menu_shell_append(GTK_MENU_SHELL(compile_menu), hpfc_compile_menu_item);
        gtk_menu_shell_append(GTK_MENU_SHELL(compile_menu), hpfc_make_menu_item);
        gtk_menu_shell_append(GTK_MENU_SHELL(compile_menu), hpfc_run_menu_item);
        gtk_menu_shell_append(GTK_MENU_SHELL(compile_menu),
                        gtk_separator_menu_item_new());
 
        dynamic_hpf_output_files_menu = gtk_menu_new();
        dynamic_hpf_output_files_menu_item = gtk_menu_item_new_with_label(
                        "View the HPF Compiler Output");
        gtk_menu_item_set_submenu(
                        GTK_MENU_ITEM(dynamic_hpf_output_files_menu_item),
                        dynamic_hpf_output_files_menu);
 
        gtk_menu_shell_append(GTK_MENU_SHELL(compile_menu),
                        dynamic_hpf_output_files_menu_item);
        // each time the menu is accessed, it is regenerated
        g_signal_connect(G_OBJECT(dynamic_hpf_output_files_menu_item), "activate",
                        G_CALLBACK(generate_a_menu_with_HPF_output_files), NULL);
 
        compile_menu_item = gtk_menu_item_new_with_label("Compile");
        gtk_menu_item_set_submenu(GTK_MENU_ITEM(compile_menu_item), compile_menu);
 
        gtk_menu_bar_append(GTK_MENU_BAR(main_window_menu_bar), compile_menu_item);
        gtk_widget_show(compile_menu_item);
        gtk_widget_show_all(compile_menu);
}