util.c

Go to the documentation of this file.

/*
 
  $Id: util.c 23493 2018-10-23 13:15:05Z 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 <stdio.h>
#include <string.h>
 
#include "genC.h"
#include "linear.h"
 
#include "properties.h"
#include "misc.h"
#include "pipsdbm.h"
 
#include "ri.h"
#include "ri-util.h"
#include "text-util.h"
 
#include "icfg.h"
 
void safe_free_vertex(vertex ver, list l_of_vers)
{
    if (!gen_in_list_p(ver, l_of_vers))
        free_vertex(ver);
    return;
}
 
list safe_add_vertex_to_list(vertex ver, list l_of_vers)
{
    if (!gen_in_list_p(ver, l_of_vers))
        ADD_ELEMENT_TO_LIST(l_of_vers, VERTEX, ver);
    return l_of_vers;
}
 
list list_of_connected_nodes(vertex ver, list l_of_vers)
{
    MAP(SUCCESSOR, succ, {
        vertex ver_child = successor_vertex(succ);
        l_of_vers = safe_add_vertex_to_list(ver_child, l_of_vers);
        l_of_vers = list_of_connected_nodes(ver_child, l_of_vers);
    }, vertex_successors(ver));
    return l_of_vers;
}
 
static string convert_string_for_daVinci_graph (string s)
{
  string r;
  int l = strlen(s);
  if (l == 0) /* if empty, do nothing */
    return strdup(s);
  else {
    int len;
    r = (string) malloc(l + 3);
    memset(r, 0, l + 3);
    if (strstr(s, "C               <") == s) {/* effects lines */
      r[0] = ' '; /* delete the comment of effects */
      strcpy(r + 1, s + 1);
      len = l+1;
    } else {
      strcpy(r, s);
      len = l;
    }
    // append a \n if needed
    if (r[len-1] != '\n')
      r[len] = '\n';
  }
  return r;
}
 
vertex get_vertex_by_string(const char* str_name, list l_of_vers)
{
    MAP(VERTEX, ver, {
        text ver_label = (text)vertex_vertex_label(ver);
        list sens = text_sentences(ver_label);
        sentence ver_first_sen = SENTENCE(CAR(sens));
        string ver_name = first_word_of_sentence(ver_first_sen);
        string ver_real_name = remove_newline_of_string(ver_name);
        if (same_string_p(ver_real_name, str_name) || same_string_p(ver_name, str_name)) {
            free(ver_real_name);
            return ver;
        } else
            free(ver_real_name);
    }, l_of_vers);
    return vertex_undefined;
}
 
 
list safe_make_successor(vertex ver_parent, vertex ver_child, list l_of_vers)
{
    successor succ;
    sentence ver_child_first_sen = SENTENCE(CAR(text_sentences((text)vertex_vertex_label(ver_child))));
    string ver_child_name = first_word_of_sentence(ver_child_first_sen);
 
    /* search if it was made yet, do not make */
    MAP(SUCCESSOR, succ, {
        vertex ver = successor_vertex(succ);
        sentence ver_first_sen = SENTENCE(CAR(text_sentences((text)vertex_vertex_label(ver))));
        string ver_name = first_word_of_sentence(ver_first_sen);
        if (same_string_p(ver_name, ver_child_name)) return l_of_vers;
    }, vertex_successors(ver_parent));
 
    /* if it was not made, do it */
    succ = make_successor(NULL, ver_child);
    ADD_ELEMENT_TO_LIST(vertex_successors(ver_parent), SUCCESSOR, succ);
    /* add vertex parent to the list of vertex */
    l_of_vers = safe_add_vertex_to_list(ver_parent, l_of_vers);
 
    return l_of_vers;
}
 
 
void print_graph_of_text_to_daVinci(FILE * f_out, list l_of_vers)
{
    bool first_node_parent = true;
    fprintf(f_out, "[\n");
 
    FOREACH (VERTEX, ver_parent, l_of_vers) {
      bool first_node_child = true;
      text node_parent_text = (text)vertex_vertex_label(ver_parent);
      bool first_sentence = true;
 
      if (first_node_parent)
        first_node_parent = false;
      else
        fprintf(f_out, ",\n");
 
      FOREACH (SENTENCE, sen, text_sentences(node_parent_text)){
        string s = sentence_to_string(sen);
        if (first_sentence) {
          string tmp = remove_newline_of_string (s);
          fprintf(f_out, "l(\"%s\",n(\"\",[a(\"OBJECT\",\"", tmp);
          first_sentence = false;
          free (tmp);
        }
        if (strstr(s, CALL_MARK)) {
          /*fprintf(f_out, convert_string_for_daVinci_graph(s + strlen(CALL_MARK)));*/
        } else {
          string r = convert_string_for_daVinci_graph(s);
          fputs(r, f_out);
          free(r);
        }
      }
 
      fprintf(f_out, "\")],[\n");
 
      FOREACH (SUCCESSOR, succ, vertex_successors(ver_parent)){
        vertex ver_child = successor_vertex(succ);
        text node_child_text = (text)vertex_vertex_label(ver_child);
        sentence node_child_sen = SENTENCE(CAR(text_sentences(node_child_text)));
        string node_name_child = remove_newline_of_string(first_word_of_sentence(node_child_sen));
 
        if (first_node_child)
          first_node_child = false;
        else
          fprintf(f_out, ",\n");
        fprintf(f_out, "  l(\"\",e(\"\",[],r(\"%s\")))", node_name_child);
        free(node_name_child);
      }
 
      fprintf(f_out, "]))");
    }
 
    fprintf(f_out, "\n]");
 
    return;
}
 
void print_graph_daVinci_from_starting_node(FILE * f_out, vertex start_ver)
{
    list l = NIL;
    ADD_ELEMENT_TO_LIST(l, VERTEX, start_ver);
    l = list_of_connected_nodes(start_ver, l);
    print_graph_of_text_to_daVinci(f_out, l);
    gen_free_list(l);
    return;
}
 
void print_marged_text_from_starting_node(FILE *fd, int margin, vertex start_ver, list l_of_vers)
{
    if (!vertex_undefined_p(start_ver)) {
        text txt = (text)vertex_vertex_label(start_ver);
        MAP(SENTENCE, sen, {
            string s = sentence_to_string(sen);
            string call_mark = strstr(s, CALL_MARK);
            if(call_mark) {
                vertex ver_child = get_vertex_by_string(call_mark + strlen(CALL_MARK), l_of_vers);
                print_marged_text_from_starting_node(fd, margin + (call_mark - s), ver_child, l_of_vers);
            } else if (strlen(s)) { /* if s in not empty, ok write out */
              string tmp = remove_newline_of_string(s);
              fprintf(fd, "%*s%s\n", margin, "", tmp);
              free (tmp);
            }
        }, text_sentences(txt));
    }
    return;
}
 
bool make_resource_from_starting_node
(const char* mod_name, string res_name, string file_ext, vertex start_ver, list l_of_vers, bool res_text_type)
{
    string filename, localfilename, dir;
    FILE *fd;
 
    localfilename = db_build_file_resource_name(res_name, mod_name, file_ext);
    dir = db_get_current_workspace_directory();
    filename = strdup(concatenate(dir, "/", localfilename, NULL));
    /*free(dir);*/ /* this line may cause a problem of bus errone*/
 
    fd = safe_fopen(filename, "w");
    if (!vertex_undefined_p(start_ver)) {
        if (res_text_type) {
            print_marged_text_from_starting_node(fd, 0, start_ver, l_of_vers);
            safe_fclose(fd, filename);
            write_an_attachment_file(filename);
        } else {
            print_graph_daVinci_from_starting_node(fd, start_ver);
            safe_fclose(fd, filename);
        }
    }
    DB_PUT_FILE_RESOURCE(res_name, mod_name, localfilename);
    free(filename); /* this line must be after DB_PUT_FILE_RESOURCE for the reason of memory liberation */
 
    return true;
}