prettyprint.c

Go to the documentation of this file.

/*
 
  $Id: prettyprint.c 23412 2017-08-09 15:07:09Z irigoin $
 
  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
/* package generic effects :  Beatrice Creusillet 5/97
 *
 * File: prettyprint.c
 * ~~~~~~~~~~~~~~~~~~~
 *
 * This File contains the generic functions necessary for the prettyprint of
 * all types of effects.
 *
 */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
#include "linear.h"
 
#include "genC.h"
 
#include "misc.h"
 
#include "text.h"
#include "text-util.h"
 
#include "ri.h"
#include "ri-util.h"
 
#include "effects.h"
#include "effects-util.h"
 
// ??? for GRAPH_FILE_EXT
#include "top-level.h"
 
#include "resources.h"
#include "pipsdbm.h"
#include "properties.h"
 
#include "prettyprint.h"
 
// for free_value_mappings()?
// ??? could/should be removed?
#include "transformer.h"
// for module_to_value_mappings()?
// ??? could/should be removed?
#include "semantics.h"
 
#include "effects-generic.h"
 
/***************************************************** ACTION INTERPRETATION */
 
static string
  read_action_interpretation = "read",
  write_action_interpretation = "write";
 
void set_action_interpretation(string r, string w)
{
  read_action_interpretation = r;
  write_action_interpretation = w;
}
 
void reset_action_interpretation(void)
{
  read_action_interpretation = "read";
  write_action_interpretation = "write";
}
 
string action_interpretation(int tag)
{
  return tag==is_action_read ?
    read_action_interpretation : write_action_interpretation;
}
 
/****************************************************************************/
 
static bool is_user_view_p = false;
static hash_table nts = hash_table_undefined;
 
void
set_is_user_view_p(bool user_view_p)
{
    is_user_view_p = user_view_p;
}
 
static bool prettyprint_with_attachments_p = false;
 
void
set_prettyprint_with_attachments(bool attachments_p)
{
    prettyprint_with_attachments_p = attachments_p;
}
 
 
/****************************************************** PRETTYPRINT STUFFS */
 
typedef struct
{
  string name;
  bool is_a_summary;
  gen_chunk* resource;
  generic_text_function get_text;
  generic_prettyprint_function prettyprint;
  generic_attachment_function attach;
}
  prettyprint_stuff, *p_prettyprint_stuff;
 
/* the required prettyprints are stored in the specified list items.
 * there can be any number of them. They are stored.
 */
static list /* of p_prettyprint_stuff */ lp = NIL;
 
void
reset_generic_prettyprints(void)
{
  gen_map(free, lp);
  gen_free_list(lp);
  lp = NIL;
}
 
void
set_a_generic_prettyprint(
  string resource_name,
  bool is_a_summary,
  gen_chunk* res,
  generic_text_function tf,
  generic_prettyprint_function tp,
  generic_attachment_function ta)
{
  p_prettyprint_stuff pps =
    (p_prettyprint_stuff) malloc(sizeof(prettyprint_stuff));
 
  pps->name         = resource_name;
  pps->is_a_summary = is_a_summary;
  pps->resource     = res;
  pps->get_text     = tf;
  pps->prettyprint  = tp;
  pps->attach       = ta;
 
  lp = CONS(VOID_STAR, pps, lp); /* hum... */
}
 
void
add_a_generic_prettyprint(
  string resource_name,
  bool is_a_summary,
  generic_text_function tf,
  generic_prettyprint_function tp,
  generic_attachment_function ta)
{
  set_a_generic_prettyprint(resource_name, is_a_summary,
                            gen_chunk_undefined, tf, tp, ta);
}
 
static void
load_resources(const char* module_name)
{
  list l;
  for (l=lp; l; POP(l))
  {
    p_prettyprint_stuff pps = (p_prettyprint_stuff) STRING(CAR(l));
    pps->resource =
        (gen_chunk*) db_get_memory_resource(pps->name, module_name, true);
  }
}
 
static list
load_list(statement_effects m, statement s)
{
  effects e = apply_statement_effects(m, s);
  list el = effects_effects(e);
  pips_assert("Retrieved effects are consistent", effects_consistent_p(e));
  return el;
}
 
/********************************************************************* TEXT */
 
/* returns the text associated to a specified prettyprint and statement
 */
static text
resource_text(
  entity module __attribute__ ((__unused__)),
  int margin __attribute__ ((__unused__)),
  statement stat,
  p_prettyprint_stuff pps)
{
    list l_eff = NIL;
    text l_eff_text;
 
    pips_assert("must not be a summary", !pps->is_a_summary);
 
    if (is_user_view_p)
    {
        statement i;
 
        if (!statement_undefined_p
            (i = apply_number_to_statement(nts, statement_number(stat))))
        {
            l_eff = load_list((statement_effects) pps->resource, i);
        }
        else
            l_eff = (list) HASH_UNDEFINED_VALUE;
    }
    else
    {
        l_eff = load_list((statement_effects) pps->resource, stat);
        ifdebug(1)
         {
             if (l_eff != (list) HASH_UNDEFINED_VALUE &&
                 l_eff != list_undefined) 
             {
                 pips_debug(1, "current effects:\n");
                 (*(pps->prettyprint))(l_eff);
             }
         }
    }
 
    l_eff_text = (*(pps->get_text))(l_eff);
 
    /* (*attach_effects_decoration_to_text_func)(the_effect_text); */
 
    return l_eff_text;
}
 
/* returns the text of all required summaries
 */
static text
text_summary_any_effect_type(
    entity module __attribute__ ((__unused__)))
{
    text result = make_text(NIL);
    list l;
    for (l=lp; l; POP(l))
    {
        p_prettyprint_stuff pps = (p_prettyprint_stuff) STRING(CAR(l));
        if (pps->is_a_summary) {
            pips_debug(5, "considering resource %s\n", pps->name);
            MERGE_TEXTS(result, (*(pps->get_text))
                        (effects_effects( (effects) pps->resource)));
        }
    }
 
    return result;
}
 
/* returns the text of all required effects associated to statement stat
 */
static text
text_statement_any_effect_type(
    entity module,
    int margin,
    statement stat)
{
    text result = make_text(NIL);
    list l;
    for (l=lp; l; POP(l))
    {
        p_prettyprint_stuff pps = (p_prettyprint_stuff) STRING(CAR(l));
        if (!pps->is_a_summary) {
            pips_debug(5, "considering resource %s\n", pps->name);
            MERGE_TEXTS(result, resource_text(module, margin, stat, pps));
        }
    }
 
    return result;
}
 
static text
get_any_effects_text(
    const char* module_name,
    bool give_code_p, bool use_values)
{
    entity module;
    statement module_stat, user_stat = statement_undefined;
    text txt = make_text(NIL);
    string pp;
 
    /* current entity
     */
    set_current_module_entity(module_name_to_entity(module_name));
    module = get_current_module_entity();
 
    /* current statement
     */
    set_current_module_statement((statement) db_get_memory_resource
                                 (DBR_CODE, module_name, true));
    module_stat = get_current_module_statement();
 
    /* resources to be prettyprinted...
     */
    load_resources(module_name);
 
    if (use_values)
      {
        /* To set up the hash table to translate value into value names */
        set_cumulated_rw_effects((statement_effects)
                                 db_get_memory_resource
                                 (DBR_CUMULATED_EFFECTS, module_name, true));
        set_proper_rw_effects((statement_effects)
                                 db_get_memory_resource
                                 (DBR_PROPER_EFFECTS, module_name, true));
        module_to_value_mappings(module);
      }
 
   /* Since we want to prettyprint with a sequential syntax, save the
       PRETTYPRINT_PARALLEL property that may select the parallel output
       style before overriding it: */
    pp = strdup(get_string_property("PRETTYPRINT_PARALLEL"));
    /* Select the default prettyprint style for sequential prettyprint: */
    set_string_property("PRETTYPRINT_PARALLEL",
                        get_string_property("PRETTYPRINT_SEQUENTIAL_STYLE"));
 
 
 
    debug_on("EFFECTS_DEBUG_LEVEL");
 
    if(is_user_view_p)
    {
        user_stat =  (statement)
            db_get_memory_resource(DBR_PARSED_CODE, module_name, true);
 
        nts = allocate_number_to_statement();
        nts = build_number_to_statement(nts, module_stat);
 
        ifdebug(1)
            print_number_to_statement(nts);
    }
 
    /* prepare the prettyprinting */
    init_prettyprint(text_statement_any_effect_type);
 
    /* summary regions first */
    MERGE_TEXTS(txt, text_summary_any_effect_type(module));
 
    if (give_code_p)
        /* then code with effects, using text_statement_any_effect_type */
        MERGE_TEXTS(txt, text_module(module,
                                     is_user_view_p? user_stat : module_stat));
 
    if(is_user_view_p)
    {
        hash_table_free(nts);
        nts = hash_table_undefined;
    }
 
    close_prettyprint();
 
    debug_off();
 
 
    /* Restore the previous PRETTYPRINT_PARALLEL property for the next
       parallel code prettyprint: */
    set_string_property("PRETTYPRINT_PARALLEL", pp);
    free(pp);
 
    if (use_values)
      {
        free_value_mappings();
        reset_cumulated_rw_effects();
        reset_proper_rw_effects();
 
      }
 
    reset_current_module_entity();
    reset_current_module_statement();
 
    return txt;
}
 
/* generic engine for prettyprinting effects.
 */
bool
print_source_or_code_effects_engine(
    const char* module_name,
    string file_suffix,
    bool use_values)
{
    char *file_name, *file_resource_name;
    bool success = true;
    entity e_module = module_name_to_entity(module_name);
 
    /* Set the prettyprint language */
    value mv = entity_initial(e_module);
    if(value_code_p(mv)) {
      code c = value_code(mv);
      set_prettyprint_language_from_property(language_tag(code_language(c)));
    } else {
      /* Should never arise */
      set_prettyprint_language_from_property(is_language_fortran);
    }
 
    file_name =
      strdup(concatenate(file_suffix,
                         get_bool_property
                         ("PRETTYPRINT_UNSTRUCTURED_AS_A_GRAPH") ? 
                         GRAPH_FILE_EXT : "",
 
                         /* To exploit the language sensitive prettyprint ability of the display */
                         c_module_p(e_module)? ".c" : ".f",
                         NULL));
    file_resource_name = 
        get_bool_property("PRETTYPRINT_UNSTRUCTURED_AS_A_GRAPH") ?
        DBR_GRAPH_PRINTED_FILE : 
            (is_user_view_p ? DBR_PARSED_PRINTED_FILE : DBR_PRINTED_FILE);
 
    if (prettyprint_with_attachments_p)
        begin_attachment_prettyprint();
    
    success = make_text_resource_and_free
        (module_name,
         file_resource_name,
         file_name,
         get_any_effects_text(module_name, true, use_values));
 
    if (prettyprint_with_attachments_p)
        end_attachment_prettyprint();
 
    return success;
}
 
 
 
 
 
/************************************************************ INTERFACES */
 
static void 
push_prettyprints(
    string resource_name,
    string summary_resource_name)
{
 
  if (!string_undefined_p(resource_name))
    add_a_generic_prettyprint(resource_name,
        false,
        effects_to_text_func,
        effects_prettyprint_func,
        attach_effects_decoration_to_text_func);
 
  if (!string_undefined_p(summary_resource_name))
    add_a_generic_prettyprint(summary_resource_name,
        true,
        effects_to_text_func,
        effects_prettyprint_func,
        attach_effects_decoration_to_text_func);
}
 
/* get the text
 */
text
get_any_effect_type_text(
    const char* module_name,
    string resource_name,
    string summary_resource_name,
    bool give_code_p)
{
    text txt;
    push_prettyprints(resource_name, summary_resource_name);
    txt = get_any_effects_text(module_name, give_code_p, false);
    reset_generic_prettyprints();
    return txt;
}
 
/* initial engine
 */
bool
print_source_or_code_with_any_effects_engine(
    const char* module_name,
    string resource_name,
    string summary_resource_name,
    string file_suffix,
    bool use_values)
{
    bool ok;
    push_prettyprints(resource_name, summary_resource_name);
    ok = print_source_or_code_effects_engine(module_name, file_suffix, use_values);
    reset_generic_prettyprints();
    return ok;
}
 
 
void generic_print_effects( list pc)
{
  // remove consistency check which creates a generic -> convex dependency
  /*
  // Well that should not be done this way BC
  if (effect_consistent_p_func == region_consistent_p &&
      effects_reference_sharing_p(pc, false)) {
    pips_internal_error("A list of regions share some references");
  }
  */
 
  if (pc != NIL) {
    FOREACH(EFFECT, e, pc) {
      if(store_effect_p(e))
        (*effect_consistent_p_func)(e);
      (*effect_prettyprint_func)(e);
    }
  }
  else
    fprintf(stderr, "\t<NONE>\n");
}