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
/* print complementary sections */
#include <stdlib.h>
#include <stdlib.h>
 
#include "all.h"
#include "text-util.h"
#include "text.h"
#include "prettyprint.h"
#include "top-level.h"
 
/* {{{ banner */
 
/* 
 * package comp_regions : Alexis Platonoff, 5 September 1990,  
 *                   Beatrice Creusillet, April 1994
 *
 * -------------- 
 * prettyprint.c
 * --------------
 *
 * This file contains the functions specific to the prettyprinting of comp_regions.
 *
 */
 
/* }}} */
 
 
#define REGION_BUFFER_SIZE 2048
 
#define REGION_FORESYS_PREFIX "C$REG"
#define PIPS_NORMAL_PREFIX "C"
 
/* {{{ function prototype */
 
static bool in_out_comp_regions_p = false;
static bool is_user_view_p = false;
static hash_table nts = hash_table_undefined;
 
static text text_statement_array_comp_regions(entity, int, statement);
static text text_array_comp_regions(list);
static bool print_code_with_comp_regions(const char*, string, string, string);
static text get_any_comp_regions_text(const char*, string, string, bool);
 
/* }}} */
 
text get_text_comp_regions(const char* module_name)
{
    is_user_view_p = false;
    in_out_comp_regions_p = false;
 
    return get_any_comp_regions_text(module_name,
                                DBR_REGIONS,
                                DBR_SUMMARY_REGIONS,
                                false);
}
 
 
/* bool print_source_regions(const char* module_name)
 * input    : the name of the current module
 * modifies : nothing.
 * comment  : prints the original source code with the corresponding regions.   
 */
bool print_source_comp_regions(module_name)
const char* module_name;
{
    is_user_view_p = true;
    in_out_comp_regions_p = false;
 
    return print_code_with_comp_regions(module_name,
                                   DBR_REGIONS,
                                   DBR_SUMMARY_REGIONS,
                                   USER_REGION_SUFFIX);
}
 
 
/* bool print_code_comp_regions(const char* module_name)
 * input    : the name of the current module
 * modifies : nothing.
 * comment  : prints the source code with the corresponding regions.    
 */
bool print_code_comp_regions(module_name)
const char* module_name;
{
    is_user_view_p = false;
    in_out_comp_regions_p = false;
 
    return print_code_with_comp_regions(module_name,
                                   DBR_COMPSEC,
                                   DBR_SUMMARY_COMPSEC,
                                   SEQUENTIAL_COMPSEC_SUFFIX);
}
 
/* bool print_code_with_comp_regions(const char* module_name, list summary_comp_regions)
 * input    : the name of the current module, the name of the region and
 *            summary region resources and the file suffix
 *            the comp_regions are in the global variable local_regions_map.
 * modifies : nothing.
 * comment  : prints the source code with the corresponding comp_regions.       
 */
static bool print_code_with_comp_regions(const char* module_name,
                                    string resource_name,
                                    string summary_resource_name,
                                    string file_suffix)
{
    char *file_name, *file_resource_name;
 
    file_name = strdup(concatenate(file_suffix,
                                  get_bool_property
                                  ("PRETTYPRINT_UNSTRUCTURED_AS_A_GRAPH") ? 
                                  GRAPH_FILE_EXT : "",
                                  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);
 
    bool success = make_text_resource(module_name, file_resource_name,
                                 file_name,
                                 get_any_comp_regions_text(module_name,
                                    resource_name,
                                    summary_resource_name,
                                    true));
 
    free(file_name);
    return success ;
}
 
/*{{{  get any comp_regions text*/
static text get_any_comp_regions_text(const char* module_name,
                             string resource_name,
                             string summary_resource_name,
                             bool give_code_p)
{
    list summary_comp_regions;
    entity module;
    statement module_stat, user_stat = statement_undefined;
    text txt = make_text(NIL);
 
    debug_on("COMP_REGIONS_DEBUG_LEVEL");
 
    /* load comp_regions corresponding to the current module */
    /* change later */
 
    set_local_comp_regions_map(comp_secs_map_to_listmap
                          ((statement_mapping) 
                           db_get_memory_resource
                           (resource_name, module_name, true)) );
 
    summary_comp_regions = 
             comp_desc_set_to_list((comp_desc_set) db_get_memory_resource
                        (summary_resource_name,
                         module_name, true));
    
    set_current_module_entity( local_name_to_top_level_entity(module_name));
    module = get_current_module_entity();
 
    set_current_module_statement((statement) db_get_memory_resource
                                 (DBR_CODE, module_name, true));
 
    module_stat = get_current_module_statement();
 
    /* 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);
 
    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(5)
        {
            print_number_to_statement(nts);
        }
    }
 
    /* prepare the prettyprinting */
    /* summary comp_regions first */
    init_prettyprint(text_statement_array_comp_regions);
    MERGE_TEXTS(txt, text_array_comp_regions(summary_comp_regions));
 
    if (give_code_p)
        /* then code with comp_regions, using text_array_comp_regions */
        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();
 
    reset_current_module_entity();
    reset_current_module_statement();
    free_local_comp_regions_map(); 
    reset_cumulated_rw_effects();
    reset_proper_rw_effects();
 
    return txt;
}
/*}}}*/
/*{{{  text statement array comp_regions*/
/* static text text_statement_array_comp_regions(entity module, int margin, statement stat)
 * output   : a text representing the list of array comp_regions associated with the
 *            statement stat.
 * comment  : if the number of array comp_regions is not nul, then empty lines are
 *            added before and after the text of the list of comp_regions.
 */
static text
text_statement_array_comp_regions(entity __attribute__ ((unused)) module,
                                  int __attribute__ ((unused)) margin,
                                  statement stat)
{
    list l_reg = NIL;
 
    if (is_user_view_p) {
        statement i;
 
        i = (statement) hash_get(nts, (char *) statement_number(stat));
 
        if (i != (statement) HASH_UNDEFINED_VALUE) {
            l_reg = load_statement_local_comp_regions(i);
        }
        else
            l_reg = (list) HASH_UNDEFINED_VALUE;
    }
    else
        l_reg = load_statement_local_comp_regions(stat);
 
    
    /* Necessary because of unreachable statements - In this case, no comp_regions
     * are stored in the statement_mapping, and their values are thus 
     * HASH_UNDEFINED_VALUE or list_undefined. BC. 25/07/95. */
    /* GO 31/7/95: I replace it by a different test in text_array_comp_regions */
 
    return text_array_comp_regions(l_reg);
}
 
/*}}}*/
/*{{{  text array comp_regions*/
 
/* static text text_array_comp_regions(list l_reg)
 * input    : a list of comp_regions
 * output   : a text representing this list of comp_regions.
 * comment  : if the number of array comp_regions is not nul, and if 
 *            PRETTYPRINT_LOOSE is true, then empty lines are
 *            added before and after the text of the list of comp_regions.
 */
static text text_array_comp_regions(l_reg)
list l_reg;
{
    text reg_text = make_text(NIL);
    /* in case of loose_prettyprint, at least one region to print? */
    bool loose_p = get_bool_property("PRETTYPRINT_LOOSE");
    bool one_p = false;  
 
    /* GO: No redundant test anymore, see  text_statement_array_comp_regions */
    if (l_reg != (list) HASH_UNDEFINED_VALUE && l_reg != list_undefined) 
    {
/*
        MAP(COMP_DESC, reg,
        {
            entity ent = effect_entity(reg);
            if ( get_bool_property("PRETTYPRINT_SCALAR_comp_regions") || 
                ! entity_scalar_p(ent)) 
            {
                if (loose_p && !one_p )
                {
                    ADD_SENTENCE_TO_TEXT(reg_text, 
                                         make_sentence(is_sentence_formatted, 
                                                       strdup("\n")));
                    one_p = true;
                }
                MERGE_TEXTS(reg_text, text_comp_region(reg));
            }   
        },
            l_reg);
            */
 
        if (loose_p && one_p)
            ADD_SENTENCE_TO_TEXT(reg_text, 
                                 make_sentence(is_sentence_formatted, 
                                               strdup("\n")));
    }
    return(reg_text);
}
/*}}}*/
/*{{{  text all comp_regions*/
 
/* text text_all_comp_regions(list l_reg)
 * input    : a list of comp_regions
 * output   : a text representing this list (with non-array comp_regions)
 */
text text_all_comp_regions(l_reg)
list l_reg;
{
    text reg_text = make_text(NIL);
 
    MAP(EFFECT, reg,
    {
        MERGE_TEXTS(reg_text, text_region(reg));
    },
        l_reg);
    return(reg_text);
}
/*}}}*/
/*{{{  text comp_regions*/
/* text text_comp_regions(list l_reg)
 * input    : a list of comp_regions
 * output   : a text representing this list (with non-array comp_regions)
 */
text text_comp_regions(l_reg)
list l_reg;
{
 
    text reg_text = make_text(NIL);
  /* change later */
    return(reg_text);
 
    MAP(EFFECT, reg,
    {
        entity ent = effect_entity(reg);
        if (! entity_scalar_p(ent)) 
        {           
            MERGE_TEXTS(reg_text, text_comp_region(reg));
        }       
    },
        l_reg);       
 
   return(reg_text);
}
/*}}}*/
/*{{{  text region*/
/* text text_region(effect reg)
 * input    : a region
 * output   : a text consisting of several lines of commentaries, 
 *            representing the region
 * modifies : nothing
 */
text text_comp_region(reg)
effect reg;
{
    text t_reg = make_text(NIL);
    bool foresys = get_bool_property("PRETTYPRINT_FOR_FORESYS");
    string str_prefix;
 
    if (foresys)
        str_prefix = REGION_FORESYS_PREFIX;
    else
        str_prefix = PIPS_NORMAL_PREFIX;
    
    if(reg == effect_undefined)
    {
        ADD_SENTENCE_TO_TEXT(t_reg, 
                             make_pred_commentary_sentence(strdup("<REGION_UNDEFINED>"),
                                                           str_prefix));
        user_log("[region_to_string] unexpected effect undefined\n");
    }
    else
    {
        free_text(t_reg);
        t_reg = words_predicate_to_commentary(words_effect(reg), str_prefix);
    }
 
    return(t_reg);   
}
#if 0
 
/* list words_comp_region(comp_desc Dad)
 * input    : a region.
 * output   : a list of strings representing the region.
 * modifies : nothing.
 * comment  :   because of 'buffer', this function cannot be called twice before
 * its output is processed. Also, overflows in relation_to_string() 
 * cannot be prevented. They are checked on return.
 */
list words_comp_region(comp_desc Dad)
{
  char buffer[REGION_BUFFER_SIZE];
 
  int Rank;
  int i;
  tag RefType;
  list pc = NIL;
 
  Rank = context_info_rank(simple_section_context
                           (comp_sec_hull(comp_desc_section(Dad))));
 
  buffer[0] = '\0';
 
 
  sprintf(buffer, "\nReference Template :: \n[ ");
  for (i=0; i < Rank; i++) {
    RefType = GetRefTemp(comp_desc_section(Dad),i);
    switch(RefType) {
      case is_rtype_lininvariant:
                        sprintf(buffer, "INV");
                                                break;
      case is_rtype_linvariant:
                        sprintf(buffer, "VAR");
                                                break;
      case is_rtype_nonlinear:
                        sprintf(buffer, "NON");
                                                break;
      default:
                        sprintf(buffer, "NUL");
                                                break;
    }
 
                if( i < (Rank-1) ) 
                        sprintf(buffer, ", ");
                else
                sprintf(buffer, " ]\n");
  }
  sprintf(buffer,"\n");
   
  pc = CHAIN_SWORD(pc, buffer);
 
  return(pc);
}
#endif
 
/*}}}*/