prettyprint.h File Reference

#include "effects.h"

Include dependency graph for prettyprint.h:

Go to the source code of this file.

Functions
entity	find_or_create_allocatable_struct (basic, string, int)
	Warning! Do not modify this file that is automatically generated! More...
bool	check_common_inclusion (entity)
	area.c More...
cons *	words_cmf_loop_range (range)
	cmfortran.c More...
text	text_loop_cmf (entity, const char *, int, loop, int, list, list)
	===================================================================== More...
expression	remove_modulo (expression)
	craft.c More...
text	text_loop_craft (entity, const char *, int, loop, int, list, list)
	===================================================================== More...
void	sc_syst_debug (Psysteme)
	constraint_to_text.c More...
void	inegalite_debug (Pcontrainte)
void	egalite_debug (Pcontrainte)
string	contrainte_text_format (string, string, text, Pcontrainte, bool, string(*)(Variable), bool, bool)
string	egalite_text_format (string, string, text, Pcontrainte, string(*)(Variable), bool, bool)
string	inegalite_text_format (string, string, text, Pcontrainte, string(*)(void), bool, bool)
void	system_sorted_text_format (string, string, text, Psysteme, string(*)(Variable), bool(*)(Pvecteur), bool)
	lower level hook for regions. More...
void	system_text_format (string, string, text, Psysteme, string(*)(Variable), bool)
	appends ps to line/txt with prefix continuations. More...
void	entity_list_text_format (string, string, text, list, const char *(*)(entity))
list	words_declaration (entity, bool, list *)
	declarations.c More...
list	words_basic (basic, list *)
	what about simple DOUBLE PRECISION, REAL, INTEGER... More...
sentence	sentence_variable (entity, list *)
sentence	Sentence_Variable (entity)
sentence	sentence_head (entity, list *)
	We have no way to distinguish between the SUBROUTINE and PROGRAM They two have almost the same properties. More...
list	words_qualifiers (list)
list	words_type (type, list *, bool)
	obj is the type to describe More...
list	Words_Type (type)
bool	c_brace_expression_p (expression)
list	words_brace_expression (expression, list *)
list	words_dimensions (list, list *)
list	generic_c_words_entity (type, list, bool, bool, list *)
	This recursive function prints a C variable with its type. More...
list	generic_c_words_simplified_entity (type, list, bool, bool, bool, bool, bool, list *)
	Same as above, but the bool is_first is used to skip a type specifier which is useful when several variables or types are defined in a unique statement such as "int i, *pi, ai[10],...;". More...
list	c_words_simplified_entity (type, list, bool, bool, list *)
	The declaration list pointer ppdl is passed down to determine if an internal derived type must be fully expanded within another declaration or not. More...
list	c_words_entity (type, list, list *)
list	safe_c_words_entity (type, list)
text	c_text_entities (entity, list, int, list *)
	Generate declarations for a list of entities belonging to the same statement declaration. More...
text	c_text_related_entities (entity, list, int, int, list *, list)
	It is assumed that all entities in list el can be declared by an unique statement, i.e. More...
text	c_text_entity (entity, entity, int, list *, bool)
	Regeneration of declarations from the symbol table. More...
text	c_text_entity_simple (entity, entity, int)
void	set_prettyprinter_common_hook (string(*)(entity, entity))
	declarations2.c More...
void	reset_prettyprinter_common_hook (void)
text	text_declaration (entity)
	exported for hpfc. More...
text	text_common_declaration (entity, entity)
	needed for hpfc More...
text	text_initializations (entity)
void	print_entity_variable (entity)
	entity.c More...
void	fprint_expression (FILE *, expression)
	expression.c More...
void	print_expression (expression)
	no file descriptor is passed to make is easier to use in a debugging stage. More...
string	expression_to_string (expression)
string	reference_to_string (reference)
void	print_expressions (list)
void	print_syntax_expressions (list)
void	print_syntax (syntax)
void	fprint_reference (FILE *, reference)
void	print_reference (reference)
void	print_reference_list (list)
void	print_references (list)
void	print_normalized (normalized)
bool	maxima_simplify (expression *)
	call maxima to simplify an expression prefer simplify_expression ! More...
void	fprint_list_of_exp (FILE *, list)
	void fprint_list_of_exp(FILE *fp, list exp_l): prints in the file "fp" the list of expression "exp_l". More...
string	close_extension (extension)
	extension.c More...
string	close_extensions (extensions, bool)
string	extension_to_string (extension)
string	extensions_to_string (extensions, bool)
	return a new allocated string with the string representation of the extensions. More...
text	text_loop_90 (entity, const char *, int, loop, int)
	fortran90.c More...
expression	expand_reference (syntax, expression, entity, range)
	A reference cannot always be expanded. More...
expression	expand_expression (expression, entity, range)
void	html_output (const char *, bool)
	html_prettyprinter.c More...
void	html_print_entity_full (entity)
void	html_print_symbol_table (void)
bool	html_prettyprint (const string)
bool	html_prettyprint_symbol_table (const string)
void	printf_loop (loop)
	loop.c More...
void	print_loops_list (entity, list)
string	get_comment_sentinel (void)
	Start a single line comment. More...
string	get_comment_continuation (void)
	Start a single line comment with continuation (blank spaces) More...
unsigned int	get_prettyprint_indentation (void)
text	empty_text (entity, int, statement)
void	init_prettyprint (text(*)(entity, int, statement))
	checks that the prettyprint hook was actually reset... More...
void	close_prettyprint (void)
	because some prettyprint functions may be used for debug, so the last hook set by somebody may have stayed there although being non sense... More...
bool	one_liner_p (statement)
	True is statement "s" can be printed out without enclosing braces when it is the true branch of a test. More...
bool	gcc_if_block_braces_required_p (test)
list	words_loop_range (range, list *)
	exported for craft More...
list	C_loop_range (range, entity, list *)
	Output a Fortan-like do-loop range as a C-like for-loop index part. More...
list	words_range (range, list *)
list	words_subscript_range (range, list *)
	@description FI: array constructor R433, p. More...
list	words_any_reference (reference, list *, const char *(*)(entity))
list	Words_Any_Reference (reference, list, const char *(*)(entity))
list	words_reference (reference, list *)
list	Words_Reference (reference)
void	set_alternate_return_set (void)
void	reset_alternate_return_set (void)
void	add_target_to_alternate_return_set (entity)
text	generate_alternate_return_targets (void)
list	words_regular_call (call, bool, list *)
	words_regular_call used for user subroutine and user function and intrinsics called like user function such as MOD(). More...
list	Words_Regular_Call (call, bool)
list	words_call_intrinsic (call, int, bool, list *)
list	words_goto_label (const char *)
	This function is useful only for parsed codes since gotos are removed by the controlizer. More...
list	eole_fma_specific_op (call, int, bool, list *)
	EOLE : The multiply-add operator is used within the optimize transformation ( JZ - sept 98) - fma(a,b,c) -> ((a*b)+c) More...
list	eole_fms_specific_op (call, int, bool, list *)
	MULTIPLY-SUB operator. More...
void	register_intrinsic_handler (const char *, intrinsic_desc_t *)
	after this call, name and desc are owned by intrinsic_handlers, but will never be deallocated they must point to permanent storage More...
list	words_call (call, int, bool, bool, list *)
	exported for cmfortran.c More...
list	Words_Call (call, int, bool, bool)
list	words_expression (expression, list *)
	This one is exported. More...
list	Words_Expression (expression)
	of string More...
list	words_syntax (syntax, list *)
	exported for expression.c More...
list	Words_Syntax (syntax)
list	words_subexpression (expression, int, bool, list *)
	exported for cmfortran.c More...
list	Words_Subexpression (expression, int, bool)
sentence	sentence_goto_label (entity, const char *, int, const char *, int)
text	text_omp_directive (loop, int)
text	text_loop_default (entity, const char *, int, loop, int, list *, bool)
	exported for fortran90.c More...
text	text_loop (entity, const char *, int, loop, int, list *, bool)
	exported for conversion/look_for_nested_loops.c More...
text	init_text_statement (entity, int, statement)
	exported for unstructured.c More...
void	set_prettyprinter_head_hook (string(*)(entity))
void	reset_prettyprinter_head_hook (void)
bool	C_comment_p (string)
	In case the input code is not C code, non-standard comments have to be detected. More...
text	C_any_comment_to_text (int, string)
	In case comments are not formatted according to C rules, e.g. More...
text	C_standard_comment_to_text (int, string)
text	C_comment_to_text (int, string)
	Special handling for C comments with each line indented according to the context. More...
text	generic_text_statement_enclosed (entity, int, statement, bool, bool, list *, bool, bool)
text	text_statement_enclosed (entity, int, statement, bool, bool, list *)
text	Text_Statement_Enclosed (entity, int, statement, bool, bool)
text	text_statement (entity, int, statement, list *)
text	Text_Statement (entity, int, statement)
text	Text_Proper_Statement (entity, int, statement)
string	proper_statement_to_string (statement)
statement	find_last_statement (statement)
void	set_last_statement (statement)
void	reset_last_statement (void)
bool	last_statement_p (statement)
void	insure_return_as_last_statement (entity, statement *)
list	initialize_previously_declared_entities (entity)
text	text_named_module (entity, entity, statement)
text	text_module (entity, statement)
void	add_control_node_identifier_to_text (text, control)
void	output_a_graph_view_of_the_unstructured_successors (text, entity, int, control)
bool	output_a_graph_view_of_the_unstructured_from_a_control (text, entity, int, control, control)
void	output_a_graph_view_of_the_unstructured (text, entity, const char *, int, unstructured, int)
bool	recompile_module (const string)
	module.c More...
void	print_parameter (parameter)
	parameter.c More...
void	print_parameters (list)
	Display a parameter on stderr, useful for debugging. More...
void	print_mode (mode)
	Display a "mode" on stderr, useful for debugging. More...
void	print_dummy (dummy)
	Display a "dummy" on stderr, useful for debugging. More...
string	close_pragma (pragma)
	pragma.c More...
string	pragma_to_string (pragma)
void	add_expr_to_pragma_expr_list (pragma, expression)
	Add an expression to the pragma current expression list. More...
bool	make_text_resource (const char *, const char *, const char *, text)
	print.c More...
bool	make_text_resource_and_free (const char *, const char *, const char *, text)
bool	user_view_p (void)
	print_code or print_source More...
bool	print_code_or_source (string)
	Generic function to prettyprint some sequential or parallel code, or even user view for the given module. More...
bool	print_code (const string)
bool	print_source (const string)
bool	print_parallelized_code (const string)
bool	print_parallelized90_code (const string)
bool	print_parallelized77_code (const string)
bool	print_parallelizedHPF_code (const string)
bool	print_parallelizedOMP_code (const string)
bool	print_parallelizedMPI_code (const string)
void	dprint (expression)
	For debugging: prettyprint many different kinds of newgen objects FC: type should be gen_chunk... More...
bool	print_code_as_a_graph (const string)
	print_code_as_a_graph.c More...
bool	same_lexpr_name_p (list, list)
	same_names.c More...
bool	same_entity_lname_p (entity, entity)
bool	same_call_name_p (call, call)
bool	same_ref_name_p (reference, reference)
bool	same_range_name_p (range, range)
bool	same_sizeofexpression_name_p (sizeofexpression, sizeofexpression)
bool	same_subscript_name_p (subscript, subscript)
bool	same_cast_name_p (cast, cast)
bool	same_application_name_p (application, application)
bool	same_va_arg_name_p (list, list)
bool	same_syntax_name_p (syntax, syntax)
bool	same_expression_name_p (expression, expression)
	compare two entities for their appearance point of view. More...
void	print_statement_set (FILE *, set)
	statement.c More...
void	fprint_statement (FILE *, statement)
	Print statement "s" on file descriptor "fd". More...
void	print_statement (statement)
	Print a statement on stderr. More...
void	print_statements (list)
void	print_statement_of_module (statement, const char *)
text	statement_to_text (statement)
void	safe_print_statement (statement)
void	print_parallel_statement (statement)
statement	last_statement (statement)
	A simplified version of find_last_statement() located in prettyprint.c and designed to be used within the prettyprinter. More...
void	print_number_to_statement (hash_table)
list	find_statements_interactively (statement)
	prompt the user to select contiguous statement in s More...
void	dump_common_layout (string_buffer, entity, bool, bool)
	symbol_table.c More...
string	get_symbol_table (entity, bool)
void	actual_symbol_table_dump (const char *, bool)
bool	parsed_symbol_table (const char *)
	bool c_symbol_table(const char* module_name) More...
bool	symbol_table (const char *)
	To replace c_symbol_table() and fortran_symbol_table() because the information about the language is available in the symbol table. More...
string	type_to_full_string_definition (type)
	type.c More...
string	string_of_type (const type)
bool	same_type_name_p (const type, const type)
	For naming homogeneity: expression_to_string(), reference_to_string()... More...
string	basic_to_string (basic)
void	print_types (list)
	Very basic and crude debugging function. More...
void	print_type (type)
	For debugging. More...
void	print_qualifiers (list)
void	print_qualifier (qualifier)
text	text_unstructured (entity, const char *, int, unstructured, int, list *)
	unstructured.c More...
list	unstructured_to_trail (unstructured)
void	dump_trail (list)
void	dump_control_to_label_name (hash_table)

Variables
char	lib_ri_util_prettyprint_c_rcsid []
	misc.c More...

Function Documentation

actual_symbol_table_dump()

void actual_symbol_table_dump	(	const char *	module_name,
		bool	is_parsed
	)

This function is called in two different context: as a standalone phase or as part of debugging the parser?!?

Parameters

module_name	odule_name
is_parsed	s_parsed

Definition at line 582 of file symbol_table.c.

{
  FILE *out;
  string ppt;
  bool isfortran = false;
 
  entity module = module_name_to_entity(module_name);
  value v = entity_initial(module);
  if(value_code_p(v)) {
    code c = value_code(v);
    language l = code_language(c);
    if(language_fortran_p(l)||language_fortran95_p(l)) {
      isfortran = true;
    }
    else if(language_c_p(l)) {
      isfortran = false;
      set_prettyprint_language_tag(is_language_c);
    }
    else {
      pips_internal_error("Language %d is not supported.\n");
    }
  }
  else {
    pips_internal_error("Module \"%s\" has no code.\n", module_name);
  }
 
  string symboltable = db_build_file_resource_name(DBR_SYMBOL_TABLE_FILE,
                                                   module_name, NULL);
  string dir = db_get_current_workspace_directory();
  string filename = strdup(concatenate(dir, "/", symboltable, NULL));
  bool reset_p = false;
 
  debug_on("SYMBOL_TABLE_DEBUG_LEVEL");
 
  /* This function is called in two different context: as a
     standalone phase or as part of debugging the parser?!? */
  if(entity_undefined_p(get_current_module_entity())) {
    reset_p = true;
    set_current_module_entity(module);
  }
 
  out = safe_fopen(filename, "w");
 
  ppt = get_symbol_table(module, isfortran);
 
  fprintf(out, "%s\n%s", module_name, ppt);
  safe_fclose(out, filename);
 
  free(dir);
  free(filename);
 
  if(reset_p)
    reset_current_module_entity();
 
  debug_off();
 
  if(is_parsed)
    DB_PUT_FILE_RESOURCE(DBR_PARSED_SYMBOL_TABLE_FILE, module_name, symboltable);
  else
    DB_PUT_FILE_RESOURCE(DBR_SYMBOL_TABLE_FILE, module_name, symboltable);
 
}

References code_language, concatenate(), db_build_file_resource_name(), db_get_current_workspace_directory(), DB_PUT_FILE_RESOURCE, debug_off, debug_on, entity_initial, entity_undefined_p, fprintf(), free(), get_current_module_entity(), get_symbol_table(), is_language_c, language_c_p, language_fortran95_p, language_fortran_p, module, module_name(), module_name_to_entity(), out, pips_internal_error, reset_current_module_entity(), safe_fclose(), safe_fopen(), set_current_module_entity(), set_prettyprint_language_tag(), strdup(), value_code, and value_code_p.

Referenced by parsed_symbol_table(), and symbol_table().

Here is the call graph for this function:

Here is the caller graph for this function:

add_control_node_identifier_to_text()

void add_control_node_identifier_to_text	(	text	,
		control
	)

Referenced by ensure_comment_consistency().

Here is the caller graph for this function:

add_expr_to_pragma_expr_list()

void add_expr_to_pragma_expr_list	(	pragma	pr,
		expression	ex
	)

Add an expression to the pragma current expression list.

Returns

void

Parameters

pr,the	pragma to process.
ex,the	expression to add.

Add the new pragma to the extension list:

Parameters

pr	r
ex	x

Definition at line 147 of file pragma.c.

                                                        {
  pips_assert ("the pragma need to be an expression", pragma_expression_p (pr) );
  /* Add the new pragma to the extension list: */
  list exprs = pragma_expression (pr);
  exprs = gen_expression_cons (ex, exprs);
  pragma_expression (pr) = exprs;
  string str = pragma_to_string (pr);
  pips_debug(5, "after: %s", str);
  free (str);
  return;
}

References free(), gen_expression_cons(), pips_assert, pips_debug, pragma_expression, pragma_expression_p, and pragma_to_string().

Referenced by add_loop_parallel_threshold().

Here is the call graph for this function:

Here is the caller graph for this function:

add_target_to_alternate_return_set()

void add_target_to_alternate_return_set

(

entity

l

)

Definition at line 814 of file misc.c.

{
  ifdebug(1) {
  pips_assert("The target list is initialized",
              !list_undefined_p(set_of_labels_required_for_alternate_returns));
  }
  set_of_labels_required_for_alternate_returns =
    gen_once(l, set_of_labels_required_for_alternate_returns);
}

References gen_once(), ifdebug, list_undefined_p, pips_assert, and set_of_labels_required_for_alternate_returns.

Referenced by words_regular_call().

Here is the call graph for this function:

Here is the caller graph for this function:

basic_to_string()

string basic_to_string

(

basic

b

)

Nga Nguyen, 19/09/2003: To not rewrite the same thing, I use the words_basic() function

Definition at line 87 of file type.c.

{
  /* Nga Nguyen, 19/09/2003: To not rewrite the same thing, I use the words_basic() function*/
  list pdl = NIL;
  return list_to_string(words_basic(b, &pdl));
  gen_free_list(pdl);
}

References gen_free_list(), list_to_string(), NIL, and words_basic().

Referenced by add_formal_to_actual_bindings(), any_expression_to_transformer(), any_user_call_site_to_transformer(), arguments_are_something(), can_terapixify_expression_p(), check_call_basic(), DeclareVariable(), dprint(), dump_common_layout(), dump_functional(), entities_type_and_name(), fortran_user_call_to_transformer(), fprint_any_environment(), fprint_functional(), get_symbol_table(), is_varibale_array_element_specifier(), mpi_recv_ctx(), mpi_send_ctx(), print_entity_variable(), register_scalar_communications(), relation_to_transformer(), rename_op(), sac_commenter(), sentence_basic_declaration(), string_expression_to_transformer(), stub_head(), stub_var_decl(), this_entity_cdeclaration(), type_and_size_of_var(), type_this_call(), type_this_entity_if_needed(), type_this_expression(), type_this_instruction(), TypeFunctionalEntity(), typing_arguments_of_user_function(), typing_function_argument_type_to_return_type(), variable_to_string(), xml_Full_Type(), and xml_TaskReturnParameter().

Here is the call graph for this function:

Here is the caller graph for this function:

C_any_comment_to_text()

text C_any_comment_to_text	(	int	r_margin,
		string	c
	)

In case comments are not formatted according to C rules, e.g.

when prettyprinting Fortran code as C code, add // at beginning of lines

Note: this is supposed to have been dealt with by another function called before, ensure_comment_consistency()

line beginning

line end

current position, pointer in comments

We do not need spaces before a line feed

Parameters

r_margin

_margin

Definition at line 4165 of file misc.c.

{
  string lb = c; /* line beginning */
  string le = c; /* line end */
  string cp = c; /* current position, pointer in comments */
  text ct = make_text(NIL);
  bool is_C_comment = C_comment_p(c);
  int e_margin = r_margin;
 
  /* We do not need spaces before a line feed */
  if(strcmp(c, "\n")==0)
    e_margin = 0;
 
  if(strlen(c)>0) {
    for(;*cp!='\0';cp++) {
      if(*cp=='\n') {
        if(cp!=c || true){ // Do not skip \n
          string cl = gen_strndup0(lb, le-lb);
          sentence s = sentence_undefined;
          if(is_C_comment)
            s = MAKE_ONE_WORD_SENTENCE(e_margin, cl);
          else if(strlen(cl)>0){
            list pc = CHAIN_SWORD(NIL, cl); // cl is uselessly duplicated
            pc = CONS(STRING, MAKE_SWORD("//"), pc);
            s= make_sentence(is_sentence_unformatted,
                             make_unformatted((char *) NULL, 0, e_margin, pc));
          }
          else {
            s = MAKE_ONE_WORD_SENTENCE(0, cl);
          }
          ADD_SENTENCE_TO_TEXT(ct, s);
          free(cl);
        }
        lb = cp+1;
        le = cp+1;
      }
      else
        le++;
    }
    // Final \n has been removed in the parser presumably by Ronan
    // But this is also useful when non-standard comments are added,
    // for instance by phase "comment_prepend"
    if(lb<cp){
      sentence s = sentence_undefined;
      string sl = gen_strndup0(lb,le-lb);
      if(is_C_comment) {
        s = MAKE_ONE_WORD_SENTENCE(e_margin,sl);
      }
      else {
        list pc = CHAIN_SWORD(NIL, sl); // sl is uselessly duplicated
        pc = CONS(STRING, MAKE_SWORD("//"), pc);
        s = make_sentence(is_sentence_unformatted,
                          make_unformatted((char *) NULL, 0, e_margin, pc));
      }
      ADD_SENTENCE_TO_TEXT(ct,s);
      free(sl);
    } else{
      //ADD_SENTENCE_TO_TEXT(ct,MAKE_ONE_WORD_SENTENCE(0,""));
      ;
    }
  }
  else{// Final \n has been removed by Ronan
    //ADD_SENTENCE_TO_TEXT(ct,MAKE_ONE_WORD_SENTENCE(0,""));
    ;
  }
 
  return ct;
}

References ADD_SENTENCE_TO_TEXT, C_comment_p(), CHAIN_SWORD, CONS, cp, free(), gen_strndup0(), is_sentence_unformatted, MAKE_ONE_WORD_SENTENCE, make_sentence(), MAKE_SWORD, make_text(), make_unformatted(), NIL, sentence_undefined, and STRING.

Referenced by C_comment_to_text().

Here is the call graph for this function:

Here is the caller graph for this function:

c_brace_expression_p()

bool c_brace_expression_p

(

expression

e

)

Definition at line 898 of file declarations.c.

{
  if (expression_call_p(e))
    {
      entity f = call_function(syntax_call(expression_syntax(e)));
      if (ENTITY_BRACE_INTRINSIC_P(f))
        return true;
    }
  return false;
}

References call_function, ENTITY_BRACE_INTRINSIC_P, expression_call_p(), expression_syntax, f(), and syntax_call.

Referenced by words_brace_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

C_comment_p()

bool C_comment_p

(

string

c

)

In case the input code is not C code, non-standard comments have to be detected.

Definition at line 4094 of file misc.c.

                           {
  bool is_C_comment=true;
  char * ccp=c;
  char cc=' ';
 
 init:
  cc=*ccp++;
  if(cc==' '|| cc=='\t' || cc=='\n')
   goto init;
 else if( cc=='/')
   goto slash;
 else if(cc=='\000')
   goto end;
 else {
   is_C_comment=false;
   goto end;
 }
 
 slash:
  cc=*ccp++;
  if(cc=='*')
   goto slash_star;
 else if(cc=='/')
   goto slash_slash;
 else{
   is_C_comment=false;
   goto end;
 }
 
 slash_star:
   cc=*ccp++;
 if(cc=='*')
   goto slash_star_star;
  else if(cc=='\0'){
    is_C_comment=false;
    goto end;
  }
 else
   goto slash_star;
 
 slash_slash:
  cc=*ccp++;
  if(cc=='\n')
   goto init;
  if(cc=='\0') // The comment may not end first with a '\n'
     goto end;
 else
   goto slash_slash;
 
 slash_star_star:
  cc=*ccp++;
  if(cc=='/')
   goto init;
  else if(cc=='*')
    goto slash_star_star;
  else if(cc=='\0'){
    is_C_comment=false;
    goto end;
  }
  else
   goto slash_star;
 
 end : return is_C_comment;
}

References end, and init.

Referenced by C_any_comment_to_text(), and C_comment_to_text().

Here is the caller graph for this function:

C_comment_to_text()

text C_comment_to_text	(	int	margin,
		string	comment
	)

Special handling for C comments with each line indented according to the context.

I do not see the interest if the user code is already indented... RK OK, since the blanks outside the comments are removed by the parser.

Parameters

margin	argin
comment	omment

Definition at line 4270 of file misc.c.

{
  text ct = text_undefined;
 
  if(C_comment_p(comment))
    //ct = C_standard_comment_to_text(margin, comment);
    ct = C_any_comment_to_text(margin, comment);
  else
    ct = C_any_comment_to_text(margin, comment);
  return ct;
}

References C_any_comment_to_text(), C_comment_p(), comment(), and text_undefined.

Referenced by text_trail().

Here is the call graph for this function:

Here is the caller graph for this function:

C_loop_range()

list C_loop_range	(	range	obj,
		entity	i,
		list *	ppdl
	)

Output a Fortan-like do-loop range as a C-like for-loop index part.

@description Assume that the increment is an integer so we can generate the good condition. Since the do-loops are recognized in C program part only with this assumptions, it is a good assumption.

call c = syntax_call(expression_syntax(range_increment(obj)));

Complete the initialization assignment

Check the final bound

Increasing or decreasing index?

Assume the increment has an integer value with a known sign If The increment is negative, that means the index is tested against a lower bound Else we assume to test against an upper bound

check if we have something of the form exp -1 as range_upper

Additionally, we want to pretty print a strict comparison if certain conditions are met. This could be the default choice , but the impact on the validation would be huge

Priority for LESS, GREATER, LESS_OR_EQUAL, GREATER_OR_EQUAL: 15

Increment the loop index

Parameters

obj	bj
ppdl	pdl

Definition at line 457 of file misc.c.

{
    list pc;
    /* call c = syntax_call(expression_syntax(range_increment(obj))); */
 
    /* Complete the initialization assignment */
    pc = words_subexpression(range_lower(obj), 0, true, ppdl);
    pc = CHAIN_SWORD(pc,"; ");
 
    /* Check the final bound */
    pc = CHAIN_SWORD(pc, entity_user_name(i));
 
    /* Increasing or decreasing index? */
    expression inc = range_increment(obj);
    /* Assume the increment has an integer value with a known sign
       If The increment is negative, that means the index is tested against
       a lower bound
       Else we assume to test against an upper bound
    */
 
    expression ru = range_upper(obj);
    /* check if we have something of the form exp -1 as range_upper */
    expression ru_minus_one = make_op_exp(PLUS_OPERATOR_NAME,
            copy_expression(ru),
            int_to_expression(1)
            );
 
    /* Additionally, we want to pretty print a strict comparison if
       certain conditions are met. This could be the default choice ,
       but the impact on the validation would be huge */
    set re = get_referenced_entities(ru);
    bool references_unsigned_entity_p = false;
    SET_FOREACH(entity,e,re) {
        references_unsigned_entity_p |= unsigned_type_p(ultimate_type(entity_type(e)));
    }
    set_free(re);
    if( references_unsigned_entity_p ) {
      if(positive_expression_p(inc))
        pc = CHAIN_SWORD(pc, " < ");
      else if(negative_expression_p(inc))
        pc = CHAIN_SWORD(pc, " > ");
      else {
        //pips_internal_error("loop range cannot be prettyprinted because increment sign"
        //                  " is unknown\n");
        pips_user_warning("loop increment sign is unknown: assumed positive\n");
        pc = CHAIN_SWORD(pc, " < ");
      }
      pc = gen_nconc(pc, words_subexpression(ru_minus_one, 0, true, ppdl));
    }
    else {
      // FI: when inc is not a constant integer,
      // expression_negative_integer_value_p() always return false
      if(positive_expression_p(inc))
        pc = CHAIN_SWORD(pc, " <= ");
      else if(negative_expression_p(inc))
        pc = CHAIN_SWORD(pc, " >= ");
      else {
        //pips_internal_error("loop range cannot be prettyprinted because increment sign"
        //                  " is unknown\n");
        pips_user_warning("loop increment sign is unknown: assumed positive\n");
        pc = CHAIN_SWORD(pc, " <= ");
      }
      /* Priority for LESS, GREATER, LESS_OR_EQUAL, GREATER_OR_EQUAL: 15 */
      pc = gen_nconc(pc, words_subexpression(ru, 15, true, ppdl));
    }
    free_expression(ru_minus_one);
    pc = CHAIN_SWORD(pc,"; ");
 
    /* Increment the loop index */
    pc = CHAIN_SWORD(pc, entity_user_name(i));
    pc = CHAIN_SWORD(pc," += ");
    pc = gen_nconc(pc, words_expression(inc, ppdl));
    pc = CHAIN_SWORD(pc,")");
 
    return(pc);
}

References CHAIN_SWORD, copy_expression(), entity_type, entity_user_name(), free_expression(), gen_nconc(), get_referenced_entities(), int_to_expression(), make_op_exp(), negative_expression_p(), pips_user_warning, PLUS_OPERATOR_NAME, positive_expression_p(), range_increment, range_lower, range_upper, SET_FOREACH, set_free(), ultimate_type(), unsigned_type_p(), words_expression(), and words_subexpression().

Referenced by text_loop_default().

Here is the call graph for this function:

Here is the caller graph for this function:

C_standard_comment_to_text()

text C_standard_comment_to_text	(	int	margin,
		string	comment
	)

position of a line end

Find the first end of line:

No end-of-line, so use all the rest of the comment:

Skip the '
' at the end since the line concept is the notion of sentence

Analyze the next line:

Do not indent if the line is empty

Parameters

margin	argin
comment	omment

Definition at line 4237 of file misc.c.

{
  string line;
  string le = comment; /* position of a line end */
  text ct = make_text(NIL);
 
  do {
    /* Find the first end of line: */
    le = strchr(comment, '\n');
    if (le == NULL)
      /* No end-of-line, so use all the rest of the comment: */
      line = strdup(comment);
    else {
      /* Skip the '\n' at the end since the line concept is the notion of
         sentence */
      line = gen_strndup0(comment, le - comment);
      /* Analyze the next line: */
      comment = le + 1;
    }
    /* Do not indent if the line is empty */
    ADD_SENTENCE_TO_TEXT(ct,
                         MAKE_ONE_WORD_SENTENCE(line[0] == '\0' ? 0 : margin,
                                                line));
  } while (le != NULL);
  return ct;
}

References ADD_SENTENCE_TO_TEXT, comment(), gen_strndup0(), line, MAKE_ONE_WORD_SENTENCE, make_text(), NIL, and strdup().

Here is the call graph for this function:

c_text_entities()

text c_text_entities	(	entity	module,
		list	ldecl,
		int	margin,
		list *	ppdl
	)

Generate declarations for a list of entities belonging to the same statement declaration.

ppdl: derived from the parser declared entity; used to decide if a derived type entity de must be declared as a reference to de (e.g. "struct s") or as the type definition of de (e.g. "struct s {}"). Of course, the type can be defined only once, even if it is referenced several times. Hence, pdl, the list pointed to by ppdl is updated in the loop to avoid redeclarations.

Dummy enum must be printed sometimes because their members are exposed directly.

Parameters

module	odule
ldecl	decl
margin	argin
ppdl	pdl

Definition at line 1452 of file declarations.c.

{
  text r = make_text(NIL);
  //list npdl = gen_copy_seq(pdl); // new parser declaration list
 
  FOREACH(ENTITY, e, ldecl) {
    text tmp = text_undefined;
    type t = entity_type(e);
 
    if(!type_area_p(t)
       && ! type_statement_p(t)
       && !type_unknown_p(t)
       && !storage_formal_p(entity_storage(e))
       && !implicit_c_variable_p(e)) {
      string n = entity_name(e);
 
      /* Dummy enum must be printed sometimes because their members
         are exposed directly. */
      if(((strstr(n,DUMMY_ENUM_PREFIX)==NULL)
          || !type_used_in_type_declarations_p(e, ldecl))
         && (strstr(n,STRUCT_PREFIX DUMMY_STRUCT_PREFIX)==NULL
             ||strstr(n,MEMBER_SEP_STRING)!=NULL)
         && (strstr(n,UNION_PREFIX DUMMY_UNION_PREFIX)==NULL
             ||strstr(n,MEMBER_SEP_STRING)!=NULL) ) {
        type et = ultimate_type(entity_type(e));
        bool init_p = true; // So as not to modify the behavior although no initializations are expected here
        // FI: I do not understand the copies of pdl in npdl
        tmp = c_text_entity(module, e, margin, ppdl, init_p);
        MERGE_TEXTS(r,tmp);
 
        if(derived_type_p(et)) {
          entity de = basic_derived(variable_basic(type_variable(et)));
          //gen_remove(&npdl, (void *) de);
          *ppdl = gen_once((void *) de, *ppdl);
        }
      }
    }
  }
 
  //gen_free_list(npdl);
 
  return r;
}

References basic_derived, c_text_entity(), derived_type_p(), DUMMY_ENUM_PREFIX, DUMMY_STRUCT_PREFIX, DUMMY_UNION_PREFIX, ENTITY, entity_name, entity_storage, entity_type, FOREACH, gen_once(), implicit_c_variable_p(), make_text(), MEMBER_SEP_STRING, MERGE_TEXTS, module, NIL, storage_formal_p, STRUCT_PREFIX, text_undefined, type_area_p, type_statement_p, type_unknown_p, type_used_in_type_declarations_p(), type_variable, ultimate_type(), UNION_PREFIX, and variable_basic.

Referenced by c_text_related_entities(), and ensure_comment_consistency().

Here is the call graph for this function:

Here is the caller graph for this function:

c_text_entity()

text c_text_entity	(	entity	module,
		entity	e,
		int	margin,
		list *	ppdl,
		bool	init_p
	)

Regeneration of declarations from the symbol table.

FI: strange recursion, probably due to Francois...

Regeneration of declarations... ==================== Variables and Function prototypes for C =========== pdl is the parser declaration list. It is used to decide if a derived entity should be simply declared, "struct s", or fully defined, "struct s {....}". It is accessed by its pointer ppdl

c_text_related_entities calls c_text_entities calls c_text_entity calls back c_text_related_entities (!) but with only one element... may call words_variable_or_function calls c_words_simplified_entity calls generic_c_words_simplified_entity

Note: text when newline are involved, words when everything fits on one line.

Parameters

module	odule
margin	argin
ppdl	pdl
init_p	nit_p

Definition at line 2087 of file declarations.c.

{
  list el = CONS(ENTITY, e, NIL);
  list il = CONS(EXPRESSION, int_to_expression(init_p? 1 : 0), NIL);
  // No implicit "extern" keyword
  il = CONS(EXPRESSION, int_to_expression(0), NIL);
  text t =  c_text_related_entities(module, el, margin, 0, ppdl, il);
  gen_free_list(el);
  gen_full_free_list(il);
 
  return t;
}

References c_text_related_entities(), CONS, ENTITY, EXPRESSION, gen_free_list(), gen_full_free_list(), int_to_expression(), module, and NIL.

Referenced by c_text_entities(), c_text_entity_simple(), and compilation_unit_text().

Here is the call graph for this function:

Here is the caller graph for this function:

c_text_entity_simple()

text c_text_entity_simple	(	entity	module,
		entity	e,
		int	margin
	)

Parameters

module	odule
margin	argin

Definition at line 2100 of file declarations.c.

{
  list pdl = NIL; // pdl is useless in Fortran or in some debugging situations
  bool init_p = true;
  text t = c_text_entity(module, e, margin, &pdl, init_p);
  gen_free_list(pdl);
 
  return t;
}

References c_text_entity(), gen_free_list(), module, and NIL.

Referenced by stub_text().

Here is the call graph for this function:

Here is the caller graph for this function:

c_text_related_entities()

text c_text_related_entities	(	entity	module,
		list	del,
		int	margin,
		int	sn,
		list *	ppdl,
		list	cl
	)

It is assumed that all entities in list el can be declared by an unique statement, i.e.

their types must be closely related, as in

"int i, *pj, foo();".

But you can also have:

"struct one { struct too {int a;};};"

where no variable is declared. And the parser generate a declaration list stating that "struct two" and "struct one" are declared in this statement.

In other words, this function prints out a C declaration statement, taking into account the derived entities that have to be defined exactly once, pdl. Of course, pdl can be updated by the caller when a derived entity is declared so as to avoid a redeclaration.

At this first level, the declarations of derived types use several lines. If a nested declaration occurs, the nested declaration is packed on a unique line.

List icl indicates for each entity if it should be initialized or not. This is useful for global variable initializations.

If we are not in a compilation unit, the initialization control list is useless and may be wrong because of program transformations such as scalar renaming.

The last entity may be a place holder

overwrite the parser declaration list pdl with del

A declaration has two parts: declaration specifiers and declarator (even with initializer) In declaration specifiers, we can have:

• storage specifiers : typedef, extern, static, auto, register
• type specifiers : void, char, short, int, long, float, double, signed, unsigned, struct-or-union specifiers, enum specifier, typedef name
• type qualifiers : const, restrict, volatile
• function specifiers : inline

This part is for storage specifiers

&& (extern_p || explicit_extern_entity_p(module, e_last)

|| (extern_entity_p(module, e_last) && !type_functional_p(t_last))))

The global variables stored in static area and in ram but they are not static so a condition is needed, which checks if it is not a global variable

If a derived type is declared first, the qualifiers are carried by the type of the second entity

This part is for type specifiers, type qualifiers, function specifiers and declarator Three special cases for struct/union/enum definitions are treated here. Variable (scalar, array), pointer, function, variables of type struct/union/enum and typedef are treated by function c_words_entity

c = words_variable_or_function(module, e1, true, pc, in_type_declaration, pdl);

the word list pc must have been inserted in text r

Add the declared variables or more declared variables.

add the asm qualifier if needed

the final semi column,

the word list pc must be added to the last sentence of text r

Parameters

module	odule
del	el
margin	argin
sn	n
ppdl	pdl
cl	l

Definition at line 1815 of file declarations.c.

{
  /* If we are not in a compilation unit, the initialization control
   * list is useless and may be wrong because of program
   * transformations such as scalar renaming.
   */
  bool cu_p = entity_undefined_p(module)?
    false :
    compilation_unit_entity_p(module);
  list icl = ENDP(cl)? NIL : (cu_p? CDR(cl) : NIL);
  list el = filtered_declaration_list(del, &icl);
  text r = make_text(NIL);
  entity e1 = ENTITY(CAR(el)); // Let's use the first declared entity.
  const char* name1 = entity_user_name(e1);
  type t1 = entity_type(e1);
  entity e_last = ENTITY(CAR(gen_last(el))); // Let's also use the last declared entity.
  //type t_last = entity_type(e_last);
  //storage s1 = entity_storage(e1);
  storage s_last = entity_storage(e_last);
  //value val1 = entity_initial(e1);
  list pc = NIL;
  bool space_p = get_bool_property("PRETTYPRINT_LISTS_WITH_SPACES");
  bool skip_first_comma_p = true;
 
  bool place_holder_p = false;
  if(gen_length(el)==2) {
    /* The last entity may be a place holder */
    entity e2 = ENTITY(CAR(CDR(el)));
    if(place_holder_variable_p(e2)) {
      place_holder_p = true;
    }
  }
 
  /* overwrite the parser declaration list pdl with del */
  //pdl = del;
  // Not a good idea with recursive calls to this function
 
  pips_assert("the entity list is not empty", gen_length(el)>0);
 
  pips_debug(5,"Print declaration for first entity %s in module %s\n",
             entity_name(e1),
             entity_undefined_p(module)? "UNDEFINED" : entity_name(module));
 
  /* A declaration has two parts: declaration specifiers and declarator (even with initializer)
     In declaration specifiers, we can have:
     - storage specifiers : typedef, extern, static, auto, register
     - type specifiers : void, char, short, int, long, float, double, signed, unsigned,
                         struct-or-union specifiers, enum specifier, typedef name
     - type qualifiers : const, restrict, volatile
     - function specifiers : inline */
 
  /* This part is for storage specifiers */
  bool extern_p = false; // so as not to change the default behavior
  bool dummy_p = false;
  if(!ENDP(cl)) {
    expression first = EXPRESSION(CAR(cl));
    int ic = integer_constant_expression_value(first);
    extern_p = (ic==1 || ic==3)? true : false;
    //dummy_p = (ic==2 || ic==3)? true : false;
    // FI: the information about dummy_p is not reliable
    // several derived entities may be used or declared within one declaration
    // statement, but only one flag is stored by the parser...
    dummy_p = false;
  }
  if (!entity_undefined_p(module) && extern_p) {
      /* && (extern_p || explicit_extern_entity_p(module, e_last) */
      /*          || (extern_entity_p(module, e_last) && !type_functional_p(t_last)))) */
    pc = CHAIN_SWORD(pc,"extern ");
  }
 
  if (strstr(entity_name(e_last),TYPEDEF_PREFIX) != NULL) {
    pc = CHAIN_SWORD(pc,"typedef ");
    // FI: too early for typedef17.c
    //*ppdl = CONS(ENTITY, e_last, *ppdl);
    //if(same_string_p(entity_user_name(e_last), "__gconv_t")) {
    //  fprintf(stderr, "Entity \"%s\" found.\n", entity_user_name(e_last));
    //}
  }
 
  /* The global variables stored in static area and in ram but they
     are not static so a condition is needed, which checks if it is not a
     global variable*/
  // entity m = get_current_module_entity();
  if ((storage_ram_p(s_last)
       && static_area_p(ram_section(storage_ram(s_last)))
       && !strstr(entity_name(e_last),TOP_LEVEL_MODULE_NAME))
      || (entity_module_p(e_last) && static_module_p(e_last)))
    pc = CHAIN_SWORD(pc,"static ");
 
  /* If a derived type is declared first, the qualifiers are carried
   * by the type of the second entity
   */
  if(derived_entity_p(e1) && gen_length(el)>1) {
    entity e2 = ENTITY(CAR(CDR(el)));
    type t2 = entity_type(e2);
    if(type_variable_p(t2)) {
      variable v2 = type_variable(t2);
      list ql2 = variable_qualifiers(v2);
      pc = gen_nconc(pc, words_qualifiers(ql2));
    }
  }
 
 
  /* This part is for type specifiers, type qualifiers, function specifiers and declarator
     Three special cases for struct/union/enum definitions are treated here.
     Variable (scalar, array), pointer, function, variables of type struct/union/enum and typedef
     are treated by function c_words_entity */
 
  bool in_type_declaration = true;
  switch (type_tag(t1)) {
  case is_type_struct:
    {
      list l = type_struct(t1);
      const char * lname = entity_local_name(e1);
      bool init_p = strstr(lname, STRUCT_PREFIX DUMMY_STRUCT_PREFIX ) != NULL;
      if(!init_p)
        init_p = !dummy_p && !ENDP(l) && !gen_in_list_p(e1, *ppdl)
          && declarable_type_p(t1, *ppdl) && !place_holder_p;
      pc = words_struct_reference(name1, pc, init_p);
      ADD_SENTENCE_TO_TEXT(r, make_sentence(is_sentence_unformatted,
                                            make_unformatted(NULL,sn,margin,pc)));
      if(init_p) {
        *ppdl = gen_once(e1, *ppdl);
        text fields = c_text_entities(module, l, margin+INDENTATION, ppdl);
        pc = CHAIN_SWORD(NIL, "{");
        add_words_to_text(r, pc);
        MERGE_TEXTS(r, fields);
        ADD_SENTENCE_TO_TEXT(r, MAKE_ONE_WORD_SENTENCE(margin, "}"));
      }
      break;
    }
  case is_type_union:
    {
      list l = type_union(t1);
      const char * lname = entity_local_name(e1);
      bool init_p = strstr(lname, UNION_PREFIX DUMMY_UNION_PREFIX ) != NULL;
      if(!init_p)
        init_p = !dummy_p && !ENDP(l) && !gen_in_list_p(e1, *ppdl)
          && declarable_type_p(t1, *ppdl) && !place_holder_p;
      pc = words_union(name1, pc, init_p);
      ADD_SENTENCE_TO_TEXT(r, make_sentence(is_sentence_unformatted,
                                            make_unformatted(NULL,sn,margin,pc)));
      if(init_p) {
        *ppdl = gen_once(e1, *ppdl);
        text fields = c_text_entities(module,l,margin+INDENTATION, ppdl);
        pc = CHAIN_SWORD(NIL, "{");
        add_words_to_text(r, pc);
        MERGE_TEXTS(r,fields);
        ADD_SENTENCE_TO_TEXT(r, MAKE_ONE_WORD_SENTENCE(margin,"}"));
      }
      break;
    }
  case is_type_enum:
    {
      list l = type_enum(t1);
      const char * lname = entity_local_name(e1);
      bool init_p = strstr( lname, ENUM_PREFIX DUMMY_ENUM_PREFIX ) != NULL;
      if(!init_p)
        init_p = !dummy_p && !ENDP(l) && !gen_in_list_p(e1, *ppdl)
          && declarable_type_p(t1, *ppdl) && !place_holder_p;
      if(init_p) {
        *ppdl = gen_once((void *) e1, *ppdl);
        pc = words_enum(name1, l, space_p, pc, ppdl);
        ADD_SENTENCE_TO_TEXT(r, make_sentence(is_sentence_unformatted,
                                              make_unformatted(NULL,sn,margin,pc)));
      }
      else {
        pc = words_enum_reference(name1, pc, init_p);
        ADD_SENTENCE_TO_TEXT(r, make_sentence(is_sentence_unformatted,
                                              make_unformatted(NULL,sn,margin,pc)));
      }
      break;
    }
  case is_type_variable:
  case is_type_functional:
  case is_type_void:
  case is_type_unknown:
    {
      /*pc = words_variable_or_function(module, e1, true, pc,
        in_type_declaration, pdl);*/
      in_type_declaration=false;
 
      bool init_p = extern_p? false : true;
      if(!ENDP(icl)) {
        expression ice = EXPRESSION(CAR(icl)); // Initialization control expression
        int ic = integer_constant_expression_value(ice);
        init_p = ic==1? true : false;
      }
 
      pc = words_variable_or_function(module, e1, true, pc,
                                      in_type_declaration, ppdl, init_p);
      ADD_SENTENCE_TO_TEXT(r, make_sentence(is_sentence_unformatted,
                                            make_unformatted(NULL,sn,margin,pc)));
      skip_first_comma_p = false;
      break;
    }
  case is_type_varargs:
  case is_type_statement:
  case is_type_area:
  default:
    pips_internal_error("unexpected type tag");
  }
 
  /* the word list pc must have been inserted in text r*/
  pc = NIL;
 
 
 
  /* Add the declared variables or more declared variables. */
  list oel = list_undefined; // other entities after e1
  if(place_holder_p)
    oel = CDR(CDR(el)); // skip the place holder variable
  else
    oel = CDR(el);
  //print_entities(oel);
  list oicl = ENDP(icl) ? NIL : CDR(icl);
  FOREACH(ENTITY, e, oel) {
    if(skip_first_comma_p) {
      skip_first_comma_p = false;
      pc = gen_nconc(pc,CHAIN_SWORD(NIL, " "));
    }
    else
      pc = gen_nconc(pc,CHAIN_SWORD(NIL,space_p? ", " : ","));
    bool init_p = true;
    if(!ENDP(oicl)) {
      expression ice = EXPRESSION(CAR(oicl)); // Initialization control expression
      int ic = integer_constant_expression_value(ice);
      init_p = ic==1? true : false;
      POP(oicl);
    }
    pc = words_variable_or_function(module, e, false, pc, in_type_declaration,
                                    ppdl, init_p);
  }
  /* add the asm qualifier if needed */
  string asm_qual = strdup("");
  FOREACH(QUALIFIER, q, entity_qualifiers(e1)) {
    if(qualifier_asm_p(q)) {
            asprintf(&asm_qual,"%s __asm(%s)", asm_qual, qualifier_asm(q));
    }
  }
  pc = CHAIN_SWORD(pc,asm_qual);
  free(asm_qual);
  /* the final semi column,*/
  pc = CHAIN_SWORD(pc,";");
 
  /* the word list pc must be added to the last sentence of text r */
  if(ENDP(text_sentences(r))) {
    pips_internal_error("Unexpected empty text");
  }
  else {
    add_words_to_text(r, pc);
  }
 
  if (strstr(entity_name(e_last),TYPEDEF_PREFIX) != NULL) {
    *ppdl = CONS(ENTITY, e_last, *ppdl);
  }
 
  return r;
}

References ADD_SENTENCE_TO_TEXT, add_words_to_text(), asprintf, c_text_entities(), CAR, CDR, CHAIN_SWORD, compilation_unit_entity_p(), CONS, declarable_type_p(), derived_entity_p(), DUMMY_ENUM_PREFIX, DUMMY_STRUCT_PREFIX, DUMMY_UNION_PREFIX, ENDP, ENTITY, entity_local_name(), entity_module_p(), entity_name, entity_qualifiers(), entity_storage, entity_type, entity_undefined_p, entity_user_name(), ENUM_PREFIX, EXPRESSION, false, filtered_declaration_list(), FOREACH, free(), gen_in_list_p(), gen_last(), gen_length(), gen_nconc(), gen_once(), get_bool_property(), INDENTATION, integer_constant_expression_value(), is_sentence_unformatted, is_type_area, is_type_enum, is_type_functional, is_type_statement, is_type_struct, is_type_union, is_type_unknown, is_type_varargs, is_type_variable, is_type_void, list_undefined, lname(), MAKE_ONE_WORD_SENTENCE, make_sentence(), make_text(), make_unformatted(), MERGE_TEXTS, module, NIL, pips_assert, pips_debug, pips_internal_error, place_holder_variable_p(), POP, QUALIFIER, qualifier_asm, qualifier_asm_p, ram_section, static_area_p(), static_module_p(), storage_ram, storage_ram_p, strdup(), STRUCT_PREFIX, text_sentences, TOP_LEVEL_MODULE_NAME, true, type_enum, type_struct, type_tag, type_union, type_variable, type_variable_p, TYPEDEF_PREFIX, UNION_PREFIX, variable_qualifiers, words_enum(), words_enum_reference(), words_qualifiers(), words_struct_reference(), words_union(), and words_variable_or_function().

Referenced by c_text_entity().

Here is the call graph for this function:

Here is the caller graph for this function:

c_words_entity()

list c_words_entity	(	type	t,
		list	name,
		list *	ppdl
	)

Parameters

name	ame
ppdl	pdl

Definition at line 1421 of file declarations.c.

{
  list pc = generic_c_words_entity(t, name, false, false, ppdl);
 
  ifdebug(8) {
    string s = list_to_string(pc);
    pips_debug(8, "End with \"\%s\"\n", s);
  }
 
  return pc;
}

References generic_c_words_entity(), ifdebug, list_to_string(), and pips_debug.

Referenced by ensure_comment_consistency(), generic_c_words_simplified_entity(), UpdatePointerEntity(), words_basic(), and words_parameters().

Here is the call graph for this function:

Here is the caller graph for this function:

c_words_simplified_entity()

list c_words_simplified_entity	(	type	t,
		list	name,
		bool	is_first,
		bool	in_type_declaration,
		list *	ppdl
	)

The declaration list pointer ppdl is passed down to determine if an internal derived type must be fully expanded within another declaration or not.

If it is declared by itself, there is no need to expand its declaration again.

Parameters

name	ame
is_first	s_first
in_type_declaration	n_type_declaration
ppdl	pdl

Definition at line 1408 of file declarations.c.

{
  list pc = generic_c_words_simplified_entity(t, name, false, false, is_first,
                                              in_type_declaration, false, ppdl);
 
  ifdebug(8) {
    string s = list_to_string(pc);
    pips_debug(8, "End with \"\%s\"\n", s);
  }
 
  return pc;
}

References generic_c_words_simplified_entity(), ifdebug, list_to_string(), and pips_debug.

Referenced by ensure_comment_consistency(), and words_variable_or_function().

Here is the call graph for this function:

Here is the caller graph for this function:

check_common_inclusion()

bool check_common_inclusion

(

entity

common

)

area.c

area.c

of entity

empty common!

take the first function as the reference for the check.

SAME name, type, offset

Parameters

common

ommon

Definition at line 107 of file area.c.

{
  bool ok = true;
  list /* of entity */ lv, lref;
  entity ref;
  pips_assert("entity is a common", entity_area_p(common));
  lv = area_layout(type_area(entity_type(common)));
 
  if (!lv) return true; /* empty common! */
 
  /* take the first function as the reference for the check. */
  ref = ram_function(storage_ram(entity_storage(ENTITY(CAR(lv)))));
  lref = common_members_of_module(common, ref, false);
 
  /* SAME name, type, offset */
  while (lv && ok)
    {
      entity v = ENTITY(CAR(lv));
      if (ram_function(storage_ram(entity_storage(v)))!=ref)
        ok = comparable_entity_in_list_p(common, v, lref);
      POP(lv);
    }
 
  gen_free_list(lref);
  return ok;
}

References area_layout, CAR, common_members_of_module(), comparable_entity_in_list_p(), ENTITY, entity_area_p(), entity_storage, entity_type, gen_free_list(), ok, pips_assert, POP, ram_function, ref, storage_ram, and type_area.

Referenced by text_area_included().

Here is the call graph for this function:

Here is the caller graph for this function:

close_extension()

string close_extension

(

extension

e

)

extension.c

Returns

a new allocated string to close the extension.

Parameters

es,the

extension to be closed

Today we only generate omp parallel do pragma so the close is pretty easy. Later we will have to analyze the extension to generate the close string accordingly.

Definition at line 49 of file extension.c.

                                     {
  return close_pragma (extension_pragma(e));
}

References close_pragma(), and extension_pragma.

Referenced by close_extensions().

Here is the call graph for this function:

Here is the caller graph for this function:

close_extensions()

string close_extensions	(	extensions	es,
		bool	nl
	)

Returns

a new allocated string to close the extensions.

Parameters

es,the	extensions to be closed
nl,set	to true to get the string with a final new line character

Use a string_buffer for efficient string concatenation:

Free the buffer with its strings:

Parameters

es	s
nl	l

Definition at line 58 of file extension.c.

                                          {
  string s = string_undefined;
 
  if (!empty_extensions_p (es) ) {
    /* Use a string_buffer for efficient string concatenation: */
    string_buffer sb = string_buffer_make(false);
 
    list el = extensions_extension(es);
    FOREACH(EXTENSION, e, el) {
      s = close_extension(e);
      if (s != string_undefined) {
        string_buffer_append(sb, s);
        if (nl ) string_buffer_append(sb, strdup ("\n"));
        nl = true;
      }
    }
    s = string_buffer_to_string(sb);
    /* Free the buffer with its strings: */
    string_buffer_free_all(&sb);
  }
 
  return s;
}

References close_extension(), empty_extensions_p(), EXTENSION, extensions_extension, FOREACH, strdup(), string_buffer_append(), string_buffer_free_all(), string_buffer_make(), string_buffer_to_string(), and string_undefined.

Here is the call graph for this function:

close_pragma()

string close_pragma

(

pragma

)

pragma.c

close_prettyprint()

void close_prettyprint

(

void

)

because some prettyprint functions may be used for debug, so the last hook set by somebody may have stayed there although being non sense...

Definition at line 242 of file misc.c.

                         {
  text_statement_hook = empty_text;
}

References empty_text(), and text_statement_hook.

Referenced by generic_print_code_pv(), get_any_comp_regions_text(), get_continuation_condition_text(), get_semantic_text(), print_code_or_source_comp(), print_code_points_to(), print_code_static_control(), print_parallelized_code_common(), print_parallelizedCMF_code(), print_parallelizedCRAFT_code(), store_new_module(), text_code_points_to(), text_code_reductions(), and wp65().

Here is the call graph for this function:

Here is the caller graph for this function:

contrainte_text_format()

string contrainte_text_format	(	string	aux_line,
		string	continuation,
		text	txt,
		Pcontrainte	c,
		bool	is_inegalite,
		string(*)(Variable)	variable_name,
		bool	a_la_fortran,
		bool	first_line
	)

Parameters

aux_line	ux_line
continuation	ontinuation
txt	xt
is_inegalite	s_inegalite
a_la_fortran	_la_fortran
first_line	irst_line

Definition at line 285 of file constraint_to_text.c.

{
  Pvecteur v;
  int heuristique = 2;
 
  if (!CONTRAINTE_UNDEFINED_P(c))
    v = contrainte_vecteur(c);
  else
    v = VECTEUR_NUL;
 
  pips_assert("vector v is okay", vect_check(v));
 
  switch(heuristique) {
  case 1: aux_line = contrainte_to_text_1(aux_line,continuation,txt,
                                          v,is_inegalite, variable_name,
                                          a_la_fortran, first_line);
    break;
  case 2:aux_line = contrainte_to_text_2(aux_line,continuation,txt,v,
                                         is_inegalite, variable_name,
                                         a_la_fortran, first_line);
    break;
  default: contrainte_error("contrainte_sprint", "unknown heuristics\n");
  }
 
  return aux_line;
}

References continuation, contrainte_error(), contrainte_to_text_1(), contrainte_to_text_2(), CONTRAINTE_UNDEFINED_P, contrainte_vecteur, pips_assert, variable_name(), vect_check(), and VECTEUR_NUL.

Referenced by contraintes_text_format(), egalite_text_format(), and inegalite_text_format().

Here is the call graph for this function:

Here is the caller graph for this function:

dprint()

void dprint

(

expression

x

)

For debugging: prettyprint many different kinds of newgen objects FC: type should be gen_chunk...

Definition at line 392 of file print.c.

{
  debug_on("PRETTYPRINT_DEBUG_LEVEL");
  if(expression_undefined_p(x))
    (void) fprintf(stderr, "UNDEFINED NEWGEN OBJECT\n");
  else if(x==0)
    (void) fprintf(stderr, "EMPTY LIST\n");
  else {
    int ot = expression_domain_number(x);
    if(ot==0)
      (void) fprintf(stderr,"PROBABLY AN EMPTY LIST\n");
    else if(expression_undefined_p(x))
      (void) fprintf(stderr,"UNDEFINED NEWGEN OBJECT\n");
    else if(ot==expression_domain)
      print_expression( x);
    else if(ot==reference_domain)
      print_reference((reference) x);
    else if(ot==points_to_domain)
      print_points_to((points_to) x); // See also print_points_to_relation
    else if(ot==cell_domain) {
      print_points_to_cell((cell) x);
      fprintf(stderr, "\n");
    }
    else if(ot==type_domain)
      print_type((type) x);
    else if(ot==statement_domain)
      print_statement((statement) x);
    else if(ot==effect_domain) {
      descriptor d = effect_descriptor((effect) x);
      if(descriptor_none_p(d))
        print_effect((effect) x);
      else
        print_region((effect) x);
    }
    else if(ot==points_to_list_domain)
      print_points_to_list((points_to_list) x);
    else if(ot==points_to_graph_domain)
      print_points_to_graph((points_to_graph) x);
    else if(ot==text_domain)
      print_text(stderr, (text) x);
    else if(ot==entity_domain) {
      entity m = get_current_module_entity();
      entity mx = module_name_to_entity(entity_module_name((entity)x));
      if(entity_undefined_p(mx))
        fprintf(stderr, "%s\n", entity_name((entity) x));
      else {
        if(m!=mx)
          fprintf(stderr,"%s" MODULE_SEP_STRING, entity_local_name(mx));
        fprintf(stderr, "%s\n", entity_local_name((entity) x));
      }
    }
    else if(ot==basic_domain) {
      string s = basic_to_string((basic) x);
      fprintf(stderr, "%s\n", s);
      free(s);
    }
    else if(ot==transformer_domain) {
      transformer t = (transformer)x;
      if(transformer_with_temporary_values_p(t))
        dump_transformer(t);
      else {
        // FI: print_transformer() core dumps in interprocedural
        // settings and dump_transformer() is as good for debugging ig
        // not better
        dump_transformer(t);
      }
    }
    else if(ot==effects_domain) {
      list el = effects_effects((effects) x);
      dprint((expression) el);
    }
    else if(ot==dimension_domain) {
      dimension d = (dimension) x;
      expression l = dimension_lower(d);
      expression u = dimension_upper(d);
      // list ql = dimension_qualifiers(d);
      // FI: lets forget abut qualifiers
      print_expression(l);
      print_expression(u);
    }
    else if(ot==qualifier_domain) {
      qualifier q = (qualifier) x;
      print_qualifier(q);
    }
    else if(0<=ot && ot<1000)
      (void) fprintf(stderr, "Unprocessed Newgen Object with tag %d\n", ot);
    else if(ot>1000 || ot<=0) {
      // FI: I do not know how to get the largest Newgen type
      // We could assume that the object is a list and look for the type
      // of the first object...
      (void) fprintf(stderr,"NOT A NEWGEN OBJECT. MAYBE A LIST\n");
      expression cx = EXPRESSION(CAR((list) x));
      int cot = expression_domain_number(cx);
      if(cot==expression_domain)
        print_expressions((list) x);
      else if(cot==reference_domain)
        print_references((list) x);
      else if(cot==cell_domain)
        print_points_to_cells((list) x);
      else if(cot==type_domain)
        print_types((list) x);
      else if(cot==statement_domain)
        print_statements((list) x);
      else if(cot==effect_domain)
        print_effects((list) x);
      else if(cot==points_to_domain)
        print_points_to_relations((list) x);
      else if(cot==transformer_domain) {
        list tl = (list) x;
        FOREACH(TRANSFORMER, t, tl) {
          if(transformer_with_temporary_values_p(t))
            dump_transformer(t);
          else
            dump_transformer(t);
        }
      }
      else if(cot==entity_domain) {
        // print_entities((list) x);
        list el = (list) x;
      entity m = get_current_module_entity();
        FOREACH(ENTITY, e, el) {
          entity me = module_name_to_entity(entity_module_name(e));
          if(m!=me)
            fprintf(stderr,"%s" MODULE_SEP_STRING, entity_local_name(me));
          fprintf(stderr, "%s\n", entity_local_name(e));
        }
      }
      else if(cot==dimension_domain) {
        list dl = (list) x;
        FOREACH(DIMENSION, d, dl) {
          expression l = dimension_lower(d);
          expression u = dimension_upper(d);
          // list ql = dimension_qualifiers(d);
          // FI: lets forget abut qualifiers
          print_expression(l);
          print_expression(u);
        }
      }
      else if(cot==qualifier_domain) {
        list ql = (list) x;
        print_qualifiers(ql);
      }
      else
        (void) fprintf(stderr, "If a list, a list of unknown objects: tag=%d\n", (int) cot);
    }
  }
  debug_off();
}

References basic_domain, basic_to_string(), CAR, cell_domain, debug_off, debug_on, descriptor_none_p, DIMENSION, dimension_domain, dimension_lower, dimension_upper, dprint(), dump_transformer, effect_descriptor, effect_domain, effects_domain, effects_effects, ENTITY, entity_domain, entity_local_name(), entity_module_name(), entity_name, entity_undefined_p, EXPRESSION, expression_domain, expression_domain_number, expression_undefined_p, FOREACH, fprintf(), free(), get_current_module_entity(), module_name_to_entity(), MODULE_SEP_STRING, points_to_domain, points_to_graph_domain, points_to_list_domain, print_effect, print_effects, print_expression(), print_expressions(), print_points_to, print_points_to_cell, print_points_to_cells, print_points_to_graph, print_points_to_list, print_points_to_relations, print_qualifier(), print_qualifiers(), print_reference(), print_references(), print_region, print_statement(), print_statements(), print_text(), print_type(), print_types(), qualifier_domain, reference_domain, statement_domain, text_domain, TRANSFORMER, transformer_domain, transformer_with_temporary_values_p, type_domain, and x.

Referenced by dprint().

Here is the call graph for this function:

Here is the caller graph for this function:

dump_common_layout()

void dump_common_layout	(	string_buffer	result,
		entity	c,
		bool	debug_p,
		bool	isfortran
	)

symbol_table.c

symbol_table.c

FI: a weaker test to stay independent from the syntax library and its internal static variables.

This piece of code can be used in a pass or as debugging code for library syntax.

Parameters

result	esult
debug_p	ebug_p
isfortran	sfortran

Definition at line 120 of file symbol_table.c.

{
  entity mod = get_current_module_entity();
  list members = get_common_members(c, mod, false);
  list equiv_members = NIL;
 
  string_buffer_append(result,
                       concatenate(NL,"Layout for ",
                                   isfortran?"common /":"memory area \"",
                                   entity_name(c),isfortran?"/":"\""," of size ",
                                   i2a(area_size(type_area(entity_type(c)))),
                                   ":",NL,NULL));
 
 
  if(ENDP(members)) {
    pips_assert("An empty area has size 0",
                area_size(type_area(entity_type(c))) ==0);
    string_buffer_append(result, concatenate("\t* empty area *",NL,NL,NULL));
  }
  else {
    // Different preconditions for C and fortran
 
    if(isfortran){
      if(area_size(type_area(entity_type(c)))==0
         /* FI: a weaker test to stay independent from the syntax
          * library and its internal static variables.
          *
          * This piece of code can be used in a pass or as debugging
          * code for library syntax.
          */
         //              && fortran_relevant_area_entity_p(c))
         && !heap_area_p(c) && !stack_area_p(c))
        {
          if(debug_p) {
            user_warning("dump_common_layout",
                         "Non-empty area %s should have a final size greater than 0\n",
                         entity_module_name(c));
          }
          else {
            pips_internal_error("Non-empty area %s should have a size greater than 0",
                                entity_module_name(c));
          }
        }
    }
    else {
      if(area_size(type_area(entity_type(c))) == 0)
        {
          if(debug_p) {
            user_warning("dump_common_layout",
                         "Non-empty area %s should have a final size greater than 0\n",
                         entity_module_name(c));
          }
        }
    }
 
    if(isfortran){
      FOREACH(ENTITY, m, members) {
        pips_assert("RAM storage",
                    storage_ram_p(entity_storage(m)));
        if(ram_function(storage_ram(entity_storage(m)))==mod) {
          int s;
 
          if(ram_section(storage_ram(entity_storage(m)))!=c) {
            pips_internal_error("Variable %s declared in area %s but allocated in area %s",
                                entity_local_name(m), entity_module_name(c),
                                entity_module_name(ram_section(storage_ram(entity_storage(m)))));
          }
 
          if(!SizeOfArray(m, &s)) {
            if(ram_section(storage_ram(entity_storage(m)))==HeapArea
               || ram_section(storage_ram(entity_storage(m)))==StackArea) {
              s = -1;
            }
            else {
              user_warning("print_common_layout",
                           "Varying size of array \"%s\"\n", entity_name(m));
              pips_internal_error("Fortran standard prohibit varying size array\n");
            }
          }
 
          string_buffer_append(result,
                               concatenate
                               ("\tVariable ",entity_name(m),"\toffset = ",
                                i2a(ram_offset(storage_ram(entity_storage(m)))),NULL));
          string_buffer_append(result,
                               concatenate("\tsize = ",i2a(s),NL,NULL));
        }
      }
    }
    else { // C language
      FOREACH(ENTITY, m, members) {
        if(!place_holder_variable_p(m)) {
          pips_assert("RAM storage",
                      storage_ram_p(entity_storage(m)));
          int s;
 
          SizeOfArray(m, &s);
 
          pips_assert("An area has no offset as -1",
                      (ram_offset(storage_ram(entity_storage(m)))!= -1));
 
          if(ram_offset(storage_ram(entity_storage(m))) == DYNAMIC_RAM_OFFSET) {
            string_buffer_append(result,
                                 concatenate(
                                             "\tDynamic Variable \"",entity_name(m),
                                             "\"\toffset = UNKNOWN, \tsize = DYNAMIC",
                                             NL,NULL));
          }
          else if (ram_offset(storage_ram(entity_storage(m))) == UNDEFINED_RAM_OFFSET) {
            string_buffer_append(result,
                                 concatenate
                                 ("\tExternal Variable \"", entity_name(m),
                                  "\"\toffset = UNKNOWN,\tsize = ",
                                  s>0?i2a(s): "unknown", NL, NULL));
          }
          else {
            string_buffer_append(result,
                                 concatenate
                                 ("\tVariable \"", entity_name(m),"\"\toffset = ",
                                  i2a(ram_offset(storage_ram(entity_storage(m)))),NULL));
            if (get_bool_property("EXTENDED_VARIABLE_INFORMATION")) {
              pips_debug(3, "extended information required\n");
              type t = entity_type (m);
              if (type_variable_p(t)) {
                variable v = type_variable(t);
                basic b = variable_basic(v);
                string_buffer_append(result,
                                     concatenate("\ttype = \"",
                                                 basic_to_string(b), "\"",
                                                 "\tuser name = \"",
                                                 entity_user_name (m), "\"",
                                                 NULL));
                // check if the basic is derived or typedef to be investigated
                string deeper = check_derived_and_typedef (b, 2, entity_user_name (m));
                if (strcmp (deeper, "") != 0) {
                  string_buffer_append (result, NL);
                  string_buffer_append (result, deeper);
                }
                else free (deeper);
              }
            }
            string_buffer_append(result,
                                 concatenate("\tsize = ",i2a(s),NL,NULL));
          }
        }
      }
    }
 
    string_buffer_append(result, NL);
 
    FOREACH(ENTITY, m, members) {
      list equiv = ram_shared(storage_ram(entity_storage(m)));
 
      equiv_members = arguments_union(equiv_members, equiv);
    }
 
    if(!ENDP(equiv_members)){
      equiv_members = arguments_difference(equiv_members, members);
      if(!ENDP(equiv_members)) {
        sort_list_of_entities(equiv_members);
 
        string_buffer_append(result, concatenate("\tVariables aliased to this common:",NL,
                                                 NULL));
 
        FOREACH(ENTITY, m, equiv_members) {
          pips_assert("RAM storage",
                      storage_ram_p(entity_storage(m)));
          string_buffer_append(result,
                               concatenate
                               ("\tVariable", entity_name(m) ,"\toffset =",
                                ram_offset(storage_ram(entity_storage(m))),"\tsize = ",
                                array_size(m),NL,NULL));
        }
        string_buffer_append(result, concatenate(NL,NULL));
        gen_free_list(equiv_members);
      }
    }
  }
  gen_free_list(members);
}

References area_size, arguments_difference(), arguments_union(), array_size(), basic_to_string(), check_derived_and_typedef(), concatenate(), DYNAMIC_RAM_OFFSET, ENDP, ENTITY, entity_local_name(), entity_module_name(), entity_name, entity_storage, entity_type, entity_user_name(), FOREACH, free(), gen_free_list(), get_bool_property(), get_common_members(), get_current_module_entity(), heap_area_p(), HeapArea, i2a(), NIL, NL, pips_assert, pips_debug, pips_internal_error, place_holder_variable_p(), ram_function, ram_offset, ram_section, ram_shared, SizeOfArray(), sort_list_of_entities(), stack_area_p(), StackArea, storage_ram, storage_ram_p, string_buffer_append(), type_area, type_variable, type_variable_p, UNDEFINED_RAM_OFFSET, user_warning, and variable_basic.

Referenced by get_symbol_table().

Here is the call graph for this function:

Here is the caller graph for this function:

dump_control_to_label_name()

void dump_control_to_label_name

(

hash_table

h

)

Definition at line 500 of file unstructured.c.

{
    int i = 0;
 
    fprintf(stderr,"[dump_control_to_label_name] Begin\n");
    HASH_MAP(c,l,{
        fprintf(stderr, "Label %s -> %s", (char *) l,
                (char *) statement_identification(control_statement((control) c)));
        i++;
    }, h);
    fprintf(stderr,"[dump_control_to_label_name] %d labels, end\n", i);
}

References control_statement, fprintf(), HASH_MAP, and statement_identification().

Referenced by text_unstructured().

Here is the call graph for this function:

Here is the caller graph for this function:

dump_trail()

void dump_trail

(

list

trail

)

Parameters

trail

rail

Definition at line 263 of file unstructured.c.

{
    if(ENDP(trail)) {
        fprintf(stderr, "[dump_trail] trail is empty\n");
    }
    else {
        fprintf(stderr, "[dump_trail] begin\n");
        MAPL(cc, {
            statement s = control_statement(CONTROL(CAR(cc)));
            fprintf(stderr, "[dump_trail] %s", statement_identification(s));
        }, trail);
        fprintf(stderr, "[dump_trail] end\n");
    }
}

References CAR, CONTROL, control_statement, ENDP, fprintf(), MAPL, and statement_identification().

Referenced by c_unstructured(), and text_unstructured().

Here is the call graph for this function:

Here is the caller graph for this function:

egalite_debug()

void egalite_debug

(

Pcontrainte

c

)

Definition at line 58 of file constraint_to_text.c.

{
  egalite_fprint(stderr, c, (get_variable_name_t) entity_local_name);
}

References egalite_fprint(), and entity_local_name().

Referenced by sc_projection_optim_along_vecteur_ofl().

Here is the call graph for this function:

Here is the caller graph for this function:

egalite_text_format()

string egalite_text_format	(	string	aux_line,
		string	continuation,
		text	txt,
		Pcontrainte	eg,
		string(*)(Variable)	variable_name,
		bool	a_la_fortran,
		bool	first_line
	)

Parameters

aux_line	ux_line
continuation	ontinuation
txt	xt
eg	g
a_la_fortran	_la_fortran
first_line	irst_line

Definition at line 321 of file constraint_to_text.c.

{
  return contrainte_text_format(aux_line,continuation,txt,eg, false,
                                variable_name,a_la_fortran,first_line);
}

References continuation, contrainte_text_format(), and variable_name().

Here is the call graph for this function:

empty_text()

text empty_text	(	entity	,
		int	,
		statement
	)

entity_list_text_format()

void entity_list_text_format	(	string	,
		string	,
		text	,
		list	,
		const char *	*)(entity
	)

eole_fma_specific_op()

list eole_fma_specific_op	(	call	obj,
		int	precedence,
		bool	leftmost,
		list *	ppdl
	)

EOLE : The multiply-add operator is used within the optimize transformation ( JZ - sept 98) - fma(a,b,c) -> ((a*b)+c)

of string

Parameters

obj	bj
precedence	recedence
leftmost	eftmost
ppdl	pdl

Definition at line 2049 of file misc.c.

{
  return eole_fmx_specific_op(obj, precedence, leftmost, true, ppdl);
}

References eole_fmx_specific_op().

Here is the call graph for this function:

eole_fms_specific_op()

list eole_fms_specific_op	(	call	obj,
		int	precedence,
		bool	leftmost,
		list *	ppdl
	)

MULTIPLY-SUB operator.

of string

Parameters

obj	bj
precedence	recedence
leftmost	eftmost
ppdl	pdl

Definition at line 2056 of file misc.c.

{
  return eole_fmx_specific_op(obj, precedence, leftmost, false, ppdl);
}

References eole_fmx_specific_op().

Here is the call graph for this function:

expand_expression()

expression expand_expression	(	expression	,
		entity	,
		range
	)

expand_reference()

expression expand_reference	(	syntax	s,
		expression	e,
		entity	i,
		range	r
	)

A reference cannot always be expanded.

Subscript expression coupling as in A(I,I) prevent expansion and an undefined expression is returned. Non-affine expressions such as A(I**2) cannot be transformed into triplets but can be tranformed into implicit DO vectors.

Arguments s, e, i and r should not be shared with the returned expression.

expand occurence of loop index

expand 1 subscript expression or fail or leave unexpanded

If dim is greater than 1, subscript expressions are coupled as in A(I,I+1).

new_args should be freed

Just the spine or more?

Definition at line 225 of file fortran90.c.

{
    reference rf = syntax_reference(s) ;
    expression new_e = expression_undefined;
 
    if( same_entity_p( reference_variable( rf ), i )) {
        /* expand occurence of loop index */
        syntax new_s = make_syntax(is_syntax_range,copy_range(r)) ;
        new_e = make_expression(new_s, normalized_undefined) ;
        set_add_element( vectors, vectors, (char *) new_e ) ;
    }
    else {
        /* expand 1 subscript expression or fail or leave unexpanded */
        int dim = 0 ;
        cons *new_args = NIL ;
        reference new_r ;
 
        MAPL( args, {
            expression arg = EXPRESSION( CAR( args )) ;
 
            new_e = expand_expression( arg, i, r ) ;
 
            if(expression_undefined_p(new_e))
                return new_e;
 
            if(set_belong_p( vectors, (char *)new_e ))
                dim++;
 
            new_args = CONS(EXPRESSION, new_e, new_args ) ;
        }, reference_indices( rf )) ;
 
        if( dim==1 ) {
            new_r = make_reference(reference_variable(rf),
                                   gen_nreverse(new_args)) ;
            new_e = make_expression(make_syntax(is_syntax_reference,new_r),
                                    normalized_undefined) ;
            set_add_element( vectors, vectors, (char *)new_e ) ;
        }
        else if(dim > 1) {
            /* If dim is greater than 1, subscript expressions are coupled
             * as in A(I,I+1).
             */
            /* new_args should be freed */
            new_e = expression_undefined;
        }
        else {
            /* Just the spine or more? */
            gen_free_list(new_args);
            new_e = copy_expression(e);
        }
    }
    return new_e;
}

References CAR, CONS, copy_expression(), copy_range(), expand_expression(), EXPRESSION, expression_undefined, expression_undefined_p, gen_free_list(), gen_nreverse(), is_syntax_range, is_syntax_reference, make_expression(), make_reference(), make_syntax(), MAPL, NIL, normalized_undefined, reference_indices, reference_variable, same_entity_p(), set_add_element(), set_belong_p(), syntax_reference, and vectors.

Referenced by expand_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_to_string()

string expression_to_string

(

expression

e

)

Definition at line 77 of file expression.c.

                                          {
  list pdl = NIL;
  list l = words_expression(e, &pdl) ;
  string out = words_to_string(l);
  FOREACH(STRING,w,l) free(w);
  gen_free_list(l);
  gen_free_list(pdl);
  return out;
}

References FOREACH, free(), gen_free_list(), NIL, out, STRING, words_expression(), and words_to_string().

Referenced by adg_get_conjonctions(), any_assign_operation_to_transformer(), any_basic_update_to_transformer(), any_expression_to_transformer(), any_scalar_assign_to_transformer_list(), any_scalar_assign_to_transformer_without_effect(), any_update_to_transformer(), atomize_or_associate_for_level(), atomizer_of_array_indices(), atomizer_of_expression(), atomizer_of_intrinsic(), build_third_comb(), c_brace_expression_string(), c_convex_effects_on_formal_parameter_backward_translation(), c_dim_string(), cell_reference_compare(), comp_regions_of_instruction(), consecutive_expression_p(), constraint_to_bound(), copy_n_reference(), do_atomize_if_different_level(), edge_cost_polynome(), equal_condition_to_points_to(), equal_must_vreference(), expression_to_post_pv(), expressions_to_predicate(), fprint_bdt(), fprint_bdt_with_stat(), fprint_plc(), freed_pointer_to_points_to(), freia_is_transpose_call(), get_bounds_expression(), have_null_value_in_pointer_expression_p(), have_sizeof_value_in_multiply_pointer_expression_p(), imprime_quast(), internal_pointer_assignment_to_points_to(), interprocedural_abc_arrays(), intrinsic_call_to_points_to(), is_param_dynamic(), loop_annotate(), make_available_scalar(), make_bottom_up_abc_tests(), make_bounds(), make_expression_equalities(), make_interprocedural_abc_tests(), make_reindex(), MakeCaseStatement(), malloc_arg_to_type(), malloc_to_abstract_location(), mppa_compile_dag(), mppa_helper_args_params(), my_adg_expressions_to_predicate(), ndf_normalized_test(), nlc_linear_expression_p(), non_equal_condition_to_points_to(), normal_expression_of_expression(), normalize_test_leaves(), opkill_may_vreference(), opkill_must_vreference(), perform_array_element_substitutions_in_transformer(), perform_substitution_in_expression(), plc_make_distance(), pointer_binary_operation_to_transformer(), points_to_compare_cell(), points_to_compare_cells(), points_to_compare_location(), points_to_compare_ptr_cell(), points_to_unary_operation_to_transformer(), predicate_to_expression(), prepare_array_bounds(), print_list_of_expressions(), psystem_to_expression(), rational_op_exp(), remove_minmax(), sa_print_ins(), sc_conditional(), sc_delimiter(), semantics_usable_points_to_reference_p(), set_entity_initial(), side_effects_p(), sigmac_params_decl(), sp_feautrier_expression_p(), sp_linear_expression_p(), splc_feautrier_expression_p(), splc_linear_expression_p(), splc_positive_relation_p(), st_brace_expression_as_string(), st_declaration_init(), this_entity_cdeclaration(), translate_IO_ref(), vect_to_string(), words_points_to_reference(), xml_Argument(), xml_Array(), xml_AssignArgument(), xml_Bounds(), xml_Bounds_and_Stride(), xml_Call(), xml_Chain_Graph(), xml_loop(), and xml_Pattern_Paving().

Here is the call graph for this function:

extension_to_string()

string extension_to_string

(

extension

e

)

Returns

a new allocated string with the extension textual representation.

to be added later when extension can be something else than pragma switch (extension_tag(e)) { case is_extension_pragma:

default: pips_internal_error("Unknown extension type"); }

Definition at line 86 of file extension.c.

                                 {
  string s;
  /* to be added later when extension can be something else than pragma
  switch (extension_tag(e)) {
  case is_extension_pragma:
  */
    s = pragma_to_string(extension_pragma(e));
    /*  default:
    pips_internal_error("Unknown extension type");
    }*/
  return s;
}

References extension_pragma, and pragma_to_string().

Referenced by extensions_to_string().

Here is the call graph for this function:

Here is the caller graph for this function:

extensions_to_string()

string extensions_to_string	(	extensions	es,
		bool	nl
	)

return a new allocated string with the string representation of the extensions.

Basically you'll get one extension per line

Assume that all the extension from the extensions (note the presence or not of the "s"...) are defined below.

Returns

string_undefined if es is extension_undefined, an malloc()ed textual string either.

Parameters

es,the	extensions to translate to strings
nl,set	to true to get the string with a final new line character

Prettyprint in the correct language:

Use a string_buffer for efficient string concatenation:

Free the buffer with its strings:

Parameters

es	s
nl	l

Definition at line 111 of file extension.c.

                                             {
  string s = string_undefined;
 
  /* Prettyprint in the correct language: */
//  set_prettyprint_language_from_property ();
 
  if (!empty_extensions_p (es) ) {
    /* Use a string_buffer for efficient string concatenation: */
    string_buffer sb = string_buffer_make(false);
 
    list el = extensions_extension(es);
    FOREACH(EXTENSION, e, el) {
      s = extension_to_string(e);
      string_buffer_append(sb, s);
      if (nl ) string_buffer_append(sb, strdup ("\n"));
      nl = true;
    }
    s = string_buffer_to_string(sb);
    /* Free the buffer with its strings: */
    string_buffer_free_all(&sb);
  }
 
  return s;
}

References empty_extensions_p(), EXTENSION, extension_to_string(), extensions_extension, FOREACH, strdup(), string_buffer_append(), string_buffer_free_all(), string_buffer_make(), string_buffer_to_string(), and string_undefined.

Referenced by loop_pragma().

Here is the call graph for this function:

Here is the caller graph for this function:

find_last_statement()

statement find_last_statement

(

statement

)

Referenced by ensure_comment_consistency().

Here is the caller graph for this function:

find_or_create_allocatable_struct()

entity find_or_create_allocatable_struct	(	basic	b,
		string	name,
		int	ndim
	)

Warning! Do not modify this file that is automatically generated!

Modify src/Libs/prettyprint/prettyprint-local.h instead, to add your own modifications. header file built by cproto prettyprint-local.h cproto-generated files allocatable.c

Warning! Do not modify this file that is automatically generated!

Parameters

name	is the name of the array (prettyprint name)

Parameters

name	ame
ndim	dim

Definition at line 97 of file allocatable.c.

                                                                         {
  // FI: scaffolding code is not even guarded...
  printf("Creating allocatable struct for dim %d\n", ndim);
 
  // Create the entity name according to the number of dims
  string struct_name;
  string b_str = STRING(CAR(words_basic(b,NULL)));
  pips_assert("asprintf !",
      asprintf( &struct_name, ALLOCATABLE_PREFIX"%s_%s_%dD", name, b_str,ndim));
 
  // Here is the internal PIPS name, there is a prefix for struct
  string prefixed_name = strdup(concatenate(STRUCT_PREFIX, struct_name, NULL));
 
  // Let's try to localize the structure
  entity struct_entity = FindEntity(TOP_LEVEL_MODULE_NAME, prefixed_name);
 
  // Localization failed, let's create it
  if(struct_entity == entity_undefined) {
    list fields = NULL;
    list dimensions = NULL;
    for (int dim = ndim; dim >= 1; dim--) {
      entity lower = make_bound(struct_name, ALLOCATABLE_LBOUND_PREFIX, dim);
      entity upper = make_bound(struct_name, ALLOCATABLE_UBOUND_PREFIX, dim);
 
      // Field for struct
      fields = CONS(ENTITY,lower,fields);
      fields = CONS(ENTITY,upper,fields);
 
      // Dimensions for the data array
      dimension d = make_dimension(entity_to_expression(lower),
                                   entity_to_expression(upper),
                                   NIL);
      dimensions = CONS(DIMENSION,d,dimensions );
    }
 
    // Create data holder
    fields
        = CONS(ENTITY,make_data_field(b, struct_name, name, dimensions),fields);
 
    // Create the struct
    string field;
    asprintf(&field,STRUCT_PREFIX "%s",struct_name);
    struct_entity = FindOrCreateTopLevelEntity(field);
    free(field);
    entity_type(struct_entity) = make_type_struct(fields);
    entity_storage(struct_entity) = make_storage_rom();
    entity_initial(struct_entity) = make_value_unknown();
  }
 
  free(prefixed_name);
  free(struct_name);
 
  return struct_entity;
}

References ALLOCATABLE_LBOUND_PREFIX, ALLOCATABLE_PREFIX, ALLOCATABLE_UBOUND_PREFIX, asprintf, CAR, concatenate(), CONS, DIMENSION, ENTITY, entity_initial, entity_storage, entity_to_expression(), entity_type, entity_undefined, FindEntity(), FindOrCreateTopLevelEntity(), free(), make_bound(), make_data_field(), make_dimension(), make_storage_rom(), make_type_struct(), make_value_unknown(), NIL, pips_assert, printf(), strdup(), STRING, STRUCT_PREFIX, TOP_LEVEL_MODULE_NAME, and words_basic().

Referenced by gfc2pips_getbasic(), and gfc2pips_symbol2entity().

Here is the call graph for this function:

Here is the caller graph for this function:

find_statements_interactively()

list find_statements_interactively

(

statement

s

)

prompt the user to select contiguous statement in s

Parameters

s	statement to search into

Returns

list of selected statement

Definition at line 258 of file statement.c.

{
  list l =NIL;
  gen_context_recurse(s,&l,statement_domain,find_statements_interactively_walker,gen_null2);
  return gen_nreverse(l);
}

References find_statements_interactively_walker(), gen_context_recurse, gen_nreverse(), gen_null2(), NIL, and statement_domain.

Referenced by outline().

Here is the call graph for this function:

Here is the caller graph for this function:

fprint_expression()

void fprint_expression	(	FILE *	f,
		expression	e
	)

expression.c

Definition at line 47 of file expression.c.

{
  list pdl = NIL;
  print_words(f, words_syntax(expression_syntax(e), &pdl));
  gen_free_list(pdl);
}

References expression_syntax, f(), gen_free_list(), NIL, print_words(), and words_syntax().

Here is the call graph for this function:

fprint_list_of_exp()

void fprint_list_of_exp	(	FILE *	fp,
		list	exp_l
	)

void fprint_list_of_exp(FILE *fp, list exp_l): prints in the file "fp" the list of expression "exp_l".

We separate the expressions with a colon (","). We do not end the print with a line feed.

Parameters

fp	p
exp_l	xp_l

Definition at line 229 of file expression.c.

{
  list aux_l;
  expression exp;
  list pdl = NIL;
 
  for(aux_l = exp_l; aux_l != NIL; aux_l = CDR(aux_l))
    {
      exp = EXPRESSION(CAR(aux_l));
      fprintf(fp,"%s", words_to_string(words_expression(exp, &pdl)));
      if(CDR(aux_l) != NIL)
        fprintf(fp,",");
    }
  gen_free_list(pdl);
}

References CAR, CDR, exp, EXPRESSION, fprintf(), gen_free_list(), NIL, words_expression(), and words_to_string().

Referenced by analyze_quast(), build_first_comb(), build_new_ref(), calculate_delay(), compatible_pc_p(), fprint_call(), fprint_dataflow(), fprint_loop(), get_unsatisfied_system(), include_trans_on_LC_in_ref(), list_of_exp_equals_1n_p(), make_causal_external(), make_causal_internal(), make_reindex(), printf_loop(), search_scc_bdt(), and simplify_dimension().

Here is the call graph for this function:

Here is the caller graph for this function:

fprint_reference()

void fprint_reference	(	FILE *	fd,
		reference	r
	)

Parameters

fd

d

Definition at line 128 of file expression.c.

{
  if(reference_undefined_p(r))
    fprintf(fd, "reference undefined\n");
  // For debugging with gdb, dynamic type checking
  else if(reference_domain_number(r)!=reference_domain)
    fprintf(fd, "Not a Newgen \"reference\" object\n");
  else {
    list pdl = NIL;
    print_words(fd,words_reference(r, &pdl));
    gen_free_list(pdl);
  }
}

References fprintf(), gen_free_list(), NIL, print_words(), reference_domain, reference_domain_number, reference_undefined_p, and words_reference().

Referenced by fprint_wp65_hash_tables(), and print_reference().

Here is the call graph for this function:

Here is the caller graph for this function:

fprint_statement()

void fprint_statement	(	FILE *	fd,
		statement	s
	)

Print statement "s" on file descriptor "fd".

Print the statement according to the current PRETTYPRINT_LANGUAGE property

See text_named_module() for improvements.

Parameters

fd

d

Definition at line 68 of file statement.c.

{
  if(statement_undefined_p(s))
    fprintf(fd, "Undefined statement\n");
  // For debugging with gdb, dynamic type checking
  else if(statement_domain_number(s)!=statement_domain)
    (void) fprintf(fd,"Arg. \"s\"is not a statement.\n");
  else {
    debug_on("TEXT_DEBUG_LEVEL");
    set_alternate_return_set();
    reset_label_counter();
    push_current_module_statement(s);
    list pdl = NIL;
    text txt = text_statement(entity_undefined, 0, s, &pdl);
    gen_free_list(pdl);
    print_text(fd, txt);
    free_text(txt);
    pop_current_module_statement();
    reset_alternate_return_set();
    debug_off();
  }
}

References debug_off, debug_on, entity_undefined, fprintf(), free_text(), gen_free_list(), NIL, pop_current_module_statement(), print_text(), push_current_module_statement(), reset_alternate_return_set(), reset_label_counter(), set_alternate_return_set(), statement_domain, statement_domain_number, statement_undefined_p, and text_statement().

Referenced by initialize_array_variable(), initialize_scalar_variable(), insert_check_alias_before_statement(), insert_flag_before_call_site(), insert_test_before_caller(), insert_test_before_statement(), print_statement(), and step_compile_generated_module().

Here is the call graph for this function:

Here is the caller graph for this function:

gcc_if_block_braces_required_p()

bool gcc_if_block_braces_required_p

(

test

obj

)

Parameters

obj

bj

Definition at line 336 of file misc.c.

{
  statement tb = effective_test_true(obj);
 
  if(one_liner_p(tb)) {
    if (statement_test_p(tb)) {
      test nested_test = statement_test(tb);
      statement fb = test_false(nested_test);
      if (!empty_statement_p(fb)) {
        return prettyprint_gcc_c_braces_p;
      }
    }
  }
  return false;
}

References effective_test_true(), empty_statement_p(), one_liner_p(), prettyprint_gcc_c_braces_p, statement_test(), statement_test_p(), and test_false.

Referenced by text_block_ifthen().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_alternate_return_targets()

text generate_alternate_return_targets

(

void

)

Definition at line 824 of file misc.c.

{
  text ral = text_undefined;
 
  if(!ENDP(set_of_labels_required_for_alternate_returns)) {
    list sl = NIL;
    FOREACH(entity, le, set_of_labels_required_for_alternate_returns) {
      sentence s1 = sentence_undefined;
      string str_continue = string_undefined;
      switch (get_prettyprint_language_tag()) {
      case is_language_fortran95:
      case is_language_fortran:
        str_continue = CONTINUE_FUNCTION_NAME;
        break;
      case is_language_c:
        str_continue = C_CONTINUE_FUNCTION_NAME;
        break;
      default:
        pips_internal_error("Language unknown !");
        break;
      }
      unformatted u1 =
        make_unformatted( strdup( label_local_name( le ) ),
                          STATEMENT_NUMBER_UNDEFINED,
                          0,
                          CONS(STRING, strdup(str_continue), NIL));
      s1 = make_sentence(is_sentence_unformatted, u1);
      sl = gen_nconc(sl, CONS(SENTENCE, s1, NIL));
    }
    ral = make_text(sl);
  }
  else {
    ral = make_text(NIL);
  }
  return ral;
}

References C_CONTINUE_FUNCTION_NAME, CONS, CONTINUE_FUNCTION_NAME, ENDP, FOREACH, gen_nconc(), get_prettyprint_language_tag(), is_language_c, is_language_fortran, is_language_fortran95, is_sentence_unformatted, label_local_name(), make_sentence(), make_text(), make_unformatted(), NIL, pips_internal_error, s1, SENTENCE, sentence_undefined, set_of_labels_required_for_alternate_returns, STATEMENT_NUMBER_UNDEFINED, strdup(), STRING, string_undefined, and text_undefined.

Referenced by ensure_comment_consistency().

Here is the call graph for this function:

Here is the caller graph for this function:

generic_c_words_entity()

list generic_c_words_entity	(	type	t,
		list	name,
		bool	is_safe,
		bool	add_dummy_parameter_name_p,
		list *	ppdl
	)

This recursive function prints a C variable with its type.

It can be a simple variable declaration such as "int a" or complicated one such as "int (* forces[10])()" (an array of 10 pointers, each pointer points to a function with no parameter and the return type is int).

Type "t" is recursively traversed and the obtained attribute are accumulated in the list "name" (name of the type, not name of the variable).

Purpose of "is_safe"? Seems to be passed down recursively but never to be used...

In C, functional type can be decorated by optional dummy parameter names.

Parameters

name	ame
is_safe	s_safe
add_dummy_parameter_name_p	dd_dummy_parameter_name_p
ppdl	pdl

Definition at line 980 of file declarations.c.

{
// If this function is still used, NIL should be replaced by the
// module declaration list
  return generic_c_words_simplified_entity(t, name, is_safe,
                                           add_dummy_parameter_name_p,
                                           true, false, false, ppdl);
}

References generic_c_words_simplified_entity().

Referenced by c_words_entity(), safe_c_words_entity(), and stub_text().

Here is the call graph for this function:

Here is the caller graph for this function:

generic_c_words_simplified_entity()

list generic_c_words_simplified_entity	(	type	t,
		list	name,
		bool	is_safe,
		bool	add_dummy_parameter_name_p,
		bool	is_first,
		bool	in_type_declaration,
		bool	argument_p,
		list *	ppdl
	)

Same as above, but the bool is_first is used to skip a type specifier which is useful when several variables or types are defined in a unique statement such as "int i, *pi, ai[10],...;".

type t: new type to add in front of the word list name

list name: later part of the declaration being built

bool is_safe: does not seem to be used anymore

bool add_dummy_parameter_name_p: for function declarations, add a dummy parameter name to the type of each formal parameter

bool is_first: prettyprint the qualifiers or not; they should be printed only once when they apply to several declarations as in:

"register int i, j;"

in_type_declaration is set to true when a variable is declared at the same time as its type

argument_p: the type is used as argument type in a function declaration

list ppdl: pointer to the declaration list to decide if data structures appearing in another data structure must be declared independently or not. See validation cases struct03.c, struct04.c and struct05.c.

Function name is an expression like *vfs[] in (*vfs[])() (syntax = application), or an abstract function type, so parentheses must be added

Function name is a simple reference

RK wants us to use another better function than i2a, but its name is not documented next to i2a() source code and here the string is going to be strduped, which makes i2a() a better choice.

ips_debug(3,"Parameter type %s\n ", type_undefined_p(t1)? "type_undefined" : words_to_string(words_type(t1, ppdl, true)));

c_words_entity(t1,NIL) should be replaced by c_words_entity(t1,name_of_corresponding_parameter)

Add type qualifiers if there are

FI: left out of the previous declaration internal representation

&& !qualifiers_p

Array name is an expression like __ctype+1 in (__ctype+1)[*np] (syntax = subscript), or abstract type, parentheses must be added

Array name is a simple reference

The derived type has been declared explicitly elsewhere: see struct05.c

The derived type is declared by itself

Do not recurse down if the derived type reference itself

A place holder variable has no name and require no space

This section is derived from c_text_entity()

it is used for structures, unions and enums which have no names because they are part of a more global declaration such as typedef s

FI: The union and the struct cases could be merged.

Parameters

name	ame
is_safe	s_safe
add_dummy_parameter_name_p	dd_dummy_parameter_name_p
is_first	s_first
in_type_declaration	n_type_declaration
argument_p	rgument_p
ppdl	pdl

Definition at line 1017 of file declarations.c.

{
  list pc = NIL;
  bool space_p = get_bool_property("PRETTYPRINT_LISTS_WITH_SPACES");
 
  if(type_undefined_p(t)) {
    pc = CHAIN_SWORD(NIL, "type_undefined");
    pc = gen_nconc(pc,name);
    return pc;
  }
 
  if (type_functional_p(t))
    {
      functional f = type_functional(t);
      type t2 = functional_result(f);
      list lparams = functional_parameters(f);
      list cparam = list_undefined;
      bool first = true;
      int pnum;
 
      pips_debug(9,"Function type with name = \"%s\" and length %zd\n",
                 list_to_string(name), gen_length(name));
 
      if ((gen_length(name) > 1)
          || ((gen_length(name) == 1) && (strcmp(STRING(CAR(name)),"*")==0)))
        {
          /* Function name is an expression like *vfs[] in (*vfs[])()
             (syntax = application), or an abstract function type, so
             parentheses must be added */
          pc = CHAIN_SWORD(NIL,"(");
          pc = gen_nconc(pc,name);
          pc = CHAIN_SWORD(pc,")(");
 
        }
      else
        {
          /* Function name is a simple reference */
          pc = CHAIN_SWORD(name,"(");
        }
 
      if(!overloaded_parameters_p(lparams)) {
        for(cparam = lparams, pnum = 1; !ENDP(cparam); POP(cparam), pnum++) {
          parameter p = PARAMETER(CAR(cparam));
          type t1 = parameter_type(p);
          string pn = dummy_unknown_p(parameter_dummy(p))?
            string_undefined
            : strdup(entity_local_name(dummy_identifier(parameter_dummy(p))));
 
          if(add_dummy_parameter_name_p
             && string_undefined_p(pn)
             && !type_varargs_p(t1)
             && !type_void_p(t1)) {
            /* RK wants us to use another better function than i2a, but
               its name is not documented next to i2a() source code and
               here the string is going to be strduped, which makes
               i2a() a better choice. */
            pn = concatenate("f", i2a(pnum), NULL);
          }
 
          /*pips_debug(3,"Parameter type %s\n ",
            type_undefined_p(t1)? "type_undefined" :
            words_to_string(words_type(t1, ppdl, true))); */
          if (!first)
            pc = gen_nconc(pc,CHAIN_SWORD(NIL, space_p? ", " : ","));
          /* c_words_entity(t1,NIL) should be replaced by c_words_entity(t1,name_of_corresponding_parameter) */
          pc = gen_nconc(pc,
                         generic_c_words_simplified_entity(t1,
                                                           string_undefined_p(pn)? NIL : CONS(STRING, strdup(pn), NIL),
                                                           is_safe, false, true,in_type_declaration, true, ppdl));
          pips_debug(9,"List of parameters \"%s\"\n ",list_to_string(pc));
          first = false;
        }
      }
 
      pc = CHAIN_SWORD(pc,")");
      return generic_c_words_simplified_entity(t2, pc, is_safe, false,
                                               is_first, in_type_declaration,
                                               argument_p, ppdl);
    }
 
  if (pointer_type_p(t))
    {
      type t1 = basic_pointer(variable_basic(type_variable(t)));
      pips_debug(9,"Pointer type with name = %s\n", list_to_string(name));
 
      /*
       *  No space : it's only "after a comma to separate items in lists such as
       *  declaration lists or parameter lists in order to improve readability"
       *
       * FI: a space would be useful sometimes to separate "*" from an
       * identifier in "char *foo(void)" to obtain "char * foo(void)"
       * instead, but not "char * * foo(void)" nor "void foo(char * )".
       */
      // pc = CHAIN_SWORD(NIL, space_p? "*":"*");
      pc = CHAIN_SWORD(NIL, "*");
      // FI: qualifiers for type t1 are dealt with at a lower level,
      // qualifiers for type t are dealt here
      variable var = type_variable(t);
      list ql = variable_qualifiers(var);
      if (qualifiers_const_p(ql) || qualifiers_restrict_p(ql)) {
        pc = gen_nconc(pc, words_late_qualifiers(variable_qualifiers(type_variable(t))) );
        // We may have other qualifiers which must be output somewhere
        // else, for instance "register"
        /*
        pc = gen_nconc(pc,
                       words_qualifiers(variable_qualifiers(type_variable(t))));
        */
      }
      pc = gen_nconc(pc,name);
      pc = generic_c_words_simplified_entity(t1, pc, is_safe, false,
                                             is_first, in_type_declaration,
                                             argument_p, ppdl);
      pc = gen_nconc(words_initial_qualifiers(ql), pc);
      return pc;
    }
 
  /* Add type qualifiers if there are */
  bool qualifiers_p = false;
  if (false && ( is_first || in_type_declaration )
      && type_variable_p(t)
      && variable_qualifiers(type_variable(t)) != NIL) {
    pc = words_qualifiers(variable_qualifiers(type_variable(t)));
    qualifiers_p = true;
  }
  else if (false && ( is_first || in_type_declaration )
      && type_void_p(t)
      && type_void(t) != NIL)
    pc = words_qualifiers(type_void(t));
 
  if (basic_type_p(t)) {
      string sname = list_to_string(name);
      pips_debug(9,"Basic type with name = \"%s\"\n", sname);
 
      if(is_first) {
        pc = gen_nconc(pc,words_type(t, ppdl, argument_p));
      }
      if (string_type_p(t)) {
        // pc = CHAIN_SWORD(pc," *");
        ;
      }
      /* FI: left out of the previous declaration internal representation */
      if(strlen(sname)!=0 && is_first/* && !qualifiers_p*/)
        pc = CHAIN_SWORD(pc," ");
      if(!bit_type_p(t) || (strstr(sname,DUMMY_MEMBER_PREFIX)==NULL)) {
        pc = gen_nconc(pc,name);
        }
      free(sname);
      if (bit_type_p(t)) {
          symbolic s = basic_bit(variable_basic(type_variable(t)));
          expression ie = symbolic_expression(s);
          list iew = words_expression(ie, ppdl);
          pc = CHAIN_SWORD(pc,":");
          pc = gen_nconc(pc, iew);
      }
      return pc;
    }
  if (array_type_p(t)) {
    variable var = type_variable(t);
    list dims = variable_dimensions(var);
    list ql = variable_qualifiers(var);
    type t1 = copy_type(t);
    list tmp = NIL;
    pips_debug(9,"Array type with name = %s\n", list_to_string(name));
 
    if ((gen_length(name) > 1) || ((gen_length(name) == 1) && (strcmp(STRING(CAR(name)),"*")==0)))
      {
        /* Array name is an expression like __ctype+1 in (__ctype+1)[*np]
           (syntax = subscript), or abstract type, parentheses must be added */
        tmp = CHAIN_SWORD(tmp,"(");
        tmp = gen_nconc(tmp,name);
        tmp = CHAIN_SWORD(tmp,")");
      }
    else
      {
        /* Array name is a simple reference  */
        tmp = name;
      }
    gen_full_free_list(variable_dimensions(type_variable(t1)));
    variable_dimensions(type_variable(t1)) = NIL;
    // FI: I understand why the dimension information has to be
    // removed, I so not understand why the qualifiers have to be
    // removed too
    gen_full_free_list(variable_qualifiers(type_variable(t1)));
    variable_qualifiers(type_variable(t1)) = NIL;
    pips_debug(8, "Before concatenation, pc=\"\%s\"\n", list_to_string(pc));
    if(pc!=NIL && !qualifiers_p)
      pc = CHAIN_SWORD(pc, " ");
    list ret =
      gen_nconc(pc,
                generic_c_words_simplified_entity(t1,gen_nconc(tmp,words_dimensions(dims, ppdl)),
                                                  is_safe, false, is_first,
                                                  in_type_declaration,
                                                  argument_p,
                                                  ppdl));
    ret = gen_nconc(words_qualifiers(ql), ret);
    free_type(t1);
    return ret;
  }
 
  if (derived_type_p(t))
    {
      variable v = type_variable(t);
      basic b = variable_basic(v);
      list ql = variable_qualifiers(v);
      entity ent = basic_derived(b);
      if(is_first) {
        type t1 = entity_type(ent);
        string n = entity_name(ent);
        pips_debug(9,"Derived type with name = %s\n", list_to_string(name));
        if((strstr(n,ENUM_PREFIX DUMMY_ENUM_PREFIX)==NULL)
           &&(strstr(n,STRUCT_PREFIX DUMMY_STRUCT_PREFIX)==NULL)
           &&(strstr(n,UNION_PREFIX DUMMY_UNION_PREFIX)==NULL)) {
          if(gen_in_list_p((void *) ent, *ppdl) // previously defined
             || !declarable_type_p(t1, *ppdl) // not definable yet
             // FI: it might be better to pass down an extra parameter
             // rather than deduce this from name
             || (!ENDP(name) && same_string_p(STRING(CAR(name)), ""))) { // "struct s;" case
            /* The derived type has been declared explicitly
               elsewhere: see struct05.c */
            pc = gen_nconc(pc,words_type(t1, ppdl, argument_p));
            pc = CHAIN_SWORD(pc," ");
            pc = CHAIN_SWORD(pc,entity_user_name(ent));
          }
          else {
            /* The derived type is declared by itself*/
            const char* name = entity_user_name(ent);
            list epc = NIL;
            /* Do not recurse down if the derived type reference
               itself */
            *ppdl = gen_once((void *) ent, *ppdl);
            epc =
              generic_c_words_simplified_entity(t1,
                                                CHAIN_SWORD(NIL,name),
                                                is_safe,
                                                add_dummy_parameter_name_p,
                                                is_first, in_type_declaration,
                                                argument_p, ppdl);
            pc = gen_nconc(pc, epc);
            //gen_free_list(npdl);
          }
          if(!ENDP(ql))
            pc = gen_nconc(words_qualifiers(ql), pc);
        }
        else {
          //pc = CHAIN_SWORD(pc,"problem!");
          pc = c_words_entity(t1, pc, ppdl);
        }
        /* A place holder variable has no name and require no space */
        if(gen_length(name)==1 && same_string_p(STRING(CAR(name)),""))
          ;
        else
          pc = CHAIN_SWORD(pc," ");
      }
      return gen_nconc(pc,name);
    }
  if (typedef_type_p(t))
    {
      if(is_first) {
        // FI: type_variable_p() is always true?
        variable var = type_variable(t);
        list ql = variable_qualifiers(var);
        basic b = variable_basic(var);
        entity ent = basic_typedef(b);
        pips_debug(9,"Typedef type with name = \"\%s\"\n",
                   list_to_string(name));
        pc = CHAIN_SWORD(pc, entity_user_name(ent));
        pc = gen_nconc(words_qualifiers(ql), pc);
        if(name!=NIL)
          pc = CHAIN_SWORD(pc," ");
      }
      return gen_nconc(pc,name);
    }
  if (type_varargs_p(t))
    {
      pips_debug(9,"Varargs type ... with name = %s\n", list_to_string(name));
      pc = CHAIN_SWORD(pc,"...");
      return gen_nconc(pc,name);
    }
  /* This section is derived from c_text_entity() */
  /* it is used for structures, unions and enums which have no names
     because they are part of a more global declaration such as
     typedef s*/
  /* FI: The union and the struct cases could be merged. */
  if(type_struct_p(t))
    {
      list l = type_struct(t);
      string sname = list_to_string(name);
      list cl = list_undefined;
 
      pips_debug(9,"Struct type ... with name = %s\n", sname);
 
      pc = CHAIN_SWORD(pc,"struct ");
      // hmmm... name may be an empty list... and the sname test seems true
      if(name && strstr(sname,DUMMY_STRUCT_PREFIX)==NULL) {
        pc = gen_nconc(pc,name);
        if(!ENDP(l))
          pc = CHAIN_SWORD(pc," ");
      }
      free(sname);
      if(!ENDP(l)) {
        pc = CHAIN_SWORD(pc,"{");
 
        for(cl = l; !ENDP(cl); POP(cl)) {
          entity sm = ENTITY(CAR(cl));
          type tsm = entity_type(sm);
          pc = gen_nconc(pc,c_words_entity(tsm,CHAIN_SWORD(NIL,entity_user_name(sm)), ppdl));
          if(ENDP(CDR(cl)))
            pc = CHAIN_SWORD(pc,";");
          else
            pc = CHAIN_SWORD(pc,"; ");
        }
        pc = CHAIN_SWORD(pc,"}");
      }
      return pc;
    }
  if(type_union_p(t))
    {
      list l = type_union(t);
      string sname = list_to_string(name);
      list cl = list_undefined;
 
      pips_debug(9,"Union type ... with name = %s\n", sname);
 
      pc = CHAIN_SWORD(pc,"union ");
      //if(strstr(sname,DUMMY_UNION_PREFIX)==NULL) {
      //        pc = gen_nconc(pc,name);
      //        pc = CHAIN_SWORD(pc," ");
      //}
      free(sname);
      pc = CHAIN_SWORD(pc,"{");
 
      for(cl = l; !ENDP(cl); POP(cl)) {
        entity eu = ENTITY(CAR(cl));
        type tu = entity_type(eu);
        pc = gen_nconc(pc,c_words_entity(tu,CHAIN_SWORD(NIL,entity_user_name(eu)), ppdl));
        if(ENDP(CDR(cl)))
          pc = CHAIN_SWORD(pc,";");
        else
          pc = CHAIN_SWORD(pc,"; ");
     }
      pc = CHAIN_SWORD(pc,"}");
      return pc;
    }
  if(type_enum_p(t))
    {
      list l = type_enum(t);
      bool first = true;
      string sname = list_to_string(name);
      list cl = list_undefined;
      int cv = 0;
 
      pips_debug(9,"Enum type ... with name = %s\n", sname);
 
      pc = CHAIN_SWORD(pc,"enum ");
      if(strstr(sname,DUMMY_ENUM_PREFIX)==NULL && !same_string_p(sname,"")) {
        pc = gen_nconc(pc,name);
        pc = CHAIN_SWORD(pc," ");
      }
      free(sname);
      pc = CHAIN_SWORD(pc,"{");
 
      for(cl = l; !ENDP(cl); POP(cl)) {
        entity em = ENTITY(CAR(cl));
        value emv = entity_initial(em);
        symbolic ems = value_symbolic(emv);
        expression eme = symbolic_expression(ems);
        constant emc = symbolic_constant(value_symbolic(emv));
        int n = constant_int(emc);
 
        if (!first)
          pc = CHAIN_SWORD(pc, space_p? ", " : ",");
        pc = CHAIN_SWORD(pc, entity_user_name(em));
        if(n!=cv || !constant_int_p(emc)) {
          pc = CHAIN_SWORD(pc, "=");
          pc = gen_nconc(pc, words_expression(eme, ppdl));
          cv = n;
        }
        cv++;
        first = false;
      };
      pc = CHAIN_SWORD(pc,"}");
      return pc;
    }
  pips_internal_error("unexpected case");
  return NIL;
}

References argument_p(), array_type_p(), basic_bit, basic_derived, basic_pointer, basic_type_p(), basic_typedef, bit_type_p(), c_words_entity(), CAR, CDR, CHAIN_SWORD, concatenate(), CONS, constant_int, constant_int_p, copy_type(), declarable_type_p(), derived_type_p(), DUMMY_ENUM_PREFIX, dummy_identifier, DUMMY_MEMBER_PREFIX, DUMMY_STRUCT_PREFIX, DUMMY_UNION_PREFIX, dummy_unknown_p, ENDP, ENTITY, entity_initial, entity_local_name(), entity_name, entity_type, entity_user_name(), ENUM_PREFIX, f(), free(), free_type(), functional_parameters, functional_result, gen_full_free_list(), gen_in_list_p(), gen_length(), gen_nconc(), gen_once(), get_bool_property(), i2a(), list_to_string(), list_undefined, lparams, NIL, overloaded_parameters_p(), PARAMETER, parameter_dummy, parameter_type, pips_debug, pips_internal_error, pointer_type_p(), POP, qualifiers_const_p(), qualifiers_restrict_p(), ret, same_string_p, strdup(), STRING, string_type_p(), string_undefined, string_undefined_p, STRUCT_PREFIX, symbolic_constant, symbolic_expression, type_enum, type_enum_p, type_functional, type_functional_p, type_struct, type_struct_p, type_undefined_p, type_union, type_union_p, type_varargs_p, type_variable, type_variable_p, type_void, type_void_p, typedef_type_p(), UNION_PREFIX, value_symbolic, variable_basic, variable_dimensions, variable_qualifiers, words_dimensions(), words_expression(), words_initial_qualifiers(), words_late_qualifiers(), words_qualifiers(), and words_type().

Referenced by c_words_simplified_entity(), and generic_c_words_entity().

Here is the call graph for this function:

Here is the caller graph for this function:

generic_text_statement_enclosed()

text generic_text_statement_enclosed	(	entity	,
		int	,
		statement	,
		bool	,
		bool	,
		list *	,
		bool	,
		bool
	)

Referenced by ensure_comment_consistency().

Here is the caller graph for this function:

get_comment_continuation()

string get_comment_continuation

(

void

)

Start a single line comment with continuation (blank spaces)

Returns

a string containing the begin of a comment line, language dependent

Definition at line 167 of file misc.c.

                                  {
  switch(get_prettyprint_language_tag()) {
    case is_language_c: return "//    ";
    case is_language_fortran: return "C    ";
    case is_language_fortran95: return "!    ";
    default: pips_internal_error("language unknown not handled"); return NULL ;
  }
}

References get_prettyprint_language_tag(), is_language_c, is_language_fortran, is_language_fortran95, and pips_internal_error.

Referenced by text_pointer_value(), text_pointer_values(), text_points_to_relation(), text_points_to_relations(), text_region_no_action(), and text_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

get_comment_sentinel()

string get_comment_sentinel

(

void

)

Start a single line comment.

Returns

a string containing the begin of a comment line, language dependent

Definition at line 154 of file misc.c.

                              {
  switch(get_prettyprint_language_tag()) {
    case is_language_c: return "//";
    case is_language_fortran: return "C";
    case is_language_fortran95: return "!";
    default: pips_internal_error("language unknown not handled"); return NULL ;
  }
}

References get_prettyprint_language_tag(), is_language_c, is_language_fortran, is_language_fortran95, and pips_internal_error.

Referenced by init_text_statement(), loop_annotate(), mark_block(), print_any_reductions(), text_complexity(), text_continuation(), text_pointer_value(), text_pointer_values(), text_points_to(), text_points_to_relation(), text_points_to_relations(), text_reductions(), text_region_no_action(), text_transformer(), and text_unstructured().

Here is the call graph for this function:

Here is the caller graph for this function:

get_prettyprint_indentation()

unsigned int get_prettyprint_indentation

(

void

)

Definition at line 177 of file misc.c.

                                           {
  if(prettyprint_language_is_fortran_p()) {
    return 0;
  } else {
    return INDENTATION;
  }
}

References INDENTATION, and prettyprint_language_is_fortran_p().

Referenced by ensure_comment_consistency(), sentence_area(), sentence_basic_declaration(), sentence_data(), sentence_data_statement(), sentence_external(), sentence_symbolic(), and text_entity_declaration().

Here is the call graph for this function:

Here is the caller graph for this function:

get_symbol_table()

string get_symbol_table	(	entity	m,
		bool	isfortran
	)

return variable

To simplify validation, at the expense of some information about the parsing process.

FI: struct, union and enum are also declared (in theory...), but their characteristics should be given differently.

&& (storage_ram_p(s) || storage_return_p(s) || storage_formal_p(s))

FI: How do we want to print out structures, unions and enums?

FI: How do we want to print out typedefs?

FI: it would be useful to dump more information aout fields and members

Formal parameters

Return variable

Structure of each area/common

Parameters

isfortran

sfortran

Definition at line 304 of file symbol_table.c.

{
  string_buffer result = string_buffer_make(true);
  string result2;
  list decls = gen_copy_seq(code_declarations(value_code(entity_initial(m))));
  int nth = 0;
  entity rv = entity_undefined; /* return variable */
  list ce = list_undefined;
 
  pips_assert("m is a module", entity_module_p(m));
  pips_assert("decls is a list of entities", entity_list_p(decls));
 
  /* To simplify validation, at the expense of some information about
     the parsing process. */
 
  gen_sort_list(decls, (gen_cmp_func_t)compare_entities);
 
  string_buffer_append(result, concatenate(NL,"Declarations for module \"",
                                           module_local_name(m),"\" with type \"", NULL));
 
  dump_functional(type_functional(entity_type(m)), result);
  string_buffer_append(result, "\"" NL);
 
  /*
   * List of implicitly and explicitly declared variables, functions
   * and areas
   *
   */
  if(ENDP(decls))
    string_buffer_append(result, concatenate("\n* empty declaration list *",NL,NL,NULL));
  else
    string_buffer_append(result, concatenate("\nVariable list:",NL,NL,NULL));
 
  FOREACH(ENTITY, e, decls) {
    // FI: more filtering needed for entities generated by the
    // different passes, such as location entities
    if(!typedef_entity_p(e) && !derived_entity_p(e)) {
      type t = entity_type(e);
 
      pips_debug(8, "Processing entity \"%s\"\n", entity_name(e));
      string_buffer_append(result, concatenate("\tDeclared entity \"",
                                               entity_name(e),"\" with type \"",
                                               type_to_string(t),"\" ",NULL));
 
      /* FI: struct, union and enum are also declared (in theory...), but
         their characteristics should be given differently. */
      if(type_variable_p(t)
         /* && (storage_ram_p(s) || storage_return_p(s) || storage_formal_p(s))*/) {
        variable v = type_variable(t);
        list dl = variable_dimensions(v);
        list ql = variable_qualifiers(v);
        basic b = variable_basic(v);
        if(basic_pointer_p(b) && type_functional_p(basic_pointer(b))) {
          functional f = type_functional(basic_pointer(b));
          string_buffer_append(result, "\"(");
          dump_functional(f,result);
          string_buffer_append(result, ") *\""NL);
        }
        else {
          if(ENDP(dl)) {
            if(ENDP(ql)) {
              string_buffer_append(result,
                                   concatenate("\"", basic_to_string(b), "\""NL,NULL));
            }
            else {
              string sql = list_to_string(words_qualifiers(ql));
              string_buffer_append(result,
                                   concatenate("\"", sql, basic_to_string(b), "\""NL,NULL));
            }
          }
          else {
            list pdl = NIL;
            string sdl = list_to_string(words_dimensions(dl, &pdl));
            gen_free_list(pdl);
            if(ENDP(ql)) {
              string_buffer_append(result,
                                   concatenate("\"", basic_to_string(b), sdl, "\""NL,NULL));
            }
            else {
              string sql = list_to_string(words_qualifiers(ql));
              string_buffer_append(result,
                                   concatenate("\"", sql, basic_to_string(b), sdl, "\""NL,NULL));
            }
          }
        }
      }
      else if(type_functional_p(t)) {
        string_buffer_append(result, "\"");
        dump_functional(type_functional(t),result);
        string_buffer_append(result, "\""NL);
      }
      else if(type_area_p(t)) {
        string_buffer_append(result,concatenate("with size ",
                                                i2a(area_size(type_area(t))),NL, NULL));
      }
      else {
        /* FI: How do we want to print out structures, unions and enums? */
        /* FI: How do we want to print out typedefs? */
        string_buffer_append(result, NL);
      }
    }
  }
 
  /*
   * Extern declarations
   */
 
  if(!isfortran) {
    list edecls = gen_copy_seq(code_externs(value_code(entity_initial(m))));
 
    //gen_sort_list(decls, compare_entities);
 
    if(ENDP(edecls))
      string_buffer_append(result, concatenate("\n* empty extern declaration list *",NL,NL,NULL));
    else
      string_buffer_append(result, concatenate("\nExternal variable list:",NL,NL,NULL));
 
    for(ce=edecls; !ENDP(ce); POP(ce)) {
      entity e = ENTITY(CAR(ce));
      type t = entity_type(e);
 
      pips_debug(8, "Processing external entity \"%s\"\n", entity_name(e));
      pips_assert("e is an entity", entity_domain_number(e)==entity_domain);
      string_buffer_append(result, concatenate("\tDeclared external entity \"",
                                               entity_name(e),"\"\twith type \"",
                                               type_to_string(t),"\" ",NULL));
 
      if(type_variable_p(t)) {
        variable v = type_variable(t);
        basic b = variable_basic(v);
        if(basic_pointer_p(b) && type_functional_p(basic_pointer(b))) {
          functional f = type_functional(basic_pointer(b));
          string_buffer_append(result, "\"(");
          dump_functional(f,result);
          string_buffer_append(result, ") *\"" NL);
        }
        else {
          string_buffer_append(result,
                               concatenate("\"", basic_to_string(b), "\""NL,NULL));
        }
      }
      else if(type_functional_p(t)) {
        string_buffer_append(result, "\"");
        dump_functional(type_functional(t),result);
        string_buffer_append(result, "\"" NL);
      }
      else if(type_area_p(t)) {
        string_buffer_append(result,concatenate("with size ",
                                                i2a(area_size(type_area(t))),NL, NULL));
      }
      else
        string_buffer_append(result, NL);
    }
  }
 
  /*
   * Derived entities: struct, union and enum
   */
 
  nth = 0;
  FOREACH(ENTITY, de, decls) {
    if(entity_struct_p(de) || entity_union_p(de) || entity_enum_p(de)) {
        nth++;
        if(nth==1) {
          string_buffer_append(result, concatenate(NL,"Derived entities:"
                                                   ,NL,NL,NULL));
        }
        /* FI: it would be useful to dump more information aout
           fields and members */
        string_buffer_append(result, concatenate("\tVariable \"", entity_name(de),
                                                 "\"\tkind = ",
                                                 entity_struct_p(de)? "struct" :
                                                 entity_union_p(de)? "union" : "enum",
                                                 "\n", NULL));
      }
  }
 
  /*
   * Typedefs
   */
 
  nth = 0;
  FOREACH(ENTITY, te, decls) {
    if(typedef_entity_p(te)) {
      type t = entity_type(te);
      nth++;
      if(nth==1) {
        string_buffer_append(result, concatenate(NL,"Typedef entities:"
                                                 ,NL,NL,NULL));
      }
      string_buffer_append(result, concatenate("\tTypedef \"", entity_name(te),
                                               "\"\twith type \"",type_to_string(t),"\" ", NULL));
 
      if(type_variable_p(t)) {
        variable v = type_variable(t);
        basic b = variable_basic(v);
        if(basic_pointer_p(b) && type_functional_p(basic_pointer(b))) {
          functional f = type_functional(basic_pointer(b));
          string_buffer_append(result, "\"(");
          dump_functional(f,result);
          string_buffer_append(result, ") *\"" NL);
        }
        else {
          string_buffer_append(result,
                               concatenate("\"", basic_to_string(b), "\""NL,NULL));
        }
      }
      else if(type_functional_p(t)) {
        string_buffer_append(result, "\"");
        dump_functional(type_functional(t),result);
        string_buffer_append(result, "\"" NL);
      }
      else if(type_void_p(t)) {
        string_buffer_append(result, "\"void\"" NL);
      }
      else {
        pips_internal_error("unexpected type for a typedef");
      }
    }
  }
 
  /* Formal parameters */
  nth = 0;
  FOREACH(ENTITY, v, decls) {
      storage vs = entity_storage(v);
 
      pips_assert("All storages are defined", !storage_undefined_p(vs));
 
      if(storage_formal_p(vs)) {
        nth++;
        if(nth==1) {
          string_buffer_append(result, concatenate(NL,"Layout for formal parameters:"
                                                   ,NL,NL,NULL));
        }
        string_buffer_append(result, concatenate("\tVariable ", entity_name(v),
                                                 "\toffset = ",
                                                 i2a(formal_offset(storage_formal(vs))),
                                                 "\n", NULL));
      }
      else if(storage_return_p(vs)) {
        pips_assert("No more than one return variable", entity_undefined_p(rv));
        rv = v;
      }
  }
 
  /* Return variable */
  if(!entity_undefined_p(rv)) {
    basic rb = variable_basic(type_variable(ultimate_type(entity_type(rv))));
    string_buffer_append(result, concatenate(NL,"Layout for return variable:",NL,NL,NULL));
    string_buffer_append(result, concatenate("\tVariable \"",
                                             entity_name(rv),
                                             "\"\tsize = ",
                                             strdup(i2a(SizeOfElements(rb))),
                                             "\n", NULL));
  }
 
  /* Structure of each area/common */
  if(!ENDP(decls)) {
    string_buffer_append(result, concatenate(NL,"Layouts for ",isfortran?"commons:":"memory areas:",NL,NULL));
  }
 
  FOREACH (ENTITY, e, decls) {
        if(type_area_p(entity_type(e))) {
          dump_common_layout(result, e, false, isfortran);
        }
  }
 
  string_buffer_append(result, concatenate("End of declarations for module ",
                                           module_local_name(m), NL,NL, NULL));
 
  gen_free_list(decls);
 
  result2 = string_buffer_to_string(result);
  string_buffer_free(&result);
 
  return result2;
}

References area_size, basic_pointer, basic_pointer_p, basic_to_string(), CAR, code_declarations, code_externs, compare_entities(), concatenate(), derived_entity_p(), dump_common_layout(), dump_functional(), ENDP, ENTITY, entity_domain, entity_domain_number, entity_enum_p(), entity_initial, entity_list_p(), entity_module_p(), entity_name, entity_storage, entity_struct_p(), entity_type, entity_undefined, entity_undefined_p, entity_union_p(), f(), FOREACH, formal_offset, gen_copy_seq(), gen_free_list(), gen_sort_list(), i2a(), list_to_string(), list_undefined, module_local_name(), NIL, NL, pips_assert, pips_debug, pips_internal_error, POP, SizeOfElements(), storage_formal, storage_formal_p, storage_return_p, storage_undefined_p, strdup(), string_buffer_append(), string_buffer_free(), string_buffer_make(), string_buffer_to_string(), type_area, type_area_p, type_functional, type_functional_p, type_to_string(), type_variable, type_variable_p, type_void_p, typedef_entity_p(), ultimate_type(), value_code, variable_basic, variable_dimensions, variable_qualifiers, words_dimensions(), and words_qualifiers().

Referenced by actual_symbol_table_dump().

Here is the call graph for this function:

Here is the caller graph for this function:

html_output()

void html_output	(	const char *	out,
		bool	cr
	)

html_prettyprinter.c

Parameters

out	ut
cr	r

Definition at line 105 of file html_prettyprinter.c.

                                           {
  if(cr) {
    html_print("<li><span>%s</span></li>" NL, out);
  } else {
    html_print("<li class=\"inlined\"><span>%s</span></li>" NL, out);
  }
}

References html_print, NL, and out.

Referenced by html_print_area(), html_print_basic(), html_print_constant(), html_print_entity_full(), html_print_entity_name(), html_print_expression(), html_print_formal(), html_print_mode(), html_print_parameter(), html_print_qualifier(), html_print_ram(), html_print_rom(), html_print_statement(), html_print_storage(), html_print_type(), html_print_unstructured(), html_print_value(), and html_print_whileloop().

Here is the caller graph for this function:

html_prettyprint()

bool html_prettyprint

(

const

string

)

Set the current module entity required to have many things working in PIPS:

The debug is now controled by this environment variable name:

Print current module

Parameters

string

od_name

Definition at line 818 of file html_prettyprinter.c.

{
 
  statement module_statement = (statement)db_get_memory_resource(DBR_CODE,
                                                                 mod_name,
                                                                 true);
 
  set_current_module_statement(module_statement);
 
  /* Set the current module entity required to have many things
     working in PIPS: */
  set_current_module_entity(module_name_to_entity(mod_name));
 
 
  /* The debug is now controled by this environment variable name: */
  debug_on("HTML_PRETTYPRINT_DEBUG_LEVEL");
  pips_assert("Statement should be OK at entry...",
              statement_consistent_p(module_statement));
 
  // Prepare the output file
  string html_file_name = db_build_file_resource_name( "RI", mod_name, ".ri.html" );
  string output_file = strdup( concatenate( db_get_current_workspace_directory( ),
                                        "/",
                                        html_file_name,
                                        NULL ) );
  pips_debug(2,"Output in %s",output_file);
  FILE *fp = safe_fopen( output_file, "w" );
  html_set_output(fp);
 
  /* Print current module */
  html_print(NL "<li><ul class=\"module\">" NL);
  begin_block(mod_name, true);
  html_print_statement(module_statement);
  end_block(mod_name, true);
  html_print("<li class=\"endmodule\">&nbsp;</li>" NL "</ul></li>" NL);
 
 
  if(get_bool_property("HTML_PRETTYPRINT_SYMBOL_TABLE")) {
    html_print_symbol_table();
  }
 
  // Reset output file
  html_set_output(0);
  safe_fclose( fp, output_file );
 
 
  DB_PUT_FILE_RESOURCE( DBR_HTML_IR_FILE, strdup( mod_name ), html_file_name );
 
  reset_current_module_statement();
  reset_current_module_entity();
 
  return true;
}

References begin_block(), concatenate(), db_build_file_resource_name(), db_get_current_workspace_directory(), db_get_memory_resource(), DB_PUT_FILE_RESOURCE, debug_on, end_block(), get_bool_property(), html_print, html_print_statement(), html_print_symbol_table(), html_set_output(), module_name_to_entity(), module_statement, NL, pips_assert, pips_debug, reset_current_module_entity(), reset_current_module_statement(), safe_fclose(), safe_fopen(), set_current_module_entity(), set_current_module_statement(), statement_consistent_p(), and strdup().

Here is the call graph for this function:

html_prettyprint_symbol_table()

bool html_prettyprint_symbol_table

(

const

string

)

Parameters

string

odule

Definition at line 872 of file html_prettyprinter.c.

{
  pips_debug(1, "working on %s", module);
 
  // Prepare the output file
  string html_file_name =
    db_build_file_resource_name( "Symbols", "", ".symbols.html" );
  string output_file =
    strdup( concatenate( db_get_current_workspace_directory( ),
                         "/", html_file_name, NULL ) );
  FILE *fp = safe_fopen( output_file, "w" );
  html_set_output(fp);
 
  // Reset output file
  html_set_output(0);
  safe_fclose( fp, output_file );
 
  DB_PUT_FILE_RESOURCE( DBR_HTML_IR_FILE, "", html_file_name );
 
  return true;
}

References concatenate(), db_build_file_resource_name(), db_get_current_workspace_directory(), DB_PUT_FILE_RESOURCE, html_set_output(), module, pips_debug, safe_fclose(), safe_fopen(), and strdup().

Here is the call graph for this function:

html_print_entity_full()

void html_print_entity_full

(

entity

e

)

Definition at line 521 of file html_prettyprinter.c.

                                      {
  begin_block("entity", true);
  html_output(entity_name( e ), true);
  html_print_type(entity_type( e ));
  html_print_storage(entity_storage( e ));
  html_print_value(entity_initial( e ));
 
  end_block("entity", true);
}

References begin_block(), end_block(), entity_initial, entity_name, entity_storage, entity_type, html_output(), html_print_storage(), html_print_type(), and html_print_value().

Referenced by html_print_symbol_table().

Here is the call graph for this function:

Here is the caller graph for this function:

html_print_symbol_table()

void html_print_symbol_table

(

void

)

Print symbol table

Definition at line 805 of file html_prettyprinter.c.

{
  /* Print symbol table */
  html_print(NL "<li><ul class=\"symbolTable\">" NL);
  begin_block("Symbol table", true);
  list entities = gen_filter_tabulated(gen_true, entity_domain);
  FOREACH(entity, e, entities ) {
    html_print_entity_full(e);
  }
  html_print("<li class=\"endSymbolTable\">&nbsp;</li>" NL "</ul></li>" NL);
  end_block("Symbol table", true);
}

References begin_block(), end_block(), entity_domain, FOREACH, gen_filter_tabulated(), gen_true(), html_print, html_print_entity_full(), and NL.

Referenced by html_prettyprint().

Here is the call graph for this function:

Here is the caller graph for this function:

inegalite_debug()

void inegalite_debug

(

Pcontrainte

c

)

Definition at line 53 of file constraint_to_text.c.

{
  inegalite_fprint(stderr, c, (get_variable_name_t) entity_local_name);
}

References entity_local_name(), and inegalite_fprint().

Here is the call graph for this function:

inegalite_text_format()

string inegalite_text_format	(	string	,
		string	,
		text	,
		Pcontrainte	,
		string(*)(void)	,
		bool	,
		bool
	)

init_prettyprint()

void init_prettyprint

(

text(*)(entity, int, statement)

hook

)

checks that the prettyprint hook was actually reset...

Definition at line 231 of file misc.c.

                                                           {
  pips_assert("prettyprint hook not set", text_statement_hook==empty_text);
  text_statement_hook = hook;
}

References empty_text(), pips_assert, and text_statement_hook.

Referenced by generic_print_code_pv(), get_any_comp_regions_text(), get_continuation_condition_text(), get_semantic_text(), print_code_or_source(), print_code_or_source_comp(), print_code_points_to(), print_code_static_control(), print_parallelized_code_common(), print_parallelizedCMF_code(), print_parallelizedCRAFT_code(), store_new_module(), text_code_points_to(), text_code_reductions(), and wp65().

Here is the call graph for this function:

Here is the caller graph for this function:

init_text_statement()

text init_text_statement	(	entity	module,
		int	margin,
		statement	obj
	)

exported for unstructured.c

FI: before calling the hook, statement_ordering(obj) should be checked

Parameters

module	odule
margin	argin
obj	bj

Definition at line 3462 of file misc.c.

{
    instruction i = statement_instruction(obj);
    text r;
 
    if (get_bool_property("PRETTYPRINT_ALL_EFFECTS")
        || !((instruction_block_p(i) &&
              !get_bool_property("PRETTYPRINT_BLOCKS")) ||
             (instruction_unstructured_p(i) &&
              !get_bool_property("PRETTYPRINT_UNSTRUCTURED")))) {
      /* FI: before calling the hook,
       * statement_ordering(obj) should be checked */
        r = (*text_statement_hook)( module, margin, obj );
        if (text_statement_hook != empty_text)
            attach_decoration_to_text(r);
    }
    else
        r  = make_text( NIL ) ;
 
    if (get_bool_property("PRETTYPRINT_ALL_EFFECTS") ||
        get_bool_property("PRETTYPRINT_STATEMENT_ORDERING")) {
        char *buffer;
        int so = statement_ordering(obj) ;
 
        if (!(instruction_block_p(statement_instruction(obj)) &&
              (! get_bool_property("PRETTYPRINT_BLOCKS")))) {
          if (so != STATEMENT_ORDERING_UNDEFINED)
            asprintf(&buffer, "%s (%d,%d)\n", get_comment_sentinel(),
                     ORDERING_NUMBER(so), ORDERING_STATEMENT(so));
          else
            asprintf(&buffer, "%s (statement ordering unavailable)\n",
                     get_comment_sentinel());
          ADD_SENTENCE_TO_TEXT(r, make_sentence(is_sentence_formatted,
                                                buffer));
        }
    }
    return( r ) ;
}

References ADD_SENTENCE_TO_TEXT, asprintf, attach_decoration_to_text(), buffer, empty_text(), get_bool_property(), get_comment_sentinel(), instruction_block_p, instruction_unstructured_p, is_sentence_formatted, make_sentence(), make_text(), module, NIL, ORDERING_NUMBER, ORDERING_STATEMENT, statement_instruction, statement_ordering, STATEMENT_ORDERING_UNDEFINED, and text_statement_hook.

Referenced by text_trail().

Here is the call graph for this function:

Here is the caller graph for this function:

initialize_previously_declared_entities()

list initialize_previously_declared_entities

(

entity

)

Referenced by ensure_comment_consistency().

Here is the caller graph for this function:

insure_return_as_last_statement()

void insure_return_as_last_statement	(	entity	,
		statement *
	)

Referenced by ensure_comment_consistency().

Here is the caller graph for this function:

last_statement()

statement last_statement

(

statement

s

)

A simplified version of find_last_statement() located in prettyprint.c and designed to be used within the prettyprinter.

Hopefully it is a return statement. Since the semantics of STOP is ignored by the parser, a final STOp should be followed by a RETURN.

Definition at line 168 of file statement.c.

{
    statement last = statement_undefined;
 
    pips_assert("statement is defined", !statement_undefined_p(s));
 
    if(statement_sequence_p(s)) {
        list ls = instruction_block(statement_instruction(s));
 
        last = (ENDP(ls)? statement_undefined :
                last_statement(STATEMENT(CAR(gen_last(ls)))));
    }
    else if(statement_unstructured_p(s)) {
        unstructured u = statement_unstructured(s);
        list trail = unstructured_to_trail(u);
 
        last = control_statement(CONTROL(CAR(trail)));
 
        gen_free_list(trail);
    }
    else if(statement_call_p(s)) {
        /* Hopefully it is a return statement.
         * Since the semantics of STOP is ignored by the parser, a
         * final STOp should be followed by a RETURN.
         */
        last = s;
    }
    else if(statement_goto_p(s))
      last = s;
    else if(statement_expression_p(s))
      last = s;
    else if(statement_loop_p(s))
      last = s;
    else if(statement_whileloop_p(s))
      last = s;
    else if(statement_forloop_p(s))
      last = s;
 
    return last;
}

References CAR, CONTROL, control_statement, ENDP, gen_free_list(), gen_last(), instruction_block, last_statement(), pips_assert, STATEMENT, statement_call_p(), statement_expression_p(), statement_forloop_p(), statement_goto_p(), statement_instruction, statement_loop_p(), statement_sequence_p(), statement_undefined, statement_undefined_p, statement_unstructured(), statement_unstructured_p(), statement_whileloop_p(), and unstructured_to_trail().

Referenced by compile_omp(), FixCReturnStatements(), last_statement(), and step_compile_analysed_module().

Here is the call graph for this function:

Here is the caller graph for this function:

last_statement_p()

bool last_statement_p

(

statement

)

Referenced by ensure_comment_consistency().

Here is the caller graph for this function:

make_text_resource()

bool make_text_resource	(	const char *	mod_name,
		const char *	res_name,
		const char *	file_ext,
		text	texte
	)

print.c

print.c

generate resource res_name for module mod_name with prefix file_ext as the text provided. it should be made clear who is to free the texte structure. currently it looks like a massive memory leak.

Parameters

mod_name	od_name
res_name	module name
file_ext	resource name [DBR_...]
texte	file extension text to be printed as this resource

Definition at line 55 of file print.c.

{
    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);
 
    fd = safe_fopen(filename, "w");
    debug_on("PRETTYPRINT_DEBUG_LEVEL");
    print_text(fd, texte);
    debug_off();
    safe_fclose(fd, filename);
 
    DB_PUT_FILE_RESOURCE(res_name, mod_name, localfilename);
    write_an_attachment_file(filename);
    free(filename);
 
    return true;
}

References concatenate(), db_build_file_resource_name(), db_get_current_workspace_directory(), DB_PUT_FILE_RESOURCE, debug_off, debug_on, free(), print_text(), safe_fclose(), safe_fopen(), strdup(), and write_an_attachment_file().

Referenced by make_text_resource_and_free(), print_aliases(), print_code_or_source(), print_code_semantics(), print_code_static_control(), print_code_with_comp_regions(), print_parallelized_code_common(), print_parallelizedCMF_code(), print_parallelizedCRAFT_code(), store_new_module(), and wp65().

Here is the call graph for this function:

Here is the caller graph for this function:

make_text_resource_and_free()

bool make_text_resource_and_free	(	const char *	mod_name,
		const char *	res_name,
		const char *	file_ext,
		text	t
	)

Parameters

mod_name	od_name
res_name	es_name
file_ext	ile_ext

Definition at line 82 of file print.c.

{
    bool ok = make_text_resource(mod_name, res_name, file_ext, t);
    free_text(t);
    return ok;
}

References free_text(), make_text_resource(), and ok.

Referenced by create_HRE_module(), generic_print_code_pv(), print_any_reductions(), print_code_or_source_comp(), print_code_points_to(), print_continuation_conditions(), print_initial_precondition(), print_program_precondition(), ProcessEntries(), and ProcessEntry().

Here is the call graph for this function:

Here is the caller graph for this function:

maxima_simplify()

bool maxima_simplify

(

expression *

presult

)

call maxima to simplify an expression prefer simplify_expression !

try to call maxima to simplify this expression

strip out banner

look for first %

skip the three next chars

parse the output

Parameters

presult

result

Definition at line 180 of file expression.c.

                                          {
    bool success = true;
    expression result = *presult;
    /* try to call maxima to simplify this expression */
    if(!expression_undefined_p(result) ) {
      list pdl = NIL;
      list w = words_expression(result,&pdl);
      gen_free_list(pdl);
        string str = words_to_string(w);
        gen_free_list(w);
        char * cmd;
        asprintf(&cmd,"maxima -q --batch-string \"string(fullratsimp(%s));\"\n",str);
        free(str);
        FILE* pout = popen(cmd,"r");
        if(pout) {
            /* strip out banner */
            fgetc(pout);fgetc(pout);
            /* look for first % */
            while(!feof(pout) && fgetc(pout)!='%');
            if(!feof(pout)) {
                /* skip the three next chars */
                fgetc(pout);fgetc(pout);fgetc(pout);
                /* parse the output */
                char bufline[strlen(cmd)];
                if(fscanf(pout," %s\n",&bufline[0]) == 1 ) {
                    expression exp = string_to_expression(bufline,get_current_module_entity());
                    if(!expression_undefined_p(exp)) {
                        free_expression(result);
                        *presult=exp;
                    }
                    else
                        success= false;
                }
            }
            else
                success= false;
            pclose(pout);
        }
        else
            success= false;
        free(cmd);
    }
    return success;
}

References asprintf, exp, expression_undefined_p, free(), free_expression(), gen_free_list(), get_current_module_entity(), NIL, string_to_expression(), words_expression(), and words_to_string().

Here is the call graph for this function:

one_liner_p()

bool one_liner_p

(

statement

s

)

True is statement "s" can be printed out without enclosing braces when it is the true branch of a test.

This is a special case because of dangling else clauses. bool one_liner_true_branch_p(statement s) { bool one_p = false; if(!statement_test_p(s)) one_p = one_liner_p(s); else { test t = instruction_test(statement_instruction(s)); statement f = test_false(t); if(!(empty_statement_p(f) || nop_statement_p(f))) one_p = true; // No need to worry, the else clause exists else { // Make sure there is no internal dangling else... one_p = one_liner_test_p(t); } } return one_p; }

True is test "t" contains a non-empty final "else" clause. bool one_liner_test_p(test t) { bool one_liner_p = false; /* We must make sure that the final else clause is not empty *\/ statement f = test_false(t); if(empty_statement_p(f) || nop_statement_p(f)) one_liner_p = false; else if(statement_test_p(f)) { /* Go down recursively for "else if" constructs. *\/ instruction i = statement_instruction(f); test ft = instruction_test(i); one_liner_p = one_liner_test_p(ft); } else one_liner_p = true; return one_liner_p; }

Can this statement be printed on one line, without enclosing braces, if it is embedded in a loop?

Another test must be used if Statement "s" is embedded in a test a a true branch.

There may be many lines hidden behind another block construct when code is generated in a non canonical way as for {{x=1;y=2;}}

OK, we could check deeper, but this is only useful for redundant internal representations. Let's forget about niceties such as skipping useless braces.

Definition at line 301 of file misc.c.

{
  instruction i = statement_instruction(s);
  bool yes = (instruction_test_p(i) || instruction_loop_p(i) || instruction_whileloop_p(i)
              || instruction_call_p(i) || instruction_expression_p(i) || instruction_forloop_p(i) || instruction_goto_p(i)
              || return_instruction_p(i));
 
  yes = yes && ENDP(statement_declarations(s));
 
  if(!yes && instruction_sequence_p(i)) {
    list sl = sequence_statements(instruction_sequence(i));
    int sc = gen_length(sl);
 
    if(sc==1) {
      /* There may be many lines hidden behind another block construct
         when code is generated in a non canonical way as for
         {{x=1;y=2;}} */
      instruction ii = statement_instruction(STATEMENT(CAR(sl)));
 
      if(instruction_sequence_p(ii)) {
        /* OK, we could check deeper, but this is only useful for
           redundant internal representations. Let's forget about
           niceties such as skipping useless braces. */
        yes = false;
      }
      else
        yes = ENDP(statement_declarations(s));
    }
    else
      yes = (sc < 1) && ENDP(statement_declarations(s));
  }
 
  return yes;
}

References CAR, ENDP, gen_length(), instruction_call_p, instruction_expression_p, instruction_forloop_p, instruction_goto_p, instruction_loop_p, instruction_sequence, instruction_sequence_p, instruction_test_p, instruction_whileloop_p, return_instruction_p(), sequence_statements, STATEMENT, statement_declarations, and statement_instruction.

Referenced by ensure_comment_consistency(), gcc_if_block_braces_required_p(), text_block_else(), text_block_elseif(), text_block_ifthen(), text_loop_default(), text_trail(), and text_whileloop().

Here is the call graph for this function:

Here is the caller graph for this function:

output_a_graph_view_of_the_unstructured()

void output_a_graph_view_of_the_unstructured	(	text	,
		entity	,
		const char *	,
		int	,
		unstructured	,
		int
	)

Referenced by ensure_comment_consistency(), and text_unstructured().

Here is the caller graph for this function:

output_a_graph_view_of_the_unstructured_from_a_control()

bool output_a_graph_view_of_the_unstructured_from_a_control	(	text	,
		entity	,
		int	,
		control	,
		control
	)

Referenced by ensure_comment_consistency().

Here is the caller graph for this function:

output_a_graph_view_of_the_unstructured_successors()

void output_a_graph_view_of_the_unstructured_successors	(	text	,
		entity	,
		int	,
		control
	)

Referenced by ensure_comment_consistency().

Here is the caller graph for this function:

parsed_symbol_table()

bool parsed_symbol_table

(

const char *

module_name

)

bool c_symbol_table(const char* module_name)

{ set_prettyprint_language_tag(is_language_c); //all the way down to words_basic() actual_symbol_table_dump(module_name, false); return true; } bool fortran_symbol_table(const char* module_name) { actual_symbol_table_dump(module_name, true); return true; } To replace c_symbol_table() and fortran_symbol_table() because the information about the language is available in the symbol table.

This the symbol table is never duplicated, this function's output is correct only if the controlizer has not been applied.

Parameters

module_name

odule_name

Definition at line 665 of file symbol_table.c.

{
  actual_symbol_table_dump(module_name, true);
  return true;
}

References actual_symbol_table_dump(), and module_name().

Here is the call graph for this function:

pragma_to_string()

string pragma_to_string

(

pragma

p

)

Returns

a new allocated string with the pragma textual representation.

Definition at line 69 of file pragma.c.

                            {
  bool flg   = false;
  list l_str = NULL; //list of string
  list l_expr = NULL; // list of expression
  size_t line_sz = 0; // the pragma line size
  string s = string_undefined;
  string_buffer sb = string_buffer_make(false);
 
  switch(pragma_tag (p)) {
    case is_pragma_string:
      s = pragma_string(p);
      break;
    case is_pragma_expression:
      l_expr = gen_nreverse(pragma_expression (p));
      FOREACH (EXPRESSION, e, l_expr)
      {
        if(flg ) {
          string_buffer_append(sb, strdup(" "));
          line_sz += 1;
        }
        flg = true;
        list pdl = NIL;
        l_str = words_expression(e, &pdl);
        gen_free_list(pdl);
        //      l_str = gen_nreverse (l_str);
        if(prettyprint_language_is_fortran_p()) {
          // In fortran line size can not be more than 72
          FOREACH (STRING, str, l_str)
          {
            pips_assert ("algo bug", line_sz < MAX_LINE_LENGTH - 7);
            size_t size = strlen(str);
            pips_assert ("not handled case need to split the str between two lines",
                size < (MAX_LINE_LENGTH - 7));
            line_sz += size;
            if(line_sz >= MAX_LINE_LENGTH - 8) {
              l_str = gen_insert_before(strdup(FORTRAN_OMP_CONTINUATION_STRING),
                                        str,
                                        l_str);
              line_sz = size;
            }
          }
        }
        string_buffer_append_list(sb, l_str);
        gen_free_list(l_str);
      }
      s = string_buffer_to_string(sb);
      // Free the buffer with its strings
      string_buffer_free_all(&sb);
      // restore the list as it was at the begining
      gen_nreverse(l_expr);
      break;
    default:
      pips_internal_error("Unknown pragma type");
      break;
  }
  if(s != string_undefined) {
    switch(get_prettyprint_language_tag()) {
      case is_language_fortran:
      case is_language_fortran95:
        s = strdup(concatenate(FORTRAN_PRAGMA_HEADER_STRING, s, NULL));
        break;
      case is_language_c:
        s = strdup(concatenate(C_PRAGMA_HEADER_STRING, " ", s, NULL));
        break;
      default:
        pips_internal_error("Language unknown !");
        break;
    }
  }
  return s;
}

References C_PRAGMA_HEADER_STRING, concatenate(), EXPRESSION, FOREACH, FORTRAN_OMP_CONTINUATION_STRING, FORTRAN_PRAGMA_HEADER_STRING, gen_free_list(), gen_insert_before(), gen_nreverse(), get_prettyprint_language_tag(), is_language_c, is_language_fortran, is_language_fortran95, is_pragma_expression, is_pragma_string, MAX_LINE_LENGTH, NIL, pips_assert, pips_internal_error, pragma_expression, pragma_string, pragma_tag, prettyprint_language_is_fortran_p(), strdup(), STRING, string_buffer_append(), string_buffer_append_list(), string_buffer_free_all(), string_buffer_make(), string_buffer_to_string(), string_undefined, and words_expression().

Referenced by add_expr_to_pragma_expr_list(), build_omp_pragma_list(), build_outer(), extension_to_string(), inner_rewrite(), and pragma_scmp_task_p().

Here is the call graph for this function:

Here is the caller graph for this function:

print_code()

bool print_code

(

const

string

)

Parameters

string

od_name

Definition at line 272 of file print.c.

{
  is_user_view = false;
  return print_code_or_source(mod_name);
}

References is_user_view, and print_code_or_source().

Referenced by print_code_as_a_graph().

Here is the call graph for this function:

Here is the caller graph for this function:

print_code_as_a_graph()

bool print_code_as_a_graph

(

const string

mod_name

)

print_code_as_a_graph.c

print_code_as_a_graph.c

Ronan.nosp@m..Ker.nosp@m.yell@.nosp@m.cri..nosp@m.ensmp.nosp@m..fr, 5/09/1995.

Parameters

mod_name

od_name

Definition at line 47 of file print_code_as_a_graph.c.

{
    bool success;
 
    set_bool_property("PRETTYPRINT_UNSTRUCTURED_AS_A_GRAPH", true);
    success = print_code(mod_name);
    set_bool_property("PRETTYPRINT_UNSTRUCTURED_AS_A_GRAPH", false);
 
    return success;
}

References print_code(), and set_bool_property().

Here is the call graph for this function:

print_code_or_source()

bool print_code_or_source

(

string

mod_name

)

Generic function to prettyprint some sequential or parallel code, or even user view for the given module.

FI: This test could be moved up in pipsmake?

FI: Should be a pips_internal_error() as pipsmake is here to avoid this very problem...

Since we want to prettyprint with a sequential syntax, save the PRETTYPRINT_PARALLEL property that may select the parallel output style before overriding it:

Select the default prettyprint style for sequential prettyprint:

Restore the previous PRETTYPRINT_PARALLEL property for the next parallel code prettyprint:

Parameters

mod_name

od_name

Definition at line 103 of file print.c.

                                           {
  bool success = false;
  text r = make_text(NIL);
  entity module;
  statement mod_stat;
  string pp;
  bool print_graph_p = get_bool_property("PRETTYPRINT_UNSTRUCTURED_AS_A_GRAPH");
  string resource_name =
      strdup(print_graph_p ? DBR_GRAPH_PRINTED_FILE
                           : (is_user_view ? DBR_PARSED_PRINTED_FILE
                                           : DBR_PRINTED_FILE));
  string file_ext = string_undefined;
 
  /* FI: This test could be moved up in pipsmake? */
  if(entity_undefined_p(module = module_name_to_entity(mod_name))) {
    /* FI: Should be a pips_internal_error() as pipsmake is here to
     avoid this very problem... */
    pips_user_error("Module \"\%s\"\n not found", mod_name);
    return false;
  }
 
  /*
   * Set the current language
   */
  value mv = entity_initial(module);
  if(value_code_p(mv)) {
    code c = value_code(mv);
    set_prettyprint_language_from_property(language_tag(code_language(c)));
  }
 
  switch(get_prettyprint_language_tag()) {
    case is_language_fortran:
      file_ext = strdup(concatenate(is_user_view ? PRETTYPRINT_FORTRAN_EXT
                                                 : PREDICAT_FORTRAN_EXT,
                                    print_graph_p ? GRAPH_FILE_EXT : "",
                                    NULL));
      break;
    case is_language_c:
      file_ext = strdup(concatenate(is_user_view ? PRETTYPRINT_C_EXT
                                                 : PREDICAT_C_EXT,
                                    print_graph_p ? GRAPH_FILE_EXT : "",
                                    NULL));
      break;
    case is_language_fortran95:
      file_ext = strdup(concatenate(is_user_view ? PRETTYPRINT_F95_EXT
                                                 : PREDICAT_F95_EXT,
                                    print_graph_p ? GRAPH_FILE_EXT : "",
                                    NULL));
      break;
    default:
      pips_internal_error("Language unknown !");
      break;
  }
 
  set_current_module_entity(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"));
 
  mod_stat = (statement)db_get_memory_resource(is_user_view ? DBR_PARSED_CODE
                                                            : DBR_CODE,
                                               mod_name,
                                               true);
 
  set_current_module_statement(mod_stat);
 
  debug_on("PRETTYPRINT_DEBUG_LEVEL");
 
  begin_attachment_prettyprint();
  init_prettyprint(empty_text);
  MERGE_TEXTS(r, text_module(module,mod_stat));
  success = make_text_resource(mod_name, resource_name, file_ext, r);
  end_attachment_prettyprint();
 
  debug_off();
 
  /* Restore the previous PRETTYPRINT_PARALLEL property for the next
   parallel code prettyprint: */
  set_string_property("PRETTYPRINT_PARALLEL", pp);
  free(pp);
 
  reset_current_module_entity();
  reset_current_module_statement();
 
  free_text(r);
  free(resource_name);
  free(file_ext);
 
  return success;
}

References begin_attachment_prettyprint(), code_language, concatenate(), db_get_memory_resource(), debug_off, debug_on, empty_text(), end_attachment_prettyprint(), entity_initial, entity_undefined_p, free(), free_text(), get_bool_property(), get_prettyprint_language_tag(), get_string_property(), init_prettyprint(), is_language_c, is_language_fortran, is_language_fortran95, is_user_view, language_tag, make_text(), make_text_resource(), MERGE_TEXTS, mod_stat, module, module_name_to_entity(), NIL, pips_internal_error, pips_user_error, reset_current_module_entity(), reset_current_module_statement(), resource_name, set_current_module_entity(), set_current_module_statement(), set_prettyprint_language_from_property(), set_string_property(), strdup(), string_undefined, text_module(), value_code, and value_code_p.

Referenced by print_code(), and print_source().

Here is the call graph for this function:

Here is the caller graph for this function:

print_dummy()

void print_dummy

(

dummy

d

)

Display a "dummy" on stderr, useful for debugging.

Parameters

d	is the dummy to display

Definition at line 93 of file parameter.c.

                          {
  if(!dummy_defined_p(d)) {
    fprintf(stderr, "DUMMY UNDEFINED\n");
  } else {
    fprintf(stderr, "%s",entity_name(dummy_identifier(d)));
  }
}

References dummy_defined_p(), dummy_identifier, entity_name, and fprintf().

Referenced by print_parameter().

Here is the call graph for this function:

Here is the caller graph for this function:

print_entity_variable()

void print_entity_variable

(

entity

e

)

entity.c

entity.c

if it is just a variable, the type is printed, otherwise just the entity name is printed

Definition at line 56 of file entity.c.

{
    variable v;
 
    (void) fprintf(stderr,"name: %s\n",entity_name(e));
 
    if (!type_variable_p(entity_type(e)))
        return;
 
    v = type_variable(entity_type(e));
 
    fprintf(stderr,"basic %s\n",basic_to_string(variable_basic(v)));
    gen_map((gen_iter_func_t) print_dimension, variable_dimensions(v));
}

References basic_to_string(), entity_name, entity_type, fprintf(), gen_map(), print_dimension(), type_variable, type_variable_p, variable_basic, and variable_dimensions.

Referenced by apply_abstract_effect_to_transformer(), call_to_transformer(), copy_write_statement_with_cumulated_regions(), entity_in_ref(), generic_apply_effect_to_transformer(), make_send_receive_conversion(), prepare_context(), print_ctx(), print_ctx_task(), print_distributed_arrays(), print_processors(), print_templates(), and regenerate_toggles().

Here is the call graph for this function:

Here is the caller graph for this function:

print_expression()

void print_expression

(

expression

e

)

no file descriptor is passed to make is easier to use in a debugging stage.

Do not make macros of those printing functions

Definition at line 58 of file expression.c.

{
  if(e==expression_undefined)
    (void) fprintf(stderr,"EXPRESSION UNDEFINED\n");
  // For debugging with gdb, dynamic type checking
  else if(expression_domain_number(e)!=expression_domain)
    (void) fprintf(stderr,"Arg. \"e\"is not an expression.\n");
  else {
    normalized n;
    (void) fprintf(stderr,"syntax = ");
    print_syntax(expression_syntax(e));
    (void) fprintf(stderr,"\nnormalized = ");
    if((n=expression_normalized(e))!=normalized_undefined)
      print_normalized(n);
    else
      (void) fprintf(stderr,"NORMALIZED UNDEFINED\n");
  }
}

References expression_domain, expression_domain_number, expression_normalized, expression_syntax, expression_undefined, fprintf(), normalized_undefined, print_normalized(), and print_syntax().

Referenced by abc_with_allocation_size(), affine_expression_of_loop_index_p(), alias_check_array_and_scalar_variable_in_caller_flt(), alias_check_array_variable_in_caller_flt(), any_basic_update_to_transformer(), any_expression_to_transformer(), array_size_stride(), atom_cse_expression(), atomize_this_expression(), bottom_up_abc_base_reference_implied_do(), bottom_up_abc_reference(), call_rwt(), copy_from_statement(), copy_from_test(), copy_to_statement(), copy_to_test(), cse_expression_flt(), debug_cost_expression_array(), dprint(), expr_cse_flt(), expression_equal_in_context_p(), expression_in_array_subscript(), expression_less_than_in_context(), expression_substitute_variable(), expression_to_points_to_sources(), find_entities_to_wrap(), formal_variable_add_aliases(), gfc2pips_code2instruction_(), Hierarchical_tiling(), HpfcExpressionToInt(), impact_check_two_scalar_variables_in_path(), integer_expression_to_transformer(), interprocedural_abc_arrays(), invariant_expression_p(), loop_flt(), loop_strip_mine(), make_list_of_flags(), make_send_receive_conversion(), MakeDimension(), MemberIdentifierToExpression(), partial_eval_reference(), pointer_expression_to_transformer(), print_alias_association(), print_alignment(), print_dimension(), print_distribution(), print_eformat(), print_expressions(), proper_to_summary_simple_effect(), ram_variable_add_aliases(), remove_minmax(), rename_statement_declarations(), same_or_equivalence_argument_add_aliases(), size_of_dummy_array(), split_update_call(), store_initial_value(), subscript_value(), substitute_and_create(), substitute_ghost_variable_in_expression(), Tiling_buffer_allocation(), top_down_abc_array(), top_down_abc_call(), transformer_add_condition_information_updown(), transformer_add_integer_relation_information(), translate_to_module_frame(), verify_array_element(), verify_used_before_set_call(), and verify_used_before_set_expression().

Here is the call graph for this function:

print_expressions()

void print_expressions

(

list

le

)

Parameters

le

e

Definition at line 98 of file expression.c.

{
 
  MAP(EXPRESSION, e , {
    print_expression(e);
      },
    le);
 
}

References EXPRESSION, MAP, and print_expression().

Referenced by add_prettyprint_control_list_to_declaration_statement(), dprint(), MakeFunctionExpression(), outliner_parameters(), and verify_used_before_set_call().

Here is the call graph for this function:

Here is the caller graph for this function:

print_loops_list()

void print_loops_list	(	entity	mod,
		list	sl
	)

Parameters

mod	od
sl	l

Definition at line 79 of file loop.c.

{
  FOREACH(LOOP, l, sl) {
    list pdl = NIL;
    text t = text_loop(mod, entity_name(loop_label(l)), 2, l, 0, &pdl, true);
    gen_free_list(pdl);
    print_text(stderr,t);
  }
}

References entity_name, FOREACH, gen_free_list(), LOOP, loop_label, NIL, print_text(), and text_loop().

Here is the call graph for this function:

print_mode()

void print_mode

(

mode

m

)

Display a "mode" on stderr, useful for debugging.

Parameters

p	is the mode to display

Definition at line 76 of file parameter.c.

                        {
  if(!mode_defined_p(m)) {
    fprintf(stderr, "MODE UNDEFINED\n");
  } else if( mode_value_p(m)) {
    fprintf(stderr, "value");
  } else if( mode_reference_p(m)) {
    fprintf(stderr, "reference");
  } else {
    fprintf(stderr, "unknown");
  }
}

References fprintf(), mode_defined_p(), mode_reference_p, and mode_value_p.

Referenced by print_parameter().

Here is the call graph for this function:

Here is the caller graph for this function:

print_normalized()

void print_normalized

(

normalized

n

)

should be replaced by a call to expression_fprint() if it's ever added to linear library

Definition at line 168 of file expression.c.

{
    if(normalized_complex_p(n))
        (void) fprintf(stderr,"COMPLEX\n");
    else
        /* should be replaced by a call to expression_fprint() if it's
           ever added to linear library */
        vect_debug((Pvecteur)normalized_linear(n));
}

References fprintf(), normalized_complex_p, normalized_linear, and vect_debug().

Referenced by print_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

print_number_to_statement()

void print_number_to_statement

(

hash_table

nts

)

Parameters

nts

ts

Definition at line 209 of file statement.c.

{
    HASH_MAP(number, stmt, {
        fprintf(stderr,"%td\t", (_int) number);
        print_statement((statement) stmt);
    }, nts);
}

References fprintf(), HASH_MAP, nts, and print_statement().

Referenced by get_any_comp_regions_text(), get_continuation_condition_text(), and get_semantic_text().

Here is the call graph for this function:

Here is the caller graph for this function:

print_parallel_statement()

void print_parallel_statement

(

statement

s

)

Definition at line 156 of file statement.c.

{
  string cstyle = strdup(get_string_property(PRETTYPRINT_PARALLEL));
  set_string_property(PRETTYPRINT_PARALLEL, "doall");
  print_statement(s);
  set_string_property(PRETTYPRINT_PARALLEL, cstyle);
  free(cstyle);
}

References free(), get_string_property(), PRETTYPRINT_PARALLEL, print_statement(), set_string_property(), and strdup().

Referenced by CodeGenerate(), do_it(), MakeLoopAs(), rice_loop(), and rice_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

print_parallelized77_code()

bool print_parallelized77_code

(

const

string

)

Parameters

string

od_name

Definition at line 294 of file print.c.

{
    return print_parallelized_code_common(mod_name, "doall");
}

References print_parallelized_code_common().

Here is the call graph for this function:

print_parallelized90_code()

bool print_parallelized90_code

(

const

string

)

Parameters

string

od_name

Definition at line 289 of file print.c.

{
    return print_parallelized_code_common(mod_name, "f90");
}

References print_parallelized_code_common().

Here is the call graph for this function:

print_parallelized_code()

bool print_parallelized_code

(

const

string

)

Parameters

string

od_name

Definition at line 284 of file print.c.

{
    return print_parallelized_code_common(mod_name, NULL);
}

References print_parallelized_code_common().

Here is the call graph for this function:

print_parallelizedHPF_code()

bool print_parallelizedHPF_code

(

const

string

)

Parameters

string

odule_name

Definition at line 299 of file print.c.

{
    return print_parallelized_code_common(module_name, "hpf");
}

References module_name(), and print_parallelized_code_common().

Here is the call graph for this function:

print_parallelizedMPI_code()

bool print_parallelizedMPI_code

(

const

string

)

Parameters

string

od_name

Definition at line 314 of file print.c.

{
  return print_parallelized_code_common(mod_name, "mpi");
}

References print_parallelized_code_common().

Here is the call graph for this function:

print_parallelizedOMP_code()

bool print_parallelizedOMP_code

(

const

string

)

Parameters

string

od_name

Definition at line 306 of file print.c.

{
    if (get_bool_property(all_priv))
        pips_user_warning("avoid property " all_priv "=TRUE with OMP\n");
 
    return print_parallelized_code_common(mod_name, "omp");
}

References all_priv, get_bool_property(), pips_user_warning, and print_parallelized_code_common().

Here is the call graph for this function:

print_parameter()

void print_parameter

(

parameter

p

)

parameter.c

parameter.c

Parameters

p	is the parameter to display

Definition at line 45 of file parameter.c.

                                  {
  if(p == parameter_undefined) {
    fprintf(stderr, "PARAMETER UNDEFINED\n");
  } else {
    fprintf(stderr, "type = ");
    print_type(parameter_type(p));
    fprintf(stderr, "\nmode= ");
    print_mode(parameter_mode(p));
    fprintf(stderr, "\ndummy= ");
    print_dummy(parameter_dummy(p));
    fprintf(stderr, "\n");
  }
}

References fprintf(), parameter_dummy, parameter_mode, parameter_type, parameter_undefined, print_dummy(), print_mode(), and print_type().

Referenced by print_parameters().

Here is the call graph for this function:

Here is the caller graph for this function:

print_parameters()

void print_parameters

(

list

lp

)

Display a parameter on stderr, useful for debugging.

Parameters

lp	is the list of parameters to display

Parameters

lp

p

Definition at line 63 of file parameter.c.

                               {
  FOREACH(PARAMETER, p , lp)
  {
    print_parameter(p);
  }
}

References FOREACH, PARAMETER, and print_parameter().

Referenced by outliner_parameters().

Here is the call graph for this function:

Here is the caller graph for this function:

print_qualifier()

void print_qualifier

(

qualifier

q

)

Definition at line 138 of file type.c.

{
  list ql = CONS(QUALIFIER, q, NIL);
  print_qualifiers(ql);
  gen_free_list(ql);
}

References CONS, gen_free_list(), NIL, print_qualifiers(), and QUALIFIER.

Referenced by dprint().

Here is the call graph for this function:

Here is the caller graph for this function:

print_qualifiers()

void print_qualifiers

(

list

ql

)

Parameters

ql

l

Definition at line 131 of file type.c.

{
  list wl = words_qualifiers(ql);
  dump_words(wl);
  gen_full_free_list(wl);
}

References dump_words(), gen_full_free_list(), and words_qualifiers().

Referenced by dprint(), and print_qualifier().

Here is the call graph for this function:

Here is the caller graph for this function:

print_reference()

void print_reference

(

reference

r

)

Definition at line 142 of file expression.c.

{
  fprint_reference(stderr, r);
}

References fprint_reference().

Referenced by align_check(), bottom_up_abc_reference(), build_sc_with_several_uniform_ref(), create_realFifo_proc(), dprint(), entity_in_ref(), entity_in_ref_rwt(), fprint_points_to_cell(), generate_mmcd_stat_from_ref(), make_lInitStats(), make_load_blocks(), make_lSwitchStats(), make_reindex(), make_send_receive_conversion(), make_store_blocks(), Overlap_Analysis(), perform_substitution_in_expression(), phrase_remove_dependences_rwt(), print_or_dump_points_to(), print_reduction(), reference_conflicting_p(), reference_conflicting_test_and_update(), reference_filter(), reference_to_points_to_sinks(), references_for_regions(), remove_write_ref(), rename_statement_reductions(), replace_array_ref_with_fifos2(), simple_indices_p(), some_conflicts_between(), source_to_sinks(), subtsitute_variable_in_reference(), update_indices_for_local_computation(), write_conf_on_ref(), and xml_Chain_Graph().

Here is the call graph for this function:

Here is the caller graph for this function:

print_reference_list()

void print_reference_list

(

list

lr

)

Parameters

lr

r

Definition at line 147 of file expression.c.

{
    if(ENDP(lr))
        fputs("NIL", stderr);
    else
        MAPL(cr,
         {
             reference r = REFERENCE(CAR(cr));
             entity e = reference_variable(r);
             (void) fprintf(stderr,"%s, ", entity_local_name(e));
         },
             lr);
 
    (void) putc('\n', stderr);
}

References CAR, ENDP, entity_local_name(), fprintf(), MAPL, REFERENCE, and reference_variable.

Referenced by call_instruction_to_communications(), loop_nest_to_local_variables(), and print_references().

Here is the call graph for this function:

Here is the caller graph for this function:

print_references()

void print_references

(

list

rl

)

Parameters

rl

l

Definition at line 163 of file expression.c.

{
  print_reference_list(rl);
}

References print_reference_list().

Referenced by dprint(), and UseFormalArguments().

Here is the call graph for this function:

Here is the caller graph for this function:

print_source()

bool print_source

(

const

string

)

Parameters

string

od_name

Definition at line 278 of file print.c.

{
  is_user_view = true;
  return print_code_or_source(mod_name);
}

References is_user_view, and print_code_or_source().

Here is the call graph for this function:

print_statement()

void print_statement

(

statement

s

)

Print a statement on stderr.

Print the statement according to the current PRETTYPRINT_LANGUAGE property

See text_named_module() for improvements.

Definition at line 98 of file statement.c.

{
  fprint_statement(stderr, s);
}

References fprint_statement().

Referenced by abc_instrumentation_insert_before_statement(), add_aliases_for_current_call_site(), adg_dataflowgraph(), adg_dataflowgraph_with_extremities(), assign_statement_task_mapping(), atomize_as_required(), bottom_up_abc_insert_before_statement(), bottom_up_abc_statement_rwt(), build_binary_operators_with_huffman(), c_code_string(), c_unstructured(), call_flt(), call_to_transformer(), comEngine_opt_loop_interchange(), compile_body(), compute_distribution_controlization_context(), compute_region(), connect_unstructured(), controlize_distribution(), copy_n_reference(), copy_n_statement(), copy_write_statement_with_cumulated_regions(), create_module_with_statement(), cse_expression_flt(), ctx_get_send_statement(), da_process_list(), debug_statement(), debug_unstructured(), distribute_code(), do_it(), do_loop_unroll_with_epilogue(), do_loop_unroll_with_prologue(), do_substitute(), dprint(), extract_matching_statements(), extract_non_conflicting_statements(), filter_live_out_regions_statement(), find_statements_interactively_walker(), fprint_bdt_with_stat(), fs_filter(), fsmize_statement(), full_loop_unroll(), full_spaghettify(), full_spaghettify_statement(), generate_code(), generate_code_loop(), generate_code_test_proc(), get_externalized_and_analyzed_function_name(), get_function_name_by_searching_tag(), get_points_to_graph_from_statement(), get_statements_with_comments_containing(), gpu_ify_statement(), gpu_memory_apply(), gpu_promote_sequential_on_sequence(), HRE_distribute(), HRE_distribute_stat(), icm_codegen(), identify_statements_to_distribute(), if_conv_init_statement(), if_conversion_compact_stats(), if_conversion_init(), init_statement_equivalence_table(), initial_code_abc_statement_rwt(), inline_calls(), inline_expression(), inline_expression_call(), inline_statement_crawler(), interprocedural_abc_insert_before_statement(), invariant_code_motion(), is_elsif_test_p(), isolate_code_portion(), loop_strip_mine(), make_array_communication_statement(), make_bottom_up_abc_tests(), make_interprocedural_abc_tests(), make_lInitStats(), make_lSwitchStats(), make_mpi_conversion(), make_send_receive_conversion(), make_statement_copy_i(), make_task_mapping(), mark_loop_to_outline(), mpi_initialize(), opt_loop_interchange_fill_lists(), outliner_patch_parameters(), outliner_statements_referenced_entities(), partial_eval_statement(), phrase_distributor_control_code(), phrase_remove_dependences_rwt(), postcondition_filter(), prepare_context(), prettyprint_dot_dependence_graph(), print_number_to_statement(), print_parallel_statement(), print_statement_of_module(), print_statements(), process_true_call_stat(), reduce_sequence(), reductions_rewrite(), remove_begin_tag(), remove_end_tag(), rename_statement_reductions(), replace_in_sequence_statement_with(), replace_reductions_in_statement(), replicate_declaration(), rice_loop(), rm_db_block(), safe_print_statement(), safescale_distributor(), safescale_module_analysis(), seq_flt(), sequence_to_post_pv(), simdize_simple_statements_pass2(), SimplifyGraph(), smalltalk_code_string(), some_conflicts_between(), spaghettify_statement(), st_statement(), statement_convert_to_statement_with_sequence_of_intruction(), statement_filter(), statement_rewrite(), step_directive_print(), step_update_comm(), store_new_module(), SupressDependances(), taskify_statement(), Tiling2_buffer(), top_down_abc_flt(), top_down_abc_rwt(), variable_private_to_loop_p(), verify_array_element(), verify_array_variable(), verify_scalar_variable(), verify_used_before_set_statement_flt(), wp65_debug_print_text(), and xml_code_string().

Here is the call graph for this function:

print_statement_of_module()

void print_statement_of_module	(	statement	s,
		const char *	mn
	)

Parameters

mn

n

Definition at line 111 of file statement.c.

{
  if(entity_undefined_p(get_current_module_entity())) {
    entity m = local_name_to_top_level_entity(mn);
    set_current_module_entity(m);
    reset_label_counter();
    print_statement(s);
    reset_current_module_entity();
  }
  else
    print_statement(s);
}

References entity_undefined_p, get_current_module_entity(), local_name_to_top_level_entity(), print_statement(), reset_current_module_entity(), reset_label_counter(), and set_current_module_entity().

Here is the call graph for this function:

print_statement_set()

void print_statement_set	(	FILE *	fd,
		set	r
	)

statement.c

Parameters

fd

d

Definition at line 49 of file statement.c.

{
    fprintf(fd, "Set contains statements");
 
    SET_MAP(s, {
        fprintf(fd, " %02td", statement_number((statement) s));
    }, r);
 
    fprintf(fd, "\n");
}

References fprintf(), SET_MAP, and statement_number.

Referenced by CodeGenerate(), rdg_loop(), rice_loop(), and rice_update_dependence_graph().

Here is the call graph for this function:

Here is the caller graph for this function:

print_statements()

void print_statements

(

list

sl

)

Parameters

sl

l

Definition at line 103 of file statement.c.

{
  FOREACH(STATEMENT, s, sl) {
    print_statement(s);
  }
}

References FOREACH, print_statement(), and STATEMENT.

Referenced by dprint(), rename_statement_declarations(), and simdize_simple_statements_pass2().

Here is the call graph for this function:

Here is the caller graph for this function:

print_syntax()

void print_syntax

(

syntax

s

)

Definition at line 121 of file expression.c.

{
  list pdl = NIL;
  print_words(stderr,words_syntax(s, &pdl));
  gen_free_list(pdl);
}

References gen_free_list(), NIL, print_words(), and words_syntax().

Referenced by interprocedural_mapping(), make_send_receive_conversion(), print_expression(), and print_syntax_expressions().

Here is the call graph for this function:

Here is the caller graph for this function:

print_syntax_expressions()

void print_syntax_expressions

(

list

le

)

Parameters

le

e

Definition at line 108 of file expression.c.

{
 
  MAP(EXPRESSION, e , {
    print_syntax(expression_syntax(e));
    if(!ENDP(CDR(le))) {
        (void) fprintf(stderr, ", ");
    }
      },
    le);
 
}

References CDR, ENDP, EXPRESSION, expression_syntax, fprintf(), MAP, and print_syntax().

Here is the call graph for this function:

print_type()

void print_type

(

type

t

)

For debugging.

Definition at line 111 of file type.c.

{
  debug_on("RI-UTIL_DEBUG_LEVEL");
  if(t==NULL)
    fprintf(stderr, "type is NULL.\n");
  else if(type_undefined_p(t))
    fprintf(stderr, "type is undefined.\n");
  else if(type_domain_number(t)!=type_domain)
    fprintf(stderr, "The argument is not a type.\n");
  else {
  // Might be better to pass true, or even more information, to see
  // what happens with the unknown type
  list pdl = NIL;
  list wl = words_type(t, &pdl, false);
  gen_free_list(pdl);
  dump_words(wl);
  }
  debug_off();
}

References debug_off, debug_on, dump_words(), fprintf(), gen_free_list(), NIL, type_domain, type_domain_number, type_undefined_p, and words_type().

Referenced by build_view_file(), create_scalar_stub_sink_cell(), dprint(), entity_all_xxx_locations_typed(), expression_to_points_to_sources(), generic_stub_source_to_sinks(), get_dont_build_view_file(), get_view_file(), gpips_display_plain_file(), print_parameter(), type_dereferencement_depth(), wpips_display_plain_file(), and wpips_display_WP65_file().

Here is the call graph for this function:

Here is the caller graph for this function:

print_types()

void print_types

(

list

tl

)

Very basic and crude debugging function.

Parameters

tl

l

Definition at line 96 of file type.c.

{
  bool first_p = true;
 
  fprintf(stderr, "Type list: ");
 
  FOREACH(TYPE, t, tl) {
    fprintf(stderr, first_p? "%p" : ", %p", t);
    first_p = false;
  }
 
  fprintf(stderr, "\n");
}

References FOREACH, fprintf(), and TYPE.

Referenced by dprint().

Here is the call graph for this function:

Here is the caller graph for this function:

printf_loop()

void printf_loop

(

loop

lp

)

loop.c

loop.c

void fprint_loop(fp, lp): print a loop.

AC 94/06/07 copied from reindexing/reindexing_utils.c for debugging

Parameters

lp

p

Definition at line 48 of file loop.c.

                          {
  FILE *fp = stdout;
 
  fprintf(fp,"\nLoop index information:");
  fprint_entity_list(fp, CONS(ENTITY, loop_index(lp), NIL));
 
  fprintf(fp,"\nDomaine (lower, upper, inc):");
  fprint_list_of_exp(fp,
      CONS(EXPRESSION, range_lower(loop_range(lp)), NIL));
  fprintf(fp,", ");
  fprint_list_of_exp(fp,
      CONS(EXPRESSION, range_upper(loop_range(lp)), NIL));
  fprintf(fp,", ");
  fprint_list_of_exp(fp,
      CONS(EXPRESSION, range_increment(loop_range(lp)), NIL));
 
  fprintf(fp,"\nLabel:");
  fprint_entity_list(fp, CONS(ENTITY, loop_label(lp), NIL));
 
  fprintf(fp,"\nExecution Type");
  if (execution_sequential_p(loop_execution(lp)))
    fprintf(fp, " ->sequentiel");
  else
    fprintf(fp, " ->parallele");
 
  fprintf(fp, "\nLocals: ");
  fprint_entity_list(fp, loop_locals(lp));
 
  fprintf(fp,"\n");
}

References CONS, ENTITY, execution_sequential_p, EXPRESSION, fprint_entity_list(), fprint_list_of_exp(), fprintf(), loop_execution, loop_index, loop_label, loop_locals, loop_range, NIL, range_increment, range_lower, and range_upper.

Referenced by loop_replace_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

proper_statement_to_string()

string proper_statement_to_string

(

statement

)

Referenced by ensure_comment_consistency(), semantics_user_warning_alist(), and spear_log_alist().

Here is the caller graph for this function:

recompile_module()

bool recompile_module

(

const string

module

)

module.c

module.c

Parameters

module

odule

Definition at line 87 of file module.c.

{
    entity modified_module = module_name_to_entity(module);
    statement modified_module_statement =
        (statement) db_get_memory_resource(DBR_CODE, module, true);
    do_recompile_module(modified_module,modified_module_statement);
    return true;
}

References db_get_memory_resource(), do_recompile_module(), module, and module_name_to_entity().

Referenced by do_inlining(), and do_unfolding().

Here is the call graph for this function:

Here is the caller graph for this function:

reference_to_string()

string reference_to_string

(

reference

r

)

Definition at line 87 of file expression.c.

                                        {
    list pdl = NIL;
    list l = words_reference(r,&pdl) ;
    gen_free_list(pdl);
    string out = words_to_string(l);
    FOREACH(STRING,w,l) free(w);
    gen_free_list(l);
    return out;
}

References FOREACH, free(), gen_free_list(), NIL, out, STRING, words_reference(), and words_to_string().

Referenced by adapt_reference_to_type(), add_address_of_value(), analyzed_reference_p(), any_assign_to_transformer(), any_basic_update_to_transformer(), any_update_to_transformer(), attach_ref_to_loop(), basic_update_reflhs_with_rhs_to_transformer(), cell_is_xxx_p(), cell_reference_to_type(), constant_memory_access_path_to_location_name(), convex_cell_reference_preceding_p(), count_dataflows_on_ref(), dereferencing_to_sinks(), extended_source_to_sinks(), filter_formal_context_according_to_actual_context(), forward_substitute_array_location_in_transformer(), fprint_dataflow(), generic_eval_cell_with_points_to(), lhs_subs_in_ins(), new_array_element_backward_substitution_in_transformer(), new_filter_formal_context_according_to_actual_context(), perform_substitution_in_expression(), points_to_cell_name(), points_to_name(), points_to_rank(), points_to_unary_operation_to_transformer(), potential_to_effective_memory_leaks(), print_value_mappings(), print_variables(), process_ref_list(), reduction_as_str(), reference_to_address_entity(), reference_to_address_of_value(), sa_do_it(), semantics_usable_points_to_reference_p(), simple_cell_reference_preceding_p(), simple_pv_translate(), successor_only_has_rr_conflict_p(), and update_reflhs_with_rhs_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

register_intrinsic_handler()

void register_intrinsic_handler	(	const char *	name,
		intrinsic_desc_t *	desc
	)

after this call, name and desc are owned by intrinsic_handlers, but will never be deallocated they must point to permanent storage

Parameters

name	ame
desc	esc

Definition at line 2517 of file misc.c.

                                                                         {
    if(hash_table_undefined_p(intrinsic_handlers)) {
        init_intrinsic_handlers();
    }
    hash_put(intrinsic_handlers,name,desc);
}

References hash_put(), hash_table_undefined_p, init_intrinsic_handlers(), and intrinsic_handlers.

Referenced by step_analyse_init().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_modulo()

expression remove_modulo

(

expression

exp

)

craft.c

craft.c

Parameters

exp

xp

Definition at line 83 of file craft.c.

{
  gen_recurse(exp, expression_domain, gen_true, rewrite_modulo_expression);
 
  return(exp);
}

References exp, expression_domain, gen_recurse, gen_true(), and rewrite_modulo_expression().

Referenced by text_loop_craft().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_alternate_return_set()

void reset_alternate_return_set

(

void

)

Definition at line 804 of file misc.c.

{
  ifdebug(1) {
  pips_assert("The target list is initialized",
              !list_undefined_p(set_of_labels_required_for_alternate_returns));
  }
  gen_free_list(set_of_labels_required_for_alternate_returns);
  set_of_labels_required_for_alternate_returns = list_undefined;
}

References gen_free_list(), ifdebug, list_undefined, list_undefined_p, pips_assert, and set_of_labels_required_for_alternate_returns.

Referenced by ensure_comment_consistency(), fprint_statement(), and statement_to_text().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_last_statement()

void reset_last_statement

(

void

)

Referenced by ensure_comment_consistency().

Here is the caller graph for this function:

reset_prettyprinter_common_hook()

void reset_prettyprinter_common_hook

(

void

)

Definition at line 787 of file declarations2.c.

{
  common_hook=default_common_hook;
}

References common_hook, and default_common_hook().

Referenced by hpfc_print_code().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_prettyprinter_head_hook()

void reset_prettyprinter_head_hook

(

void

)

Definition at line 3964 of file misc.c.

{ head_hook=NULL;}

References head_hook.

Referenced by compile_mpi(), and hpfc_print_code().

Here is the caller graph for this function:

safe_c_words_entity()

list safe_c_words_entity	(	type	t,
		list	name
	)

Ignore the parser declared entities?

Parameters

name

ame

Definition at line 1433 of file declarations.c.

{
  /* Ignore the parser declared entities? */
  list pdl = NIL;
  list l = generic_c_words_entity(t, name, true, false, &pdl);
  gen_free_list(pdl);
  return l;
}

References gen_free_list(), generic_c_words_entity(), and NIL.

Referenced by FindOrCreateCurrentEntity(), UpdateEntity(), and UpdateFunctionEntity().

Here is the call graph for this function:

Here is the caller graph for this function:

safe_print_statement()

void safe_print_statement

(

statement

s

)

The return label only can be associated to a RETURN call, however the controlizer does not follow this consistency rule.

Definition at line 140 of file statement.c.

{
  if(statement_undefined_p(s)) {
    fprintf(stderr, "Statement undefined\n");
  }
  else if(continue_statement_p(s)
     && entity_return_label_p(statement_label(s))) {
    /* The return label only can be associated to a RETURN call,
       however the controlizer does not follow this consistency
       rule. */
    fprintf(stderr, "%s\n", statement_identification(s));
  }
  else
    print_statement(s);
}

References continue_statement_p(), entity_return_label_p(), fprintf(), print_statement(), statement_identification(), statement_label, and statement_undefined_p.

Referenced by check_new_arc_for_structured_statement(), and IsolatedStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

same_application_name_p()

bool same_application_name_p	(	application	a1,
		application	a2
	)

Parameters

a1	1
a2	2

Definition at line 109 of file same_names.c.

{
  return  same_expression_name_p(application_function(a1), application_function(a2)) &&
   same_lexpr_name_p(application_arguments(a1), application_arguments(a2));
}

References application_arguments, application_function, same_expression_name_p(), and same_lexpr_name_p().

Referenced by same_syntax_name_p().

Here is the call graph for this function:

Here is the caller graph for this function:

same_call_name_p()

bool same_call_name_p	(	call	c1,
		call	c2
	)

Parameters

c1	1
c2	2

Definition at line 69 of file same_names.c.

{
  return same_entity_lname_p(call_function(c1), call_function(c2)) &&
    same_lexpr_name_p(call_arguments(c1), call_arguments(c2));
}

References call_arguments, call_function, same_entity_lname_p(), and same_lexpr_name_p().

Referenced by same_syntax_name_p().

Here is the call graph for this function:

Here is the caller graph for this function:

same_cast_name_p()

bool same_cast_name_p	(	cast	cs1,
		cast	cs2
	)

Parameters

cs1	s1
cs2	s2

Definition at line 103 of file same_names.c.

{
  return same_type_name_p(cast_type(cs1), cast_type(cs2)) &&
    same_expression_name_p(cast_expression(cs1), cast_expression(cs2)) ;
}

References cast_expression, cast_type, same_expression_name_p(), and same_type_name_p().

Referenced by same_syntax_name_p().

Here is the call graph for this function:

Here is the caller graph for this function:

same_entity_lname_p()

bool same_entity_lname_p	(	entity	e1,
		entity	e2
	)

Parameters

e1	1
e2	2

Definition at line 64 of file same_names.c.

{
  return same_string_p(entity_local_name(e1), entity_local_name(e2));
}

References entity_local_name(), and same_string_p.

Referenced by inline_should_inline(), outline_remove_duplicates(), same_call_name_p(), same_ref_name_p(), simd_replace_parameters(), and UseFormalArguments().

Here is the call graph for this function:

Here is the caller graph for this function:

same_expression_name_p()

bool same_expression_name_p	(	expression	e1,
		expression	e2
	)

compare two entities for their appearance point of view.

used for putting common in includes.

Parameters

e1	1
e2	2

Definition at line 159 of file same_names.c.

{
  return same_syntax_name_p(expression_syntax(e1), expression_syntax(e2));
}

References expression_syntax, and same_syntax_name_p().

Referenced by same_application_name_p(), same_cast_name_p(), same_lexpr_name_p(), same_range_name_p(), same_sizeofexpression_name_p(), and same_subscript_name_p().

Here is the call graph for this function:

Here is the caller graph for this function:

same_lexpr_name_p()

bool same_lexpr_name_p	(	list	l1,
		list	l2
	)

same_names.c

else

Parameters

l1	1
l2	2

Definition at line 53 of file same_names.c.

{
  if (gen_length(l1)!=gen_length(l2))
    return false;
  /* else */
  for(; l1 && l2; POP(l1), POP(l2))
    if (!same_expression_name_p(EXPRESSION(CAR(l1)), EXPRESSION(CAR(l2))))
      return false;
  return true;
}

References CAR, EXPRESSION, gen_length(), POP, and same_expression_name_p().

Referenced by same_application_name_p(), same_call_name_p(), same_ref_name_p(), and same_subscript_name_p().

Here is the call graph for this function:

Here is the caller graph for this function:

same_range_name_p()

bool same_range_name_p	(	range	r1,
		range	r2
	)

Parameters

r1	1
r2	2

Definition at line 81 of file same_names.c.

{
  return same_expression_name_p(range_lower(r1), range_lower(r2)) &&
    same_expression_name_p(range_upper(r1), range_upper(r2)) &&
    same_expression_name_p(range_increment(r1), range_increment(r2));
}

References range_increment, range_lower, range_upper, and same_expression_name_p().

Referenced by same_syntax_name_p().

Here is the call graph for this function:

Here is the caller graph for this function:

same_ref_name_p()

bool same_ref_name_p	(	reference	r1,
		reference	r2
	)

Parameters

r1	1
r2	2

Definition at line 75 of file same_names.c.

{
  return same_entity_lname_p(reference_variable(r1), reference_variable(r2))
    && same_lexpr_name_p(reference_indices(r1), reference_indices(r2));
}

References reference_indices, reference_variable, same_entity_lname_p(), and same_lexpr_name_p().

Referenced by get_complement_expression(), and same_syntax_name_p().

Here is the call graph for this function:

Here is the caller graph for this function:

same_sizeofexpression_name_p()

bool same_sizeofexpression_name_p	(	sizeofexpression	s0,
		sizeofexpression	s1
	)

Parameters

s0	0
s1	1

Definition at line 88 of file same_names.c.

{
    if(sizeofexpression_type_p(s0) && sizeofexpression_type_p(s1))
        return same_type_name_p(sizeofexpression_type(s0),sizeofexpression_type(s1));
    if(sizeofexpression_expression_p(s0) && sizeofexpression_expression_p(s1))
        return same_expression_name_p(sizeofexpression_expression(s0),sizeofexpression_expression(s1));
    return false;
}

References s1, same_expression_name_p(), same_type_name_p(), sizeofexpression_expression, sizeofexpression_expression_p, sizeofexpression_type, and sizeofexpression_type_p.

Referenced by same_syntax_name_p(), and same_va_arg_name_p().

Here is the call graph for this function:

Here is the caller graph for this function:

same_subscript_name_p()

bool same_subscript_name_p	(	subscript	ss1,
		subscript	ss2
	)

Parameters

ss1	s1
ss2	s2

Definition at line 97 of file same_names.c.

{
  return same_expression_name_p(subscript_array(ss1), subscript_array(ss2)) 
     && same_lexpr_name_p(subscript_indices(ss1), subscript_indices(ss2));
}

References same_expression_name_p(), same_lexpr_name_p(), subscript_array, and subscript_indices.

Referenced by same_syntax_name_p().

Here is the call graph for this function:

Here is the caller graph for this function:

same_syntax_name_p()

bool same_syntax_name_p	(	syntax	s1,
		syntax	s2
	)

else

Parameters

s1	1
s2	2

Definition at line 130 of file same_names.c.

{
  if (syntax_tag(s1)!=syntax_tag(s2))
    return false;
  /* else */
  switch (syntax_tag(s1))
    {
    case is_syntax_call:
      return same_call_name_p(syntax_call(s1), syntax_call(s2));
    case is_syntax_reference:
      return same_ref_name_p(syntax_reference(s1), syntax_reference(s2));
    case is_syntax_range:
      return same_range_name_p(syntax_range(s1), syntax_range(s2));
    case is_syntax_sizeofexpression:
      return same_sizeofexpression_name_p(syntax_sizeofexpression(s1),syntax_sizeofexpression(s2));
    case is_syntax_subscript:
      return same_subscript_name_p(syntax_subscript(s1), syntax_subscript(s2));
    case is_syntax_cast:
      return same_cast_name_p(syntax_cast(s1), syntax_cast(s2));
    case is_syntax_application:
      return same_application_name_p(syntax_application(s1), syntax_application(s2));
    case is_syntax_va_arg:
      return same_va_arg_name_p(syntax_va_arg(s1), syntax_va_arg(s2));
    default:
      pips_internal_error("unexpected syntax tag: %d", syntax_tag(s1));
    }
  return false;
}

References is_syntax_application, is_syntax_call, is_syntax_cast, is_syntax_range, is_syntax_reference, is_syntax_sizeofexpression, is_syntax_subscript, is_syntax_va_arg, pips_internal_error, s1, same_application_name_p(), same_call_name_p(), same_cast_name_p(), same_range_name_p(), same_ref_name_p(), same_sizeofexpression_name_p(), same_subscript_name_p(), same_va_arg_name_p(), syntax_application, syntax_call, syntax_cast, syntax_range, syntax_reference, syntax_sizeofexpression, syntax_subscript, syntax_tag, and syntax_va_arg.

Referenced by same_expression_name_p().

Here is the call graph for this function:

Here is the caller graph for this function:

same_type_name_p()

bool same_type_name_p	(	const type	t0,
		const type	t1
	)

For naming homogeneity: expression_to_string(), reference_to_string()...

but type_to_string() is already implemented in ri-util in a less useful form string type_to_string(cons type t) { return string_of_type(t); } This function cannot be in ri-util because of string_of_type()

Parameters

t0	0
t1	1

Definition at line 74 of file type.c.

                                                    {
  string s0 = string_of_type(t0),
    s1 =string_of_type(t1);
  bool same = same_string_p(s0,s1);
  free(s0); free(s1);
  return same;
}

References free(), s1, same_string_p, and string_of_type().

Referenced by comparable_entity_in_list_p(), same_cast_name_p(), and same_sizeofexpression_name_p().

Here is the call graph for this function:

Here is the caller graph for this function:

same_va_arg_name_p()

bool same_va_arg_name_p	(	list	l1,
		list	l2
	)

Parameters

l1	1
l2	2

Definition at line 115 of file same_names.c.

{
  if (gen_length(l1)!=gen_length(l2))
    return false;
 
  for(; l1 && l2; POP(l1), POP(l2)) {
    sizeofexpression s1 = SIZEOFEXPRESSION(CAR(l1));
    sizeofexpression s2 = SIZEOFEXPRESSION(CAR(l2));
    if (!same_sizeofexpression_name_p(s1, s2))
      return false;
  }
  return true;
}

References CAR, gen_length(), POP, s1, same_sizeofexpression_name_p(), and SIZEOFEXPRESSION.

Referenced by same_syntax_name_p().

Here is the call graph for this function:

Here is the caller graph for this function:

sc_syst_debug()

void sc_syst_debug

(

Psysteme

s

)

constraint_to_text.c

Definition at line 46 of file constraint_to_text.c.

{
  sc_fprint(stderr, s, (get_variable_name_t) entity_local_name);
}

References entity_local_name(), and sc_fprint().

Referenced by build_and_test_dependence_context(), dependence_cone_positive(), loop_regions_normalize(), region_exact_projection_along_variable(), region_sc_minimal(), regions_may_convex_hull(), regions_must_convex_hull(), sc_projection_optim_along_vecteur_ofl(), TestDependence(), text_transformer(), and unimodular().

Here is the call graph for this function:

Here is the caller graph for this function:

sentence_goto_label()

sentence sentence_goto_label	(	entity	,
		const char *	,
		int	,
		const char *	,
		int
	)

sentence_head()

sentence sentence_head	(	entity	e,
		list *	ppdl
	)

We have no way to distinguish between the SUBROUTINE and PROGRAM They two have almost the same properties.

For the time being, especially for the PUMA project, we have a temporary idea to deal with it: When there's no argument(s), it should be a PROGRAM, otherwise, it should be a SUBROUTINE. Lei ZHOU 18/10/91

correct PROGRAM and SUBROUTINE distinction added, FC 18/08/94 approximate BLOCK DATA / SUBROUTINE distinction also added. FC 09/97

Parameters

ppdl

pdl

Definition at line 601 of file declarations.c.

{
  list pc = NIL;
  type te = entity_type(e);
  functional fe;
  type tr;
  list args = words_parameters(e, ppdl);
 
  pips_assert("is functionnal", type_functional_p(te));
 
  if (static_module_p(e))
    pc = CHAIN_SWORD(pc,"static ");
 
  fe = type_functional(te);
  tr = functional_result(fe);
 
  switch(type_tag(tr)) {
    case is_type_void:
      switch(get_prettyprint_language_tag()) {
        case is_language_fortran:
        case is_language_fortran95:
          if (entity_main_module_p(e))
            pc = CHAIN_SWORD(pc,"PROGRAM ");
          else {
            if (entity_blockdata_p(e))
              pc = CHAIN_SWORD(pc, "BLOCKDATA ");
            else if (entity_f95module_p(e))
              pc = CHAIN_SWORD(pc, "MODULE ");
            else
              pc = CHAIN_SWORD(pc,"SUBROUTINE ");
          }
          break;
        case is_language_c:
          pc = CHAIN_SWORD(pc,"void ");
          break;
        default:
          pips_internal_error("Language unknown !");
          break;
      }
      break;
    case is_type_variable: {
      list pdl = NIL;
      // FI: the qualifiers are dropped...
      variable var = type_variable(tr);
      basic b = variable_basic(var);
      list ql = variable_qualifiers(var);
      pc = gen_nconc(pc, words_basic(b, &pdl));
      pc = gen_nconc(words_qualifiers(ql), pc);
      switch(get_prettyprint_language_tag()) {
        case is_language_fortran:
        case is_language_fortran95:
          pc = CHAIN_SWORD(pc," FUNCTION ");
          break;
        case is_language_c:
          pc = CHAIN_SWORD(pc," ");
          break;
        default:
          pips_internal_error("Language unknown !");
          break;
      }
      break;
    }
    case is_type_unknown:
      /*
       * For C functions with no return type.
       * It can be treated as of type int, but we keep it unknown
       * for the moment, to make the differences and to regenerate initial code
       */
      break;
    default:
      pips_internal_error("unexpected type for result");
  }
 
  pc = CHAIN_SWORD(pc, entity_user_name(e));
 
  if (!ENDP(args)) {
    pc = CHAIN_SWORD(pc, "(");
    pc = gen_nconc(pc, args);
    pc = CHAIN_SWORD(pc, ")");
  } else if (type_variable_p(tr)
              || (prettyprint_language_is_c_p()
                  && (type_unknown_p(tr) || type_void_p(tr)))) {
    pc = CHAIN_SWORD(pc, "()");
  }
 
  return (make_sentence(is_sentence_unformatted, make_unformatted(NULL,
                                                                  0,
                                                                  0,
                                                                  pc)));
}

References CHAIN_SWORD, ENDP, entity_blockdata_p(), entity_f95module_p(), entity_main_module_p(), entity_type, entity_user_name(), functional_result, gen_nconc(), get_prettyprint_language_tag(), is_language_c, is_language_fortran, is_language_fortran95, is_sentence_unformatted, is_type_unknown, is_type_variable, is_type_void, make_sentence(), make_unformatted(), NIL, pips_assert, pips_internal_error, prettyprint_language_is_c_p(), static_module_p(), type_functional, type_functional_p, type_tag, type_unknown_p, type_variable, type_variable_p, type_void_p, variable_basic, variable_qualifiers, words_basic(), words_parameters(), and words_qualifiers().

Referenced by ensure_comment_consistency().

Here is the call graph for this function:

Here is the caller graph for this function:

Sentence_Variable()

sentence Sentence_Variable

(

entity

e

)

Definition at line 583 of file declarations.c.

{
  list pdl = NIL;
  sentence s = sentence_variable(e, &pdl);
  gen_free_list(pdl);
  return s;
}

References gen_free_list(), NIL, and sentence_variable().

Referenced by make_emulated_shared_variable(), and set_dimensions_of_local_variable_family().

Here is the call graph for this function:

Here is the caller graph for this function:

sentence_variable()

sentence sentence_variable	(	entity	e,
		list *	ppdl
	)

Parameters

ppdl

pdl

Definition at line 567 of file declarations.c.

{
    list pc = NIL;
    type te = entity_type(e);
 
    pips_assert("is a variable", type_variable_p(te));
 
    pc = gen_nconc(pc, words_basic(variable_basic(type_variable(te)), ppdl));
    pc = CHAIN_SWORD(pc, " ");
 
    pc = gen_nconc(pc, words_declaration(e, true, ppdl));
 
    return(make_sentence(is_sentence_unformatted,
                         make_unformatted(NULL, 0, 0, pc)));
}

References CHAIN_SWORD, entity_type, gen_nconc(), is_sentence_unformatted, make_sentence(), make_unformatted(), NIL, pips_assert, type_variable, type_variable_p, variable_basic, words_basic(), and words_declaration().

Referenced by Sentence_Variable().

Here is the call graph for this function:

Here is the caller graph for this function:

set_alternate_return_set()

void set_alternate_return_set

(

void

)

Definition at line 795 of file misc.c.

{
  ifdebug(1) {
  pips_assert("The target list is undefined",
              list_undefined_p(set_of_labels_required_for_alternate_returns));
  }
  set_of_labels_required_for_alternate_returns = NIL;
}

References ifdebug, list_undefined_p, NIL, pips_assert, and set_of_labels_required_for_alternate_returns.

Referenced by ensure_comment_consistency(), fprint_statement(), and statement_to_text().

Here is the caller graph for this function:

set_last_statement()

void set_last_statement

(

statement

)

Referenced by ensure_comment_consistency().

Here is the caller graph for this function:

set_prettyprinter_common_hook()

void set_prettyprinter_common_hook

(

string(*)(entity, entity)

)

declarations2.c

Referenced by hpfc_print_code().

Here is the caller graph for this function:

set_prettyprinter_head_hook()

void set_prettyprinter_head_hook

(

string(*)(entity)

f

)

Definition at line 3963 of file misc.c.

{ head_hook=f;}

References f(), and head_hook.

Referenced by compile_mpi(), and hpfc_print_code().

Here is the call graph for this function:

Here is the caller graph for this function:

statement_to_text()

text statement_to_text

(

statement

s

)

Definition at line 124 of file statement.c.

{
  text t = text_undefined;
 
  debug_on("PRETTYPRINT_DEBUG_LEVEL");
  set_alternate_return_set();
  reset_label_counter();
  list pdl = NIL;
  t = text_statement(entity_undefined, 0, s, &pdl);
  gen_free_list(pdl);
  reset_alternate_return_set();
  debug_off();
 
  return t;
}

References debug_off, debug_on, entity_undefined, gen_free_list(), NIL, reset_alternate_return_set(), reset_label_counter(), set_alternate_return_set(), text_statement(), and text_undefined.

Referenced by control_graph(), insert_impact_description_as_comment(), and subtsitute_variable_in_reference().

Here is the call graph for this function:

Here is the caller graph for this function:

string_of_type()

string string_of_type

(

const

type

)

Definition at line 56 of file type.c.

{
  list pdl = NIL;
  list wl = words_type(t, &pdl, false);
  gen_free_list(pdl);
  string s = words_to_string(wl);
  FOREACH(STRING,s,wl) free(s);
  gen_free_list(wl);
  return s;
}

References FOREACH, free(), gen_free_list(), NIL, STRING, words_to_string(), and words_type().

Referenced by binary_arithmetic_operator_to_post_pv(), check_type_of_points_to_cells(), declaration_to_post_pv(), FILE_star_effect_reference_p(), malloc_arg_to_type(), malloc_to_abstract_location(), malloc_type_to_abstract_location(), module_initial_parameter_pv(), and xml_print_parameter().

Here is the call graph for this function:

Here is the caller graph for this function:

symbol_table()

bool symbol_table

(

const char *

module_name

)

To replace c_symbol_table() and fortran_symbol_table() because the information about the language is available in the symbol table.

Parameters

module_name

odule_name

Definition at line 673 of file symbol_table.c.

{
  actual_symbol_table_dump(module_name, false);
  return true;
}

References actual_symbol_table_dump(), and module_name().

Referenced by expression_similar_get_context_p(), and expression_similar_p().

Here is the call graph for this function:

Here is the caller graph for this function:

system_sorted_text_format()

void system_sorted_text_format	(	string	line,
		string	prefix,
		text	txt,
		Psysteme	ps,
		string(*)(Variable)	variable_name,
		bool(*)(Pvecteur)	put_first,
		bool	a_la_fortran
	)

lower level hook for regions.

{

repeat twice: once for first, once for not first.

== / .EQ.

<= / .LE.

}

Parameters

line	ine
prefix	refix
txt	xt
ps	s
a_la_fortran	_la_fortran

Definition at line 391 of file constraint_to_text.c.

{
  bool invert, stop, some_previous = false;
 
  if (ps==NULL)
  {
    add_to_current_line(line, get_string_property("SYSTEM_NULL"), prefix, txt);
    return;
  }
  else if (SC_UNDEFINED_P(ps))
  {
    add_to_current_line(line, get_string_property("SYSTEM_UNDEFINED"),
                        prefix, txt);
    return;
  }
  else if (sc_empty_p(ps))
  {
    add_to_current_line(line, get_string_property("SYSTEM_NOT_FEASIBLE"),
                        prefix, txt);
    return;
  }
 
  /* {
   */
  if (!a_la_fortran) add_to_current_line(line, "{", prefix, txt);
 
  /* repeat twice: once for first, once for not first.
   */
  for(invert = false, stop = false; !stop; )
  {
    /* == / .EQ.
     */
    some_previous =
      contraintes_text_format(line, prefix, txt, sc_egalites(ps),
                              variable_name, invert, put_first,
                              some_previous, false, a_la_fortran);
 
    /* <= / .LE.
     */
    some_previous =
      contraintes_text_format(line, prefix, txt, sc_inegalites(ps),
                              variable_name, invert, put_first,
                              some_previous, true, a_la_fortran);
 
    if (invert || !put_first) stop = true;
    invert = true;
  }
 
  /* }
   */
  if (!a_la_fortran) add_to_current_line(line, "}", prefix, txt);
}

References add_to_current_line(), contraintes_text_format(), get_string_property(), line, prefix, sc_empty_p(), and variable_name().

Referenced by system_text_format(), text_pointer_value(), text_points_to_relation(), and text_region_no_action().

Here is the call graph for this function:

Here is the caller graph for this function:

system_text_format()

void system_text_format	(	string	line,
		string	prefix,
		text	txt,
		Psysteme	ps,
		string(*)(Variable)	variable_name,
		bool	a_la_fortran
	)

appends ps to line/txt with prefix continuations.

Parameters

line	ine
prefix	refix
txt	xt
ps	s
a_la_fortran	_la_fortran

Definition at line 453 of file constraint_to_text.c.

{
  system_sorted_text_format
    (line, prefix, txt, ps, variable_name, NULL, a_la_fortran);
}

References line, prefix, system_sorted_text_format(), and variable_name().

Referenced by text_continuation(), and text_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

text_common_declaration()

text text_common_declaration	(	entity	common,
		entity	module
	)

needed for hpfc

Parameters

common	ommon
module	odule

Definition at line 1228 of file declarations2.c.

{
    type t = entity_type(common);
    list l;
    text result;
    list pdl = NIL; // Assumed Fortran only
    pips_assert("indeed a common", type_area_p(t));
    l = CONS(ENTITY, common, common_members_of_module(common, module, false));
    result = text_entity_declaration(module, l, true, &pdl);
    gen_free_list(l);
    gen_free_list(pdl);
    return result;
}

References common_members_of_module(), CONS, ENTITY, entity_type, gen_free_list(), module, NIL, pips_assert, text_entity_declaration(), and type_area_p.

Referenced by hpfc_print_common(), and text_area_included().

Here is the call graph for this function:

Here is the caller graph for this function:

text_declaration()

text text_declaration

(

entity

module

)

exported for hpfc.

Assume Fortran only!

Parameters

module

odule

Definition at line 1216 of file declarations2.c.

{
  /* Assume Fortran only! */
  list pdl = NIL;
  text t = text_entity_declaration
      (module, code_declarations(entity_code(module)), false, &pdl);
  gen_free_list(pdl);
  return t;
}

References code_declarations, entity_code(), gen_free_list(), module, NIL, and text_entity_declaration().

Referenced by ensure_comment_consistency(), and init_host_and_node_entities().

Here is the call graph for this function:

Here is the caller graph for this function:

text_initializations()

text text_initializations

(

entity

m

)

The previous declaration list is useless in Fortran, but the signature of functions designed for C or Fortran must be respected.

Definition at line 1244 of file declarations2.c.

{
  text t = make_text(NIL);
  list il = list_undefined;
 
  pips_assert("m is a module", entity_module_p(m));
 
  il = sequence_statements(code_initializations(value_code(entity_initial(m))));
 
  FOREACH(STATEMENT, is, il) {
    /* The previous declaration list is useless in Fortran, but the
       signature of functions designed for C or Fortran must be
       respected. */
    list pdl = NIL;
    if(!empty_comments_p(statement_comments(is))) {
      ADD_SENTENCE_TO_TEXT(t, make_sentence(is_sentence_formatted,
                                            strdup(statement_comments(is))));
    }
    ADD_SENTENCE_TO_TEXT(t, sentence_data_statement(is, &pdl));
    gen_free_list(pdl);
  }
 
  return t;
}

References ADD_SENTENCE_TO_TEXT, code_initializations, empty_comments_p(), entity_initial, entity_module_p(), FOREACH, gen_free_list(), is_sentence_formatted, list_undefined, make_sentence(), make_text(), NIL, pips_assert, sentence_data_statement(), sequence_statements, STATEMENT, statement_comments, strdup(), and value_code.

Referenced by ensure_comment_consistency().

Here is the call graph for this function:

Here is the caller graph for this function:

text_loop()

text text_loop	(	entity	module,
		const char *	label,
		int	margin,
		loop	obj,
		int	n,
		list *	ppdl,
		bool	is_recursive_p
	)

exported for conversion/look_for_nested_loops.c

small hack to show the initial label of the loop to name it...

quite ugly management of other prettyprints...

Parameters

module	odule
label	abel
margin	argin
obj	bj
ppdl	pdl
is_recursive_p	s_recursive_p

Definition at line 3264 of file misc.c.

{
  text r = make_text(NIL);
  statement body = loop_body( obj ) ;
  entity the_label = loop_label(obj);
  const char* do_label = entity_local_name(the_label)+sizeof(LABEL_PREFIX) -1;
  bool structured_do = entity_empty_label_p(the_label);
  bool do_enddo_p = get_bool_property("PRETTYPRINT_DO_LABEL_AS_COMMENT");
 
  /* small hack to show the initial label of the loop to name it...
   */
  if(!structured_do && do_enddo_p)
    {
      ADD_SENTENCE_TO_TEXT(r, make_sentence(is_sentence_formatted,
                                            strdup(concatenate("!     INITIALLY: DO ", do_label, "\n", NULL))));
    }
 
  /* quite ugly management of other prettyprints...
   */
  switch(execution_tag(loop_execution(obj)) ) {
  case is_execution_sequential:
    MERGE_TEXTS(r, text_loop_default(module, label, margin, obj, n, ppdl, is_recursive_p));
    break ;
  case is_execution_parallel:
    if (pp_cmf_style_p()) {
      text aux_r;
      if((aux_r = text_loop_cmf(module, label, margin, obj, n, NIL, NIL))
         != text_undefined) {
        MERGE_TEXTS(r, aux_r);
      }
    }
    else if (pp_craft_style_p()) {
      text aux_r;
      if((aux_r = text_loop_craft(module, label, margin, obj, n, NIL, NIL))
         != text_undefined) {
        MERGE_TEXTS(r, aux_r);
      }
    }
    else if (pp_f90_style_p()) {
      instruction bi = statement_instruction(body); // body instruction
      bool success_p = false;
      if(instruction_assign_p(bi) ) {
        MERGE_TEXTS(r, text_loop_90(module, label, margin, obj, n));
        success_p = true;
      }
      else if(instruction_sequence_p(bi)) {
        list sl = sequence_statements(instruction_sequence(bi));
        if(gen_length(sl)==1) {
          statement ibs = STATEMENT(CAR(sl));
          instruction ibi = statement_instruction(ibs);
          if(instruction_assign_p(ibi) ) {
            MERGE_TEXTS(r, text_loop_90(module, label, margin, obj, n));
            success_p = true;
          }
        }
      }
      if(!success_p) {
        MERGE_TEXTS(r, text_loop_default(module, label, margin, obj, n, ppdl, is_recursive_p));
      }
    }
    else {
      MERGE_TEXTS(r, text_loop_default(module, label, margin, obj, n, ppdl, is_recursive_p));
    }
    break ;
  default:
    pips_internal_error("Unknown \"execution\" tag") ;
  }
  return r;
}

References ADD_SENTENCE_TO_TEXT, CAR, concatenate(), entity_empty_label_p(), entity_local_name(), execution_tag, gen_length(), get_bool_property(), instruction_assign_p(), instruction_sequence, instruction_sequence_p, is_execution_parallel, is_execution_sequential, is_sentence_formatted, LABEL_PREFIX, loop_body, loop_execution, loop_label, make_sentence(), make_text(), MERGE_TEXTS, module, NIL, pips_internal_error, pp_cmf_style_p, pp_craft_style_p, pp_f90_style_p, sequence_statements, STATEMENT, statement_instruction, strdup(), text_loop_90(), text_loop_cmf(), text_loop_craft(), text_loop_default(), and text_undefined.

Referenced by print_loops_list(), and text_instruction().

Here is the call graph for this function:

Here is the caller graph for this function:

text_loop_90()

text text_loop_90	(	entity	module,
		const char *	label,
		int	margin,
		loop	obj,
		int	n
	)

fortran90.c

fortran90.c

text_loop_90() only is called if the loop is parallel and if its body is a unique assignment statement or a list containing a unique assignment.

statement_ordering must be initialized too to avoid a prettyprinter warning

FI: Although new_s has been converted to text, it cannot always be freed. I do not know which part of new_s is reused in the result of text_statement() or somewhere else... Found with valgrind and validation case Prettyprint/aa01.tpips

No legal vector form has been found

Parameters

module	odule
label	abel
margin	argin
obj	bj

Definition at line 77 of file fortran90.c.

{
    /* text_loop_90() only is called if the loop is parallel and if its
     * body is a unique assignment statement or a list containing a
     * unique assignment.
     */
  statement as = body_to_assignment_statement( loop_body( obj )) ;
  instruction i = statement_instruction(as);
    entity idx = loop_index( obj ) ;
    range r = loop_range( obj ) ;
 
    expression lhs =
        EXPRESSION( CAR( call_arguments( instruction_call( i )))) ;
    expression rhs =
        EXPRESSION( CAR( CDR( call_arguments( instruction_call( i ))))) ;
    expression new_lhs = expression_undefined;
    expression new_rhs = expression_undefined;
    text t = text_undefined;
 
    pips_assert("Loop obj is consistent", loop_consistent_p(obj));
 
    vectors = set_make( set_pointer ) ;
 
    new_lhs = expand_expression( lhs, idx, r ) ;
    new_rhs = expand_expression( rhs, idx, r ) ;
 
    pips_assert("new_lhs is consistent", expression_consistent_p(new_lhs));
    pips_assert("new_rhs is consistent", expression_consistent_p(new_rhs));
 
    set_free(vectors);
 
    if(!expression_undefined_p(new_lhs) && !expression_undefined_p(new_rhs)) {
        statement new_s = make_assign_statement( new_lhs, new_rhs );
 
        statement_number(new_s) = statement_number(as);
        /* statement_ordering must be initialized too to avoid a
           prettyprinter warning */
        statement_ordering(new_s) = statement_ordering(as);
        statement_comments(new_s) = statement_comments(as);
        list pdl = NIL;
        t = text_statement(module, margin, new_s, &pdl);
        gen_free_list(pdl);
        /* FI: Although new_s has been converted to text, it cannot
           always be freed. I do not know which part of new_s is
           reused in the result of text_statement() or somewhere
           else... Found with valgrind and validation case
           Prettyprint/aa01.tpips */
        //free_statement(new_s);
    }
    else {
        /* No legal vector form has been found */
        free_expression(new_lhs);
        free_expression(new_rhs);
        list pdl = NIL;
        t = text_loop_default(module, label, margin, obj, n, &pdl, true);
        gen_free_list(pdl);
    }
 
    pips_assert("Loop obj still is consistent", loop_consistent_p(obj));
 
    return t;
}

References body_to_assignment_statement(), call_arguments, CAR, CDR, expand_expression(), EXPRESSION, expression_consistent_p(), expression_undefined, expression_undefined_p, free_expression(), gen_free_list(), instruction_call, loop_body, loop_consistent_p(), loop_index, loop_range, make_assign_statement(), module, NIL, pips_assert, set_free(), set_make(), set_pointer, statement_comments, statement_instruction, statement_number, statement_ordering, text_loop_default(), text_statement(), text_undefined, and vectors.

Referenced by text_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

text_loop_cmf()

text text_loop_cmf	(	entity	module,
		const char *	label,
		int	margin,
		loop	obj,
		int	n,
		list	lr,
		list	lidx
	)

=====================================================================

Parameters

module	odule
label	abel
margin	argin
obj	bj
lr	r
lidx	idx

Definition at line 66 of file cmfortran.c.

{
  text result_text = text_undefined;
  instruction i;
  entity idx;
  range r;
 
  i = statement_instruction(loop_body(obj));
  idx = loop_index(obj);
  r = loop_range(obj);
 
  lr = gen_nconc(lr, CONS(RANGE, r, NIL));
  lidx = gen_nconc(lidx, CONS(ENTITY, idx, NIL));
 
  if(!instruction_assign_p(i)) {
    if(instruction_loop_p(i)) {
      result_text = text_loop_cmf(module, label, margin,
                                  instruction_loop(i), n, lr, lidx);
    }
  }
  else {
    list pc, lli, llr;
    unformatted u;
 
    pc = CHAIN_SWORD(NIL, "FORALL(");
    for(lli = lidx, llr = lr; !ENDP(lli); POP(lli), POP(llr)) {
      pc = CHAIN_SWORD(pc, entity_local_name(ENTITY(CAR(lli))));
      pc = CHAIN_SWORD(pc, " = ");
      pc = gen_nconc(pc, words_cmf_loop_range(RANGE(CAR(llr))));
      if(CDR(lli) != NIL)
        pc = CHAIN_SWORD(pc, ", ");
    }
    pc = CHAIN_SWORD(pc, ") ");
    pc = gen_nconc(pc, Words_Call(instruction_call(i), 0, true, true));
    u = make_unformatted(strdup(label), n, margin, pc) ;
    result_text = make_text(CONS(SENTENCE,
                                 make_sentence(is_sentence_unformatted,
                                               u),
                                 NIL));
  }
  return(result_text);
}

References CAR, CDR, CHAIN_SWORD, CONS, ENDP, ENTITY, entity_local_name(), gen_nconc(), instruction_assign_p(), instruction_call, instruction_loop, instruction_loop_p, is_sentence_unformatted, loop_body, loop_index, loop_range, make_sentence(), make_text(), make_unformatted(), module, NIL, POP, RANGE, SENTENCE, statement_instruction, strdup(), text_undefined, Words_Call(), and words_cmf_loop_range().

Referenced by text_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

text_loop_craft()

text text_loop_craft	(	entity	module,
		const char *	label,
		int	margin,
		loop	obj,
		int	n,
		list	lr,
		list	lidx
	)

=====================================================================

Parameters

module	odule
label	abel
margin	argin
obj	bj
lr	r
lidx	idx

Definition at line 92 of file craft.c.

{
  text result_text = make_text(NIL);
  instruction i;
  entity idx;
  range r;
 
  i = statement_instruction(loop_body(obj));
  idx = loop_index(obj);
  r = loop_range(obj);
 
  lr = gen_nconc(lr, CONS(RANGE, r, NIL));
  lidx = gen_nconc(lidx, CONS(ENTITY, idx, NIL));
 
  if(!instruction_assign_p(i)) {
    if(instruction_loop_p(i)) {
      result_text = text_loop_craft(module, label, margin,
                                  instruction_loop(i), n, lr, lidx);
    }
  }
  else {
    list pc, lli, llr, args, new_lli = NIL;
    unformatted u;
    int c;
    char *comment;
    expression lhs_exp = expression_undefined;
    syntax lhs_sy;
    
    args = call_arguments(instruction_call(i));
    if(!ENDP(args))
      lhs_exp = copy_expression(EXPRESSION(CAR(args)));
    else
      user_error("text_loop_craft",
                 "Call to an assign with no argument\n");
 
    lhs_sy = expression_syntax(lhs_exp);
    if(syntax_tag(lhs_sy) != is_syntax_reference)
      user_error("text_loop_craft", "\n An lhs expression not a ref\n");
    else {
      lli = reference_indices(syntax_reference(lhs_sy));
      for(; !ENDP(lli); POP(lli)) {
        new_lli = gen_nconc(new_lli, CONS(EXPRESSION,
                                          remove_modulo(EXPRESSION(CAR(lli))),
                                          NIL));
      }
      reference_indices(syntax_reference(lhs_sy)) = new_lli;
    }
 
    // BUG: missing overflow checks
    comment = (char*) malloc(64);
    char * x = comment;
    x += sprintf(comment, "CDIR$ DOSHARED(");
    for(lli = lidx; !ENDP(lli); POP(lli)) {
      x += sprintf(x, "%s", entity_local_name(ENTITY(CAR(lli))));
      if(CDR(lli) != NIL)
        x += sprintf(x, ", ");
    }
    list pdl = NIL;
    x += sprintf(x, ") ON %s\n", words_to_string(words_expression(lhs_exp, &pdl)));
    gen_free_list(pdl);
    ADD_SENTENCE_TO_TEXT(result_text, make_sentence(is_sentence_formatted,
                                                    comment));
 
    for(lli = lidx, llr = lr, c = 0; !ENDP(lli); POP(lli), POP(llr), c++) {
      pc = CHAIN_SWORD(NIL, "DO " );
      pc = CHAIN_SWORD(pc, entity_local_name(ENTITY(CAR(lli))));
      pc = CHAIN_SWORD(pc, " = ");
      pc = gen_nconc(pc, words_loop_range(RANGE(CAR(llr)), &pdl));
      gen_free_list(pdl);
      u = make_unformatted(strdup(label), n,
                           margin+c*INDENTATION, pc);
      ADD_SENTENCE_TO_TEXT(result_text,
                           make_sentence(is_sentence_unformatted, u));
    }
    MERGE_TEXTS(result_text, text_statement(module, margin+c*INDENTATION,
                                            loop_body(obj), &pdl));
    gen_free_list(pdl);
 
    for(c = gen_length(lidx)-1; c > -1; c--) {
      ADD_SENTENCE_TO_TEXT(result_text,
                           MAKE_ONE_WORD_SENTENCE(margin+c*INDENTATION,
                                                  "ENDDO"));
    }
  }
  return(result_text);
}

References ADD_SENTENCE_TO_TEXT, call_arguments, CAR, CDR, CHAIN_SWORD, comment(), CONS, copy_expression(), ENDP, ENTITY, entity_local_name(), EXPRESSION, expression_syntax, expression_undefined, gen_free_list(), gen_length(), gen_nconc(), INDENTATION, instruction_assign_p(), instruction_call, instruction_loop, instruction_loop_p, is_sentence_formatted, is_sentence_unformatted, is_syntax_reference, loop_body, loop_index, loop_range, MAKE_ONE_WORD_SENTENCE, make_sentence(), make_text(), make_unformatted(), malloc(), MERGE_TEXTS, module, NIL, POP, RANGE, reference_indices, remove_modulo(), statement_instruction, strdup(), syntax_reference, syntax_tag, text_statement(), user_error, words_expression(), words_loop_range(), words_to_string(), and x.

Referenced by text_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

text_loop_default()

text text_loop_default	(	entity	module,
		const char *	label,
		int	margin,
		loop	obj,
		int	n,
		list *	ppdl,
		bool	is_recursive_p
	)

exported for fortran90.c

HPF directives before the loop if required (INDEPENDENT and NEW)

idem if Open MP directives are required

LOOP prologue.

builds the PRIVATE scalar declaration if required

of string

local_var is a global variable which is exploited later...

FI: I do not understand why the local declarations were not added right away. I hope my change (simplification) does not break something else that is not tested by our non-regression suite.

loop BODY

LOOP postlogue

Parameters

module	odule
label	abel
margin	argin
obj	bj
ppdl	pdl
is_recursive_p	s_recursive_p

Definition at line 3118 of file misc.c.

                                            {
  list pc = NIL;
  sentence first_sentence = sentence_undefined;
  unformatted u;
  text r = make_text(NIL);
  statement body = loop_body( obj );
  entity the_label = loop_label(obj);
  const char* do_label = entity_local_name(the_label) + sizeof(LABEL_PREFIX) -1;
  bool structured_do = entity_empty_label_p(the_label);
  bool doall_loop_p = false;
  bool hpf_prettyprint = pp_hpf_style_p();
  bool do_enddo_p = get_bool_property("PRETTYPRINT_DO_LABEL_AS_COMMENT");
  bool all_private = get_bool_property("PRETTYPRINT_ALL_PRIVATE_VARIABLES");
  bool braces_p = !one_liner_p(body) || prettyprint_all_c_braces_p;
 
  if (execution_sequential_p(loop_execution(obj))) {
    doall_loop_p = false;
  } else {
    doall_loop_p = pp_doall_style_p();
  }
 
  /* HPF directives before the loop if required (INDEPENDENT and NEW) */
  if (hpf_prettyprint)
    MERGE_TEXTS(r, text_hpf_directive(obj, margin));
  /* idem if Open MP directives are required */
  if (pp_omp_style_p())
    MERGE_TEXTS(r, text_omp_directive(obj, margin));
 
  /* LOOP prologue.
   */
  switch (get_prettyprint_language_tag()) {
    case is_language_fortran:
    case is_language_fortran95:
      pc = CHAIN_SWORD(NIL, (doall_loop_p) ? "DOALL " : "DO " );
      if (!structured_do && !doall_loop_p && !do_enddo_p) {
        pc = CHAIN_SWORD(pc, concatenate(do_label, " ", NULL));
      }
      break;
    case is_language_c:
      pc = CHAIN_SWORD(NIL, (doall_loop_p) ? "forall(" : "for(" );
      break;
    default:
      pips_internal_error("Language unknown !");
      break;
  }
 
  //pc = CHAIN_SWORD(pc, entity_local_name(loop_index(obj)));
  pc = CHAIN_SWORD(pc, entity_user_name(loop_index(obj)));
  pc = CHAIN_SWORD(pc, " = ");
 
  switch (get_prettyprint_language_tag()) {
  case is_language_fortran:
  case is_language_fortran95:
    pc = gen_nconc(pc, words_loop_range(loop_range(obj), ppdl));
    u = make_unformatted(strdup(label), n, margin, pc);
    ADD_SENTENCE_TO_TEXT(r, first_sentence =
                         make_sentence(is_sentence_unformatted, u));
    break;
  case is_language_c:
    pc = gen_nconc(pc, C_loop_range(loop_range(obj), loop_index(obj), ppdl));
    if (braces_p)
      pc = CHAIN_SWORD(pc," {");
    if ((label != NULL) && (label[0] != '\0')) {
      pips_debug(9, "the label %s need to be print for a for C loop", label);
      u = make_unformatted(strdup(label), 0, 0, NULL);
      ADD_SENTENCE_TO_TEXT(r, first_sentence =
                           make_sentence(is_sentence_unformatted, u));
    }
    u = make_unformatted(NULL, n, margin, pc);
    ADD_SENTENCE_TO_TEXT(r, make_sentence(is_sentence_unformatted, u));
    break;
  default:
    pips_internal_error("Language tag unknown!");
    break;
  }
 
  if(is_recursive_p) {
    /* builds the PRIVATE scalar declaration if required
     */
    if (!ENDP(loop_locals(obj)) && (doall_loop_p || all_private)
        && !hpf_prettyprint) {
      list /* of string */lp = loop_private_variables(obj, ppdl);
 
      // initialize the local variable text if needed
      if ((local_flg == false) && (lp)) {
        local_flg = true;
        local_var = make_text(NIL);
      }
 
      if (lp)
        /* local_var is a global variable which is exploited
           later... */
        /* FI: I do not understand why the local declarations were
           not added right away. I hope my change (simplification)
           does not break something else that is not tested by our
           non-regression suite. */
        if (!pp_omp_style_p()) {
          ADD_SENTENCE_TO_TEXT
            //      ( local_var,
            ( r,
              make_sentence(is_sentence_unformatted,
                            make_unformatted(NULL, 0, margin+INDENTATION, lp)));
        }
    }
 
    /* loop BODY
     */
    MERGE_TEXTS(r, text_statement_enclosed(module,
                                           margin+INDENTATION,
                                           body,
                                           !one_liner_p(body),
                                           !one_liner_p(body),
                                           ppdl));
 
    /* LOOP postlogue
     */
    switch (get_prettyprint_language_tag()) {
    case is_language_fortran:
    case is_language_fortran95:
      if (structured_do || doall_loop_p || do_enddo_p || pp_cray_style_p()
          || pp_craft_style_p() || pp_cmf_style_p()) {
        ADD_SENTENCE_TO_TEXT(r, MAKE_ONE_WORD_SENTENCE(margin,"ENDDO"));
      }
      break;
    case is_language_c:
      if (braces_p)
        ADD_SENTENCE_TO_TEXT(r, MAKE_ONE_WORD_SENTENCE(margin,"}"));
      break;
    default:
      pips_internal_error("Language unknown !");
      break;
    }
 
    attach_loop_to_sentence_up_to_end_of_text(first_sentence, r, obj);
  }
 
  return r;
}

References ADD_SENTENCE_TO_TEXT, attach_loop_to_sentence_up_to_end_of_text(), C_loop_range(), CHAIN_SWORD, concatenate(), ENDP, entity_empty_label_p(), entity_local_name(), entity_user_name(), execution_sequential_p, gen_nconc(), get_bool_property(), get_prettyprint_language_tag(), INDENTATION, is_language_c, is_language_fortran, is_language_fortran95, is_sentence_unformatted, LABEL_PREFIX, local_flg, local_var, loop_body, loop_execution, loop_index, loop_label, loop_locals, loop_private_variables(), loop_range, MAKE_ONE_WORD_SENTENCE, make_sentence(), make_text(), make_unformatted(), MERGE_TEXTS, module, NIL, one_liner_p(), pips_debug, pips_internal_error, pp_cmf_style_p, pp_craft_style_p, pp_cray_style_p, pp_doall_style_p, pp_hpf_style_p, pp_omp_style_p, prettyprint_all_c_braces_p, sentence_undefined, strdup(), text_hpf_directive(), text_omp_directive(), text_statement_enclosed(), and words_loop_range().

Referenced by text_loop(), and text_loop_90().

Here is the call graph for this function:

Here is the caller graph for this function:

text_module()

text text_module	(	entity	,
		statement
	)

Referenced by add_new_module(), do_recompile_module(), ensure_comment_consistency(), generic_print_code_pv(), get_any_comp_regions_text(), get_continuation_condition_text(), get_semantic_text(), hpfc_print_code(), print_code_or_source(), print_code_or_source_comp(), print_code_points_to(), print_code_static_control(), print_parallelized_code_common(), print_parallelizedCMF_code(), print_parallelizedCRAFT_code(), simd_memory_packing(), store_new_module(), text_code_points_to(), text_code_reductions(), wp65(), and wp65_debug_print_module().

Here is the caller graph for this function:

text_named_module()

text text_named_module	(	entity	,
		entity	,
		statement
	)

Referenced by create_HRE_module(), create_module_with_statement(), ensure_comment_consistency(), outliner_file(), outliner_independent(), outliner_independent_recursively(), ProcessEntries(), ProcessEntry(), and step_compile_analysed_module().

Here is the caller graph for this function:

text_omp_directive()

text text_omp_directive	(	loop	l,
		int	m
	)

Definition at line 3084 of file misc.c.

{
  list pdl = NIL; // pdl is useless in Fortran
  text t = text_undefined;
 
  switch(get_prettyprint_language_tag()) {
    case is_language_fortran:
    case is_language_fortran95:
      t = text_directive(l,
                         m,
                         "\n" OMP_DIRECTIVE,
                         OMP_CONTINUATION,
                         OMP_PARALLELDO,
                         &pdl);
      break;
    case is_language_c:
      // text_directive function takes care of private variables
      // More should be done to take care of shared variables, reductions
      // and other specific omp clause like lastprivate, copyin ...
      t = text_directive(l,
                         m,
                         OMP_C_DIRECTIVE,
                         OMP_C_CONTINUATION,
                         OMP_C_PARALLELDO,
                         &pdl);
      break;
    default:
      pips_internal_error("Language unknown !");
      break;
  }
  return t;
}

References get_prettyprint_language_tag(), is_language_c, is_language_fortran, is_language_fortran95, NIL, OMP_C_CONTINUATION, OMP_C_DIRECTIVE, OMP_C_PARALLELDO, OMP_CONTINUATION, OMP_DIRECTIVE, OMP_PARALLELDO, pips_internal_error, text_directive(), and text_undefined.

Referenced by text_loop_default().

Here is the call graph for this function:

Here is the caller graph for this function:

Text_Proper_Statement()

text Text_Proper_Statement	(	entity	,
		int	,
		statement
	)

Referenced by ensure_comment_consistency().

Here is the caller graph for this function:

Text_Statement()

text Text_Statement	(	entity	,
		int	,
		statement
	)

Referenced by ensure_comment_consistency(), fprint_statement_complexity(), make_movements_loop_body_wp65(), prettyprint_dot_label(), and protected_text_statement().

Here is the caller graph for this function:

text_statement()

text text_statement	(	entity	,
		int	,
		statement	,
		list *
	)

Referenced by ensure_comment_consistency(), fprint_statement(), statement_to_text(), text_block_else(), text_io_block_if(), text_logical_if(), text_loop_90(), text_loop_craft(), text_unstructured(), and text_whileloop().

Here is the caller graph for this function:

Text_Statement_Enclosed()

text Text_Statement_Enclosed	(	entity	,
		int	,
		statement	,
		bool	,
		bool
	)

Referenced by ensure_comment_consistency().

Here is the caller graph for this function:

text_statement_enclosed()

text text_statement_enclosed	(	entity	,
		int	,
		statement	,
		bool	,
		bool	,
		list *
	)

Referenced by ensure_comment_consistency(), text_block(), text_block_else(), text_block_elseif(), text_block_ifthen(), text_loop_default(), text_trail(), and text_whileloop().

Here is the caller graph for this function:

text_unstructured()

text text_unstructured	(	entity	module,
		const char *	label,
		int	margin,
		unstructured	u,
		int	num,
		list *	ppdl
	)

unstructured.c

build an arbitrary reverse trail of control nodes

decorate control nodes with labels when necessary

generate text with labels and goto's

Parameters

module	odule
label	abel
margin	argin
num	um
ppdl	pdl

Definition at line 55 of file unstructured.c.

{
    text r = make_text(NIL);
    hash_table labels = hash_table_make(hash_pointer, 0) ;
 
    debug(2, "text_unstructured", "Begin for unstructured %p\n", u);
   
    ifdebug(3) {
        list blocks = NIL;
        control cexit = unstructured_exit(u) ;
        control centry = unstructured_control(u) ;
 
        fprintf(stderr,"Unstructured %p (%p, %p)\n", u, centry, cexit) ;
        CONTROL_MAP( n, {
            statement st = control_statement(n) ;
 
            /*
              fprintf(stderr, "\n%*sNode %p (%s)\n--\n", margin, "",
              (unsigned int) n, control_to_label_name(n, labels)) ;
              */
            fprintf(stderr, "\n%*sNode %p (%s)\n--\n", margin, "",
                    n, statement_identification(st));
            ifdebug(9) {
              list pdl = NIL;
              print_text(stderr, text_statement(module,margin,st,&pdl));
              gen_free_list(pdl);
            }
            fprintf(stderr, "--\n%*sPreds:", margin, "");
            MAPL(ps,{
                int so = statement_ordering(control_statement(CONTROL(CAR(ps))));
                fprintf(stderr,"%p (%d,%d), ", CONTROL(CAR(ps)),
                        ORDERING_NUMBER(so), ORDERING_STATEMENT(so));
            }, control_predecessors(n));
            fprintf(stderr, "\n%*sSuccs:", margin, "") ;
            MAPL(ss,{
                int so = statement_ordering(control_statement(CONTROL(CAR(ss))));
                fprintf(stderr,"%p (%d,%d), ", CONTROL(CAR(ss)),
                        ORDERING_NUMBER(so), ORDERING_STATEMENT(so));
            }, control_successors(n));
            fprintf(stderr, "\n\n") ;
        }, centry , blocks) ;
        gen_free_list(blocks);
    }
 
    if (get_bool_property("PRETTYPRINT_UNSTRUCTURED_AS_A_GRAPH"))
    {
        output_a_graph_view_of_the_unstructured
            (r, module, label, margin, u, num);
    }
    else {
        list trail = NIL;
 
        if(get_bool_property("PRETTYPRINT_UNSTRUCTURED")) {
            list pbeg = CHAIN_SWORD(NIL, "BEGIN UNSTRUCTURED");
            unformatted unf = make_unformatted(strdup(get_comment_sentinel()), num, margin, pbeg);
 
            ADD_SENTENCE_TO_TEXT(r, 
                                 make_sentence(is_sentence_unformatted, unf));
        }
 
        /* build an arbitrary reverse trail of control nodes */
        trail = unstructured_to_trail(u);
        debug(3, "text_unstructured", "Trail length: %d\n", gen_length(trail));
 
        trail = gen_nreverse(trail);
 
        ifdebug(3)
            dump_trail(trail);
 
        /* decorate control nodes with labels when necessary */
        decorate_trail(module, trail, labels);
 
        ifdebug(3)
            dump_control_to_label_name(labels);
 
        /* generate text with labels and goto's */
 
        MERGE_TEXTS(r, text_trail(module, margin, trail, labels, ppdl));
 
        if(get_bool_property("PRETTYPRINT_UNSTRUCTURED")) {
            list pend = CHAIN_SWORD(NIL, "END UNSTRUCTURED");
            unformatted unf = make_unformatted(strdup(get_comment_sentinel()), num, margin, pend);
            ADD_SENTENCE_TO_TEXT(r, 
                                 make_sentence(is_sentence_unformatted, unf));
        }
        gen_free_list(trail);
    }
 
    hash_table_free(labels) ;
 
    debug(2, "text_unstructured", "End for unstructured %p\n", u);
 
    return(r) ;
}

References ADD_SENTENCE_TO_TEXT, blocks, CAR, CHAIN_SWORD, CONTROL, CONTROL_MAP, control_predecessors, control_statement, control_successors, debug(), decorate_trail(), dump_control_to_label_name(), dump_trail(), fprintf(), gen_free_list(), gen_length(), gen_nreverse(), get_bool_property(), get_comment_sentinel(), hash_pointer, hash_table_free(), hash_table_make(), ifdebug, is_sentence_unformatted, make_sentence(), make_text(), make_unformatted(), MAPL, MERGE_TEXTS, module, NIL, num, ORDERING_NUMBER, ORDERING_STATEMENT, output_a_graph_view_of_the_unstructured(), print_text(), statement_identification(), statement_ordering, strdup(), text_statement(), text_trail(), unstructured_control, unstructured_exit, and unstructured_to_trail().

Referenced by text_instruction().

Here is the call graph for this function:

Here is the caller graph for this function:

type_to_full_string_definition()

string type_to_full_string_definition

(

type

t

)

type.c

type.c

FI: I am not sure about the language used.

Definition at line 45 of file type.c.

{
  debug_on("PRETTYPRINT_DEBUG_LEVEL");
  list pdl = NIL;
  string s = words_to_string(words_type(t, &pdl, false));
  gen_free_list(pdl);
  debug_off();
  return s;
}

References debug_off, debug_on, gen_free_list(), NIL, words_to_string(), and words_type().

Referenced by adapt_reference_to_type(), add_sizeof_value(), filter_formal_context_according_to_actual_context(), find_kth_points_to_node_in_points_to_path(), intrinsic_call_to_points_to(), new_filter_formal_context_according_to_actual_context(), pips_user_value_name(), print_value_mappings(), type_compatible_super_cell(), type_compatible_with_points_to_cell_p(), and type_to_sizeof_value().

Here is the call graph for this function:

Here is the caller graph for this function:

unstructured_to_trail()

list unstructured_to_trail

(

unstructured

u

)

The exit node must be first (i.e. last) to reach the continuation of the unstructured, or never reached (e.g. because the program loops forever or stops in the unstructured).

Definition at line 240 of file unstructured.c.

{
    list trail = NIL;
    control centry = unstructured_control(u) ;
    control cexit = unstructured_exit(u) ;
 
    trail = build_trail(trail, centry);
 
        /* The exit node *must* be first (i.e. last) to reach the continuation
         * of the unstructured, or never reached (e.g. because the program loops
         * forever or stops in the unstructured).
         */
    if(control_in_trail_p(trail, cexit)) {
        if(cexit!=CONTROL(CAR(trail))) {
            gen_remove(&trail, cexit);
            trail = CONS(CONTROL, cexit, trail);
        }
    }
 
    return trail;
}

References build_trail(), CAR, CONS, CONTROL, control_in_trail_p(), gen_remove(), NIL, unstructured_control, and unstructured_exit.

Referenced by c_unstructured(), ensure_comment_consistency(), last_statement(), new_points_to_unstructured(), and text_unstructured().

Here is the call graph for this function:

Here is the caller graph for this function:

user_view_p()

bool user_view_p

(

void

)

print_code or print_source

Definition at line 95 of file print.c.

{
    return is_user_view;
}

References is_user_view.

words_any_reference()

list words_any_reference	(	reference	,
		list *	,
		const char *	*)(entity
	)

Words_Any_Reference()

list Words_Any_Reference	(	reference	,
		list	,
		const char *	*)(entity
	)

words_basic()

list words_basic	(	basic	obj,
		list *	ppdl
	)

what about simple DOUBLE PRECISION, REAL, INTEGER...

This may happen in debugging statements

if(basic_int(obj)==4) { pc = CHAIN_SWORD(pc,"INTEGER"); } else {

FI: Use "bool" of stdbool.h instead of "int" but it leads to include issue for generated code; avoid stdbool.h and use "_Bool" directly but it leads to infinite loop from "_Bool" to "_Bool" because "_Bool" is declared as a typedef in anr999

should be a user error? Or simply bootstrap.c is not accurate?

ignore if it is signed or unsigned

The following code maybe redundant, because of tests in c_words_entity

This may occur in the parser when a variable is used before it is fully defined (see ptr in decl42.c)

FI: This space may not be always useful

Parameters

obj	bj
ppdl	pdl

Definition at line 323 of file declarations.c.

{
  list pc = NIL;
 
  if ( basic_undefined_p(obj) ) {
    /* This may happen in debugging statements */
    pc = CHAIN_SWORD(pc,"undefined");
  } else {
    switch ( basic_tag(obj) ) {
      case is_basic_int: {
        switch(get_prettyprint_language_tag()) {
          case is_language_fortran:
          case is_language_fortran95:
/*            if(basic_int(obj)==4) {
              pc = CHAIN_SWORD(pc,"INTEGER");
            } else { */
              pc = CHAIN_SWORD(pc,"INTEGER*");
              pc = CHAIN_IWORD(pc,basic_int(obj));
//            }
            break;
          case is_language_c:
          {
            string pn;
            switch (basic_int(obj)) {
              // FC: if the numbering was nice, it could use an array...
            case 1: pn = "PRETTYPRINT_C_CHAR_TYPE";
              break;
            case 2: pn = "PRETTYPRINT_C_SHORT_TYPE";
              break;
            case 4: pn = "PRETTYPRINT_C_INT_TYPE";
              break;
            case 6: pn = "PRETTYPRINT_C_LONG_TYPE";
              break;
            case 8: pn = "PRETTYPRINT_C_LONGLONG_TYPE";
              break;
            case 9: pn = "PRETTYPRINT_C_INT128_TYPE";
              break;
            case 11: pn = "PRETTYPRINT_C_UCHAR_TYPE";
              break;
            case 12: pn = "PRETTYPRINT_C_USHORT_TYPE";
              break;
            case 14: pn = "PRETTYPRINT_C_UINT_TYPE";
              break;
            case 16: pn = "PRETTYPRINT_C_ULONG_TYPE";
              break;
            case 18: pn = "PRETTYPRINT_C_ULONGLONG_TYPE";
              break;
            case 19: pn = "PRETTYPRINT_C_UINT128_TYPE";
              break;
            case 21: pn = "PRETTYPRINT_C_SCHAR_TYPE";
              break;
            case 22: pn = "PRETTYPRINT_C_SSHORT_TYPE";
              break;
            case 24: pn = "PRETTYPRINT_C_SINT_TYPE";
              break;
            case 26: pn = "PRETTYPRINT_C_SLONG_TYPE";
              break;
            case 28: pn = "PRETTYPRINT_C_SLONGLONG_TYPE";
              break;
            default:
              pips_internal_error("Unexpected int number %d\n", basic_int(obj));
            }
            pc = CHAIN_SWORD(pc, get_string_property(pn));
            break;
          }
        default:
          pips_internal_error("Language unknown !");
          break;
        }
        break;
      }
      case is_basic_float: {
        switch(get_prettyprint_language_tag()) {
          case is_language_fortran:
          case is_language_fortran95:
            pc = CHAIN_SWORD(pc,"REAL*");
            pc = CHAIN_IWORD(pc,basic_float(obj));
            break;
          case is_language_c:
            switch ( basic_float(obj) ) {
              case 4:
                pc = CHAIN_SWORD(pc,"float");
                break;
              case 8:
                pc = CHAIN_SWORD(pc,"double");
                break;
              case 16:
                pc = CHAIN_SWORD(pc,"long double");
                break;
            }
            break;
          default:
            pips_internal_error("Language unknown !");
            break;
        }
        break;
      }
      case is_basic_logical: {
        switch(get_prettyprint_language_tag()) {
          case is_language_fortran:
            pc = CHAIN_SWORD(pc,"LOGICAL*");
            pc = CHAIN_IWORD(pc,basic_logical(obj));
            break;
          case is_language_c:
            pc = CHAIN_SWORD(pc,"int"); /* FI: Use "bool" of stdbool.h instead
                                            of "int" but it leads to
                                            include issue for
                                            generated code; avoid stdbool.h
                                            and use "_Bool" directly
                                            but it leads to infinite
                                            loop from "_Bool" to
                                            "_Bool" because "_Bool"
                                            is declared as a typedef
                                            in anr999 */
            break;
          case is_language_fortran95:
            pips_internal_error("Need to update F95 case");
            break;
          default:
            pips_internal_error("Language unknown !");
            break;
        }
        break;
      }
      case is_basic_overloaded: {
        /* should be a user error? Or simply bootstrap.c is not accurate? */
        switch(get_prettyprint_language_tag()) {
          case is_language_fortran:
            pc = CHAIN_SWORD(pc,"OVERLOADED");
            break;
          case is_language_c:
            pc = CHAIN_SWORD(pc,"overloaded");
            break;
          case is_language_fortran95:
            pips_internal_error("Need to update F95 case");
            break;
          default:
            pips_internal_error("Language unknown !");
            break;
        }
        break;
      }
      case is_basic_complex: {
        switch(get_prettyprint_language_tag()) {
          case is_language_fortran:
          case is_language_fortran95:
            pc = CHAIN_SWORD(pc,"COMPLEX*");
            pc = CHAIN_IWORD(pc,basic_complex(obj));
            break;
          case is_language_c:
            switch ( basic_complex(obj) ) {
              case 8:
                pc = CHAIN_SWORD(pc,"_Complex");
                break;
              case 9:
                pc = CHAIN_SWORD(pc,"float _Complex");
                break;
              case 16:
                pc = CHAIN_SWORD(pc,"double _Complex");
                break;
              case 32:
                pc = CHAIN_SWORD(pc,"long double _Complex");
                break;
              default:
                pips_internal_error("Unexpected complex size");
            }
            break;
          default:
            pips_internal_error("Language unknown !");
            break;
        }
        break;
      }
      case is_basic_string: {
        switch(get_prettyprint_language_tag()) {
          case is_language_fortran:
            pc = CHAIN_SWORD(pc,"CHARACTER*");
            pc = gen_nconc( pc, words_value( basic_string(obj) ) );
            break;
          case is_language_c:
            pc = CHAIN_SWORD(pc,"char *"); // FI: should it be char[]?
            break;
          case is_language_fortran95:
            pips_internal_error("Need to update F95 case");
            break;
          default:
            pips_internal_error("Language unknown !");
            break;
        }
        break;
      }
      case is_basic_bit: {
        symbolic bs = basic_bit(obj);
        int i = constant_int(symbolic_constant(bs));
        pips_debug(7,"Bit field basic: %d\n",i);
        pc = CHAIN_SWORD(pc,"int"); /* ignore if it is signed or unsigned */
        break;
      }
      /* The following code maybe redundant, because of tests in c_words_entity*/
      case is_basic_pointer: {
        type t = basic_pointer(obj);
        pips_debug(7,"Basic pointer\n");
        if ( type_undefined_p(t) ) {
          /* This may occur in the parser when a variable is used
           before it is fully defined (see ptr in decl42.c) */
          pc = CHAIN_SWORD(pc,"type_undefined *");
        } else {
          pc = gen_nconc( pc, words_type( t, ppdl, false ) );
          pc = CHAIN_SWORD(pc," *");
        }
        break;
      }
      case is_basic_derived: {
        entity ent = basic_derived(obj);
        const char* name = entity_user_name( ent );
        const char* lname = entity_local_name( ent );
        type t = entity_type(ent);
 
        if ( strstr( lname, STRUCT_PREFIX DUMMY_STRUCT_PREFIX ) == NULL
            && strstr( lname, UNION_PREFIX DUMMY_UNION_PREFIX ) == NULL
            && strstr( lname, ENUM_PREFIX DUMMY_ENUM_PREFIX ) == NULL ) {
          pc = gen_nconc( pc, words_type( t, ppdl, false ) );
          pc = CHAIN_SWORD(pc," ");
          pc = CHAIN_SWORD(pc,name);
          pc = CHAIN_SWORD(pc," "); /* FI: This space may not be always useful */
        } else {
          pc = gen_nconc( pc, c_words_entity( t, NIL, ppdl ) );
        }
        break;
      }
      case is_basic_typedef: {
        entity ent = basic_typedef(obj);
        pc = CHAIN_SWORD(pc,entity_user_name(ent));
        break;
      }
      default:
        pips_internal_error("unexpected basic tag %d", basic_tag(obj));
    }
  }
  return(pc);
}

References basic_bit, basic_complex, basic_derived, basic_float, basic_int, basic_logical, basic_pointer, basic_string, basic_tag, basic_typedef, basic_undefined_p, c_words_entity(), CHAIN_IWORD, CHAIN_SWORD, constant_int, DUMMY_ENUM_PREFIX, DUMMY_STRUCT_PREFIX, DUMMY_UNION_PREFIX, entity_local_name(), entity_type, entity_user_name(), ENUM_PREFIX, gen_nconc(), get_prettyprint_language_tag(), get_string_property(), is_basic_bit, is_basic_complex, is_basic_derived, is_basic_float, is_basic_int, is_basic_logical, is_basic_overloaded, is_basic_pointer, is_basic_string, is_basic_typedef, is_language_c, is_language_fortran, is_language_fortran95, lname(), NIL, pips_debug, pips_internal_error, STRUCT_PREFIX, symbolic_constant, type_undefined_p, UNION_PREFIX, words_type(), and words_value().

Referenced by basic_to_string(), find_or_create_allocatable_struct(), sentence_head(), sentence_variable(), and words_type().

Here is the call graph for this function:

Here is the caller graph for this function:

words_brace_expression()

list words_brace_expression	(	expression	exp,
		list *	ppdl
	)

Parameters

exp	xp
ppdl	pdl

Definition at line 910 of file declarations.c.

{
  list pc = NIL;
  list args = call_arguments(syntax_call(expression_syntax(exp)));
  bool first = true;
  bool space_p = get_bool_property("PRETTYPRINT_LISTS_WITH_SPACES");
 
  pc = CHAIN_SWORD(pc,"{");
  MAP(EXPRESSION,e,
  {
    if (!first)
      pc = CHAIN_SWORD(pc, space_p? ", " : ",");
    if (c_brace_expression_p(e))
      pc = gen_nconc(pc,words_brace_expression(e, ppdl));
    else
      pc = gen_nconc(pc,words_expression(e, ppdl));
    first = false;
  },args);
  pc = CHAIN_SWORD(pc,"}");
  return pc;
}

References c_brace_expression_p(), call_arguments, CHAIN_SWORD, exp, EXPRESSION, expression_syntax, gen_nconc(), get_bool_property(), MAP, NIL, syntax_call, and words_expression().

Referenced by words_brace_op(), and words_variable_or_function().

Here is the call graph for this function:

Here is the caller graph for this function:

Words_Call()

list Words_Call	(	call	obj,
		int	precedence,
		bool	leftmost,
		bool	is_a_subroutine
	)

Parameters

obj	bj
precedence	recedence
leftmost	eftmost
is_a_subroutine	s_a_subroutine

Definition at line 2597 of file misc.c.

{
  list npdl = NIL;
  list pc = words_call(obj, precedence, leftmost, is_a_subroutine, &npdl);
  gen_free_list(npdl);
  return pc;
}

References gen_free_list(), NIL, and words_call().

Referenced by defs_elim_of_assign_call(), do_simdizer_init(), io_filter(), and text_loop_cmf().

Here is the call graph for this function:

Here is the caller graph for this function:

words_call()

list words_call	(	call	obj,
		int	precedence,
		bool	leftmost,
		bool	is_a_subroutine,
		list *	ppdl
	)

exported for cmfortran.c

Parameters

obj	bj
precedence	recedence
leftmost	eftmost
is_a_subroutine	s_a_subroutine
ppdl	pdl

Definition at line 2575 of file misc.c.

{
  list pc;
  entity f = call_function(obj);
  value i = entity_initial(f);
 
  if(value_intrinsic_p(i)) {
    int effective_precedence = (precedence_p||precedence<=1)?
      precedence : MAXIMAL_PRECEDENCE;
 
    pc = words_intrinsic_call(obj, effective_precedence, leftmost, ppdl);
  }
  else
    pc = words_genuine_regular_call(obj, is_a_subroutine, ppdl);
  return pc;
}

References call_function, entity_initial, f(), MAXIMAL_PRECEDENCE, precedence_p, value_intrinsic_p, words_genuine_regular_call(), and words_intrinsic_call().

Referenced by text_instruction(), text_logical_if(), Words_Call(), words_subexpression(), and words_syntax().

Here is the call graph for this function:

Here is the caller graph for this function:

words_call_intrinsic()

list words_call_intrinsic	(	call	,
		int	,
		bool	,
		list *
	)

words_cmf_loop_range()

cons* words_cmf_loop_range

(

range

obj

)

cmfortran.c

cmfortran.c

There are memory leaks here since a new expression is constructed. =====================================================================

expression_constant_p(range_increment(obj)) &&

Parameters

obj

bj

Definition at line 46 of file cmfortran.c.

{
    cons *pc;
    call c = syntax_call(expression_syntax(range_increment(obj)));
 
    pc = Words_Subexpression(range_lower(obj), 0, true);
    pc = CHAIN_SWORD(pc,":");
    pc = gen_nconc(pc, Words_Subexpression(range_upper(obj), 0, true));
    if (/*  expression_constant_p(range_increment(obj)) && */
         strcmp( entity_local_name(call_function(c)), "1") == 0 )
        return(pc);
    pc = CHAIN_SWORD(pc,":");
    pc = gen_nconc(pc, Words_Expression(range_increment(obj)));
 
    return(pc);
}

References call_function, CHAIN_SWORD, entity_local_name(), expression_syntax, gen_nconc(), range_increment, range_lower, range_upper, syntax_call, Words_Expression(), and Words_Subexpression().

Referenced by text_loop_cmf().

Here is the call graph for this function:

Here is the caller graph for this function:

words_declaration()

list words_declaration	(	entity	e,
		bool	prettyprint_common_variable_dimensions_p,
		list *	ppdl
	)

declarations.c

declarations.c

this is the case of g77 used after hpfc. thus I added a flag not to prettyprint again the dimensions of common variables. FC.

It is in the standard that dimensions cannot be declared twice in a single module. BC.

Parameters

prettyprint_common_variable_dimensions_p	rettyprint_common_variable_dimensions_p
ppdl	pdl

Definition at line 277 of file declarations.c.

                                    {
  list pl = NIL;
  bool space_p = get_bool_property("PRETTYPRINT_LISTS_WITH_SPACES");
 
  pl = CHAIN_SWORD(pl, entity_user_name(e));
 
  if (type_variable_p(entity_type(e))) {
    if (prettyprint_common_variable_dimensions_p || !(variable_in_common_p(e)
        || variable_static_p(e))) {
      if (variable_dimensions(type_variable(entity_type(e))) != NIL) {
        list dims = variable_dimensions(type_variable(entity_type(e)));
 
        switch(get_prettyprint_language_tag()) {
          case is_language_fortran:
          case is_language_fortran95:
            pl = CHAIN_SWORD(pl, "(");
            MAPL(pd,
                {
                  pl = gen_nconc(pl, words_dimension(DIMENSION(CAR(pd)), ppdl));
                  if (CDR(pd) != NIL) pl = CHAIN_SWORD(pl, space_p? ", " : ",");
                }, dims)
            ;
            pl = CHAIN_SWORD(pl, ")");
            break;
          case is_language_c:
            MAPL(pd,
                {
                  pl = CHAIN_SWORD(pl, "[");
                  pl = gen_nconc(pl, words_dimension(DIMENSION(CAR(pd)), ppdl));
                  pl = CHAIN_SWORD(pl, "]");
                }, dims)
            ;
            break;
          default:
            pips_internal_error("Language unknown !");
        }
      }
    }
  }
  attach_declaration_to_words(pl, e);
  return (pl);
}

References attach_declaration_to_words(), CAR, CDR, CHAIN_SWORD, DIMENSION, entity_type, entity_user_name(), gen_nconc(), get_bool_property(), get_prettyprint_language_tag(), is_language_c, is_language_fortran, is_language_fortran95, MAPL, NIL, pips_internal_error, pl, type_variable, type_variable_p, variable_dimensions, variable_in_common_p(), variable_static_p(), and words_dimension().

Referenced by loop_private_variables(), sentence_area(), sentence_variable(), and text_entity_declaration().

Here is the call graph for this function:

Here is the caller graph for this function:

words_dimensions()

list words_dimensions	(	list	dims,
		list *	ppdl
	)

Parameters

dims	ims
ppdl	pdl

Definition at line 932 of file declarations.c.

{
  list pc = NIL;
  bool space_p = get_bool_property("PRETTYPRINT_LISTS_WITH_SPACES");
 
  switch(get_prettyprint_language_tag()) {
    case is_language_fortran:
    case is_language_fortran95: {
      pc = CHAIN_SWORD(pc, "(");
      string spacer = "";
      FOREACH(dimension,d,dims) {
        pc = CHAIN_SWORD(pc, spacer);
        pc = gen_nconc(pc, words_dimension(d, ppdl));
        spacer = space_p ? ", " : ",";
      }
      pc = CHAIN_SWORD(pc, ")");
      break;
    }
    case is_language_c: {
      FOREACH(dimension,d,dims) {
        pc = CHAIN_SWORD(pc, "[");
        pc = gen_nconc(pc, words_dimension(d, ppdl));
        pc = CHAIN_SWORD(pc, "]");
      }
      break;
    }
    default:
      pips_internal_error("Language unknown !");
      break;
  }
  return pc;
}

References CHAIN_SWORD, FOREACH, gen_nconc(), get_bool_property(), get_prettyprint_language_tag(), is_language_c, is_language_fortran, is_language_fortran95, NIL, pips_internal_error, and words_dimension().

Referenced by generic_c_words_simplified_entity(), get_symbol_table(), and words_type().

Here is the call graph for this function:

Here is the caller graph for this function:

Words_Expression()

list Words_Expression

(

expression

obj

)

of string

Parameters

obj

bj

Definition at line 2616 of file misc.c.

{
  return Words_Syntax(expression_syntax(obj));
}

References expression_syntax, and Words_Syntax().

Referenced by can_terapixify_expression_p(), effect_words_reference(), eval_var(), reference_conversion_expression(), words_cmf_loop_range(), words_loop_list(), words_numerical_dimension(), and words_test_list().

Here is the call graph for this function:

Here is the caller graph for this function:

words_expression()

list words_expression	(	expression	obj,
		list *	ppdl
	)

This one is exported.

Outer parentheses are never useful. ppdl can point to an empty list, but it must be free on return of string

Parameters

obj	bj
ppdl	pdl

Definition at line 2611 of file misc.c.

{
  return words_syntax(expression_syntax(obj), ppdl);
}

References expression_syntax, and words_syntax().

Referenced by adg_fprint_list_of_exp(), C_loop_range(), ensure_comment_consistency(), expression_to_string(), fprint_list_of_exp(), generic_c_words_simplified_entity(), imprime_special_quast(), maxima_simplify(), pragma_to_string(), sentence_data_statement(), sentence_symbolic(), text_block_elseif(), text_block_ifthen(), text_entity_declaration(), text_instruction(), text_logical_if(), text_loop_craft(), text_trail(), text_whileloop(), words_brace_expression(), words_dimension(), words_enum(), words_implied_do(), words_io_control(), words_io_inst(), words_loop_range(), words_omp_red(), words_range(), words_stat_io_inst(), words_subscript_range(), words_va_arg(), and words_variable_or_function().

Here is the call graph for this function:

Here is the caller graph for this function:

words_goto_label()

list words_goto_label

(

const char *

tlabel

)

This function is useful only for parsed codes since gotos are removed by the controlizer.

of string

<<<<<< .working switch (get_prettyprint_language_tag()) { case is_language_fortran: case is_language_fortran95: pc = CHAIN_SWORD(pc, RETURN_FUNCTION_NAME); break; case is_language_c: pc = CHAIN_SWORD(pc, C_RETURN_FUNCTION_NAME); pc = CHAIN_SWORD(pc, ";"); break; default: pips_internal_error("Language unknown !"); break;

}

In C, a label cannot begin with a number so "l" is added for this case

In C, a label cannot begin with a number so "l" is added for this case

Parameters

tlabel

label

Definition at line 1917 of file misc.c.

{
    list pc = NIL;
  if (strcmp(tlabel, RETURN_LABEL_NAME) == 0) {
    /*<<<<<<< .working
    switch (get_prettyprint_language_tag()) {
    case is_language_fortran:
    case is_language_fortran95:
      pc = CHAIN_SWORD(pc, RETURN_FUNCTION_NAME);
      break;
    case is_language_c:
      pc = CHAIN_SWORD(pc, C_RETURN_FUNCTION_NAME);
      pc = CHAIN_SWORD(pc, ";");
      break;
    default:
      pips_internal_error("Language unknown !");
      break;
    }
    =======*/
    switch (get_prettyprint_language_tag()) {
    case is_language_fortran:
    case is_language_fortran95:
      pc = CHAIN_SWORD(pc, RETURN_FUNCTION_NAME);
      break;
    case is_language_c: {
      entity f = get_current_module_entity();
 
      if(void_function_p(f)) {
      // FI: this hides the parsed code structure and is wrong
      // in C because a value may have to be returned;
        pc = CHAIN_SWORD(pc, C_RETURN_FUNCTION_NAME);
        pc = CHAIN_SWORD(pc, ";");
      }
      else {
        entity rv = function_to_return_value(f);
        pc = CHAIN_SWORD(pc, C_RETURN_FUNCTION_NAME" ");
        pc = CHAIN_SWORD(pc, entity_user_name(rv));
        pc = CHAIN_SWORD(pc, ";");
      }
      if(false) {
        // the gotos are maintained, but the final return must be printed out
        // FI: this would only work if the final return were printed
        // out for sure and with its label
        /* In C, a label cannot begin with a number so "l" is added
           for this case*/
        pc = CHAIN_SWORD(pc, strdup((isdigit(tlabel[0])?"goto l":"goto ")));
        pc = CHAIN_SWORD(pc, tlabel);
        pc = CHAIN_SWORD(pc, C_CONTINUE_FUNCTION_NAME);
      }
      break;
    }
    default:
      pips_internal_error("Language unknown !");
      break;
    }
    //>>>>>>> .merge-right.r18859
  } else {
    switch (get_prettyprint_language_tag()) {
      case is_language_fortran:
      case is_language_fortran95:
        pc = CHAIN_SWORD(pc, strdup("GOTO "));
        pc = CHAIN_SWORD(pc, tlabel);
        break;
      case is_language_c:
        /* In C, a label cannot begin with a number so "l" is added
           for this case*/
        pc = CHAIN_SWORD(pc, strdup((isdigit(tlabel[0])?"goto l":"goto ")));
        pc = CHAIN_SWORD(pc, tlabel);
        pc = CHAIN_SWORD(pc, C_CONTINUE_FUNCTION_NAME);
        break;
      default:
        pips_internal_error("Language unknown !");
        break;
    }
  }
  return pc;
}

References C_CONTINUE_FUNCTION_NAME, C_RETURN_FUNCTION_NAME, CHAIN_SWORD, entity_user_name(), f(), function_to_return_value(), get_current_module_entity(), get_prettyprint_language_tag(), is_language_c, is_language_fortran, is_language_fortran95, NIL, pips_internal_error, RETURN_FUNCTION_NAME, RETURN_LABEL_NAME, strdup(), and void_function_p().

Referenced by sentence_goto_label(), and text_trail().

Here is the call graph for this function:

Here is the caller graph for this function:

words_loop_range()

list words_loop_range	(	range	obj,
		list *	ppdl
	)

exported for craft

expression_constant_p(range_increment(obj)) &&

Parameters

obj	bj
ppdl	pdl

Definition at line 434 of file misc.c.

                                              {
    list pc;
    call c = syntax_call(expression_syntax(range_increment(obj)));
 
    pc = words_subexpression(range_lower(obj), 0, true, ppdl);
    pc = CHAIN_SWORD(pc,", ");
    pc = gen_nconc(pc, words_subexpression(range_upper(obj), 0, true, ppdl));
    if (/*  expression_constant_p(range_increment(obj)) && */
         strcmp( entity_local_name(call_function(c)), "1") == 0 )
        return(pc);
    pc = CHAIN_SWORD(pc,", ");
    pc = gen_nconc(pc, words_expression(range_increment(obj), ppdl));
 
    return(pc);
}

References call_function, CHAIN_SWORD, entity_local_name(), expression_syntax, gen_nconc(), range_increment, range_lower, range_upper, syntax_call, words_expression(), and words_subexpression().

Referenced by text_loop_craft(), text_loop_default(), and words_implied_do().

Here is the call graph for this function:

Here is the caller graph for this function:

words_qualifiers()

list words_qualifiers

(

list

obj

)

Parameters

obj

bj

Definition at line 795 of file declarations.c.

{
  return generic_words_qualifiers(obj, true, true);
}

References generic_words_qualifiers().

Referenced by c_text_related_entities(), generic_c_words_simplified_entity(), get_symbol_table(), print_qualifiers(), sentence_head(), words_dimension(), and words_type().

Here is the call graph for this function:

Here is the caller graph for this function:

words_range()

list words_range	(	range	obj,
		list *	ppdl
	)

Returns

a list of string

if undefined I print a star, why not!?

C does not include ranges, but the PIPS internal representation does. For instance, constant ranges can be useful to express effects or regions for intrinsics. To be discussed with Beatrice: e.g. memcpy(), strncp(). Especially when they are called with constant arguments.

Parameters

obj	bj
ppdl	pdl

Definition at line 538 of file misc.c.

                                         {
  list pc = NIL;
 
  /* if undefined I print a star, why not!? */
  if(expression_undefined_p(range_lower(obj))) {
    pc = CONS(STRING, MAKE_SWORD("*"), NIL);
  } else {
    switch(get_prettyprint_language_tag()) {
    case is_language_fortran: {
      call c = syntax_call(expression_syntax(range_increment(obj)));
 
      pc = CHAIN_SWORD(pc,"(/ (I,I=");
      pc = gen_nconc(pc, words_expression(range_lower(obj), ppdl));
      pc = CHAIN_SWORD(pc,",");
      pc = gen_nconc(pc, words_expression(range_upper(obj), ppdl));
      if(strcmp(entity_local_name(call_function(c)), "1") != 0) {
        pc = CHAIN_SWORD(pc,",");
        pc = gen_nconc(pc, words_expression(range_increment(obj), ppdl));
      }
      pc = CHAIN_SWORD(pc,") /)") ;
      break;
    }
    case is_language_fortran95: {
      // Print the lower bound if != *
      if(!unbounded_expression_p(range_lower(obj))) {
        pc = gen_nconc(pc, words_expression(range_lower(obj), ppdl));
      }
 
      // Print the upper bound if != *
      pc = CHAIN_SWORD(pc,":");
      if(!unbounded_expression_p(range_upper(obj))) {
        pc = gen_nconc(pc, words_expression(range_upper(obj), ppdl));
      }
 
      // Print the increment if != 1
      call c = syntax_call(expression_syntax(range_increment(obj)));
      if(strcmp(entity_local_name(call_function(c)), "1") != 0) {
        pc = CHAIN_SWORD(pc,":");
        pc = gen_nconc(pc, words_expression(range_increment(obj), ppdl));
      }
      break;
    }
    case is_language_c:
      /* C does not include ranges, but the PIPS internal
         representation does. For instance, constant ranges can be
         useful to express effects or regions for intrinsics. To be
         discussed with Beatrice: e.g. memcpy(), strncp(). Especially
         when they are called with constant arguments. */
 
      // FI: we might still want a warning, but the compiler will
      // choke anyway if this is used to prettyprint some C source code
      // pips_internal_error("I don't know how to print a range in C !");
 
      // FI: copied from Fortran 95, but we may prefer to see the stars
 
      // Print the lower bound if != *
      if(!unbounded_expression_p(range_lower(obj))) {
        pc = gen_nconc(pc, words_expression(range_lower(obj), ppdl));
      }
 
      // Print the upper bound if != *
      pc = CHAIN_SWORD(pc,":");
      if(!unbounded_expression_p(range_upper(obj))) {
        pc = gen_nconc(pc, words_expression(range_upper(obj), ppdl));
      }
 
      // Print the increment if != 1
      call c = syntax_call(expression_syntax(range_increment(obj)));
      if(strcmp(entity_local_name(call_function(c)), "1") != 0) {
        pc = CHAIN_SWORD(pc,":");
        pc = gen_nconc(pc, words_expression(range_increment(obj), ppdl));
      }
 
      break;
    default:
      pips_internal_error("Language unknown !");
      break;
    }
  }
  return pc;
}

References call_function, CHAIN_SWORD, CONS, entity_local_name(), expression_syntax, expression_undefined_p, gen_nconc(), get_prettyprint_language_tag(), is_language_c, is_language_fortran, is_language_fortran95, MAKE_SWORD, NIL, pips_internal_error, range_increment, range_lower, range_upper, STRING, syntax_call, unbounded_expression_p(), and words_expression().

Referenced by make_bounds(), and words_syntax().

Here is the call graph for this function:

Here is the caller graph for this function:

Words_Reference()

list Words_Reference

(

reference

obj

)

Parameters

obj

bj

Definition at line 786 of file misc.c.

{
  return Words_Any_Reference(obj, NIL, entity_user_name);
}

References entity_user_name(), NIL, and Words_Any_Reference().

Referenced by text_region_no_action(), and words_reduction().

Here is the call graph for this function:

Here is the caller graph for this function:

words_reference()

list words_reference	(	reference	obj,
		list *	ppdl
	)

Parameters

obj	bj
ppdl	pdl

Definition at line 781 of file misc.c.

{
  return words_any_reference(obj, ppdl, entity_user_name);
}

References entity_user_name(), and words_any_reference().

Referenced by adg_fprint_dataflow(), fprint_reference(), reference_to_string(), and words_syntax().

Here is the call graph for this function:

Here is the caller graph for this function:

Words_Regular_Call()

list Words_Regular_Call	(	call	obj,
		bool	is_a_subroutine
	)

Parameters

obj	bj
is_a_subroutine	s_a_subroutine

Definition at line 1081 of file misc.c.

{
  list pdl = NIL;
  list pc = words_regular_call(obj, is_a_subroutine, &pdl);
  gen_free_list(pdl);
  return pc;
}

References gen_free_list(), NIL, and words_regular_call().

Referenced by get_sp_of_call_p().

Here is the call graph for this function:

Here is the caller graph for this function:

words_regular_call()

list words_regular_call	(	call	obj,
		bool	is_a_subroutine,
		list *	ppdl
	)

words_regular_call used for user subroutine and user function and intrinsics called like user function such as MOD().

used also by library static_controlize

special cases for stdarg builtin macros

Special cases for stdio.h

else if (ENTITY__IO_GETC_P(f))

pc = CHAIN_SWORD(pc, "getc");

else if (ENTITY__IO_PUTC_P(f))

pc = CHAIN_SWORD(pc, "putc");

Special cases for Fortran intrinsics not available in C

the implied complex operator is hidden... [D]CMPLX_(x,y) -> (x,y)

The corresponding formal parameter cannot be checked by formal_label_replacement_p() because the called modules may not have been parsed yet.

Alternate return actual argument have been replaced by character strings by the parser.

pips_assert("ls has at least four characters", strlen(ls)>=4);

Get rid of initial and final quotes

free(ls1);

The actual label cannot always be used because it might have been eliminated as part of dead code by PIPS since it is not used with the STOP option.

The assertion may be wrong if this piece of code is used to print intermediate statements

words_expression cannot be called because of the C comma operator which require surrounding parentheses in this context. Be careful with unary minus.

alse

Parameters

obj	bj
is_a_subroutine	s_a_subroutine
ppdl	pdl

Definition at line 868 of file misc.c.

{
  list pc = NIL;
 
  entity f = call_function(obj);
  value i = entity_initial(f);
  type t = entity_type(f);
  bool space_p = get_bool_property("PRETTYPRINT_LISTS_WITH_SPACES");
 
  if (call_arguments(obj) == NIL) {
    if (type_statement_p(t))
      return (CHAIN_SWORD(pc, entity_local_name(f)+sizeof(LABEL_PREFIX) -1));
    if (value_constant_p(i) || value_symbolic_p(i)) {
      switch (get_prettyprint_language_tag()) {
      case is_language_fortran:
      case is_language_fortran95:
        return (CHAIN_SWORD(pc, entity_user_name(f)));
        break;
      case is_language_c:
        if (ENTITY_TRUE_P(f))
          return (CHAIN_SWORD(pc, "true"));
        if (ENTITY_FALSE_P(f))
          return (CHAIN_SWORD(pc, "false"));
        return (CHAIN_SWORD(pc, entity_user_name(f)));
        break;
      default:
        pips_internal_error("Language unknown !");
        break;
      }
    }
  }
 
  type calltype = call_compatible_type(entity_type(call_function(obj)));
  bool function_p = type_void_p(functional_result(type_functional(calltype)));
 
  if (function_p) {
    if (is_a_subroutine) {
      switch (get_prettyprint_language_tag()) {
      case is_language_fortran:
      case is_language_fortran95:
        pc = CHAIN_SWORD(pc, "CALL ");
        break;
      case is_language_c:
        pc = CHAIN_SWORD(pc, "");
        break;
      default:
        pips_internal_error("Language unknown !");
        break;
      }
    } else {
      switch (get_prettyprint_language_tag()) {
      case is_language_fortran:
        pips_user_warning("subroutine '%s' used as a function.\n",
                          entity_name(f));
        break;
      case is_language_c:
        // no warning in C
        break;
      case is_language_fortran95:
        pips_internal_error("Need to update F95 case");
        break;
      default:
        pips_internal_error("Language unknown !");
        break;
      }
    }
  } else if (is_a_subroutine) {
    switch (get_prettyprint_language_tag()) {
      case is_language_fortran:
      case is_language_fortran95:
        pips_user_warning("function '%s' used as a subroutine.\n",
                          entity_name(f));
        pc = CHAIN_SWORD(pc, "CALL ");
        break;
      case is_language_c:
        // no warning in C
        pc = CHAIN_SWORD(pc, "");
        break;
      default:
        pips_internal_error("Language unknown !");
        break;
    }
  }
 
  /* special cases for stdarg builtin macros */
  bool add_argument_count_p = false;
  if (ENTITY_VA_END_P(f)) {
    //pc = CHAIN_SWORD(pc, "va_end");
    pc = CHAIN_SWORD(pc, "__builtin_va_end");
  }
  else if (ENTITY_VA_START_P(f)) {
    //pc = CHAIN_SWORD(pc, "va_start");
    pc = CHAIN_SWORD(pc, "__builtin_va_start");
  }
  else if (ENTITY_VA_COPY_P(f)) {
    //pc = CHAIN_SWORD(pc, "va_copy");
    pc = CHAIN_SWORD(pc, "__builtin_va_copy");
  }
 
  /* Special cases for stdio.h */
  /* else if (ENTITY__IO_GETC_P(f)) */
/*     pc = CHAIN_SWORD(pc, "getc"); */
/*   else if (ENTITY__IO_PUTC_P(f)) */
/*     pc = CHAIN_SWORD(pc, "putc"); */
  else if (ENTITY_ISOC99_SCANF_P(f))
    pc = CHAIN_SWORD(pc, ISOC99_SCANF_USER_FUNCTION_NAME);
  else if (ENTITY_ISOC99_FSCANF_P(f))
    pc = CHAIN_SWORD(pc, ISOC99_FSCANF_USER_FUNCTION_NAME);
  else if (ENTITY_ISOC99_SSCANF_P(f))
    pc = CHAIN_SWORD(pc, ISOC99_SSCANF_USER_FUNCTION_NAME);
  else if (ENTITY_ISOC99_VFSCANF_P(f))
    pc = CHAIN_SWORD(pc, ISOC99_VFSCANF_USER_FUNCTION_NAME);
  else if (ENTITY_ISOC99_VSCANF_P(f))
    pc = CHAIN_SWORD(pc, ISOC99_VSCANF_USER_FUNCTION_NAME);
  else if (ENTITY_ISOC99_VSSCANF_P(f))
    pc = CHAIN_SWORD(pc, ISOC99_VSSCANF_USER_FUNCTION_NAME);
 
  /* Special cases for Fortran intrinsics not available in C */
  else if (ENTITY_MIN_P(f) && get_prettyprint_language_tag()==is_language_c
           && !get_bool_property("PRETTYPRINT_INTERNAL_INTRINSICS")) {
    add_argument_count_p = true;
    pc = CHAIN_SWORD(pc, PIPS_C_MIN_OPERATOR_NAME);
    }
  else if (ENTITY_MAX_P(f) && get_prettyprint_language_tag()==is_language_c
           && !get_bool_property("PRETTYPRINT_INTERNAL_INTRINSICS")) {
    add_argument_count_p = true;
    pc = CHAIN_SWORD(pc, PIPS_C_MAX_OPERATOR_NAME);
    }
 
  /* the implied complex operator is hidden... [D]CMPLX_(x,y) -> (x,y)
   */
  else if(!ENTITY_IMPLIED_CMPLX_P(f) && !ENTITY_IMPLIED_DCMPLX_P(f))
    pc = CHAIN_SWORD(pc, entity_user_name(f));
 
 
  /* The corresponding formal parameter cannot be checked by
     formal_label_replacement_p() because the called modules may not have
     been parsed yet. */
 
  if(!ENDP(call_arguments(obj))) {
    list pa = list_undefined;
    pc = CHAIN_SWORD(pc, "(");
 
    if(add_argument_count_p) {
      int n = gen_length(call_arguments(obj));
      string narg;
      asprintf(&narg,"%d", n);
      pc = CHAIN_SWORD(pc, narg);
      pc = CHAIN_SWORD(pc, ", ");
    }
 
    for(pa = call_arguments(obj); !ENDP(pa); POP(pa)) {
      expression eap = EXPRESSION(CAR(pa));
      if(get_bool_property("PRETTYPRINT_REGENERATE_ALTERNATE_RETURNS")
         && expression_call_p(eap) && actual_label_replacement_p(eap)) {
        /* Alternate return actual argument have been replaced by
           character strings by the parser. */
        entity cf = call_function(syntax_call(expression_syntax(eap)));
        const char* ls = entity_local_name(cf);
        string ls1 = malloc(strlen(ls));
        /* pips_assert("ls has at least four characters", strlen(ls)>=4); */
 
        /* Get rid of initial and final quotes */
        ls1 = strncpy(ls1, ls+1, strlen(ls)-2);
        *(ls1+strlen(ls)-2) = '\000';
        pips_assert("eap must be a call to a constant string", expression_call_p(eap));
        if(strcmp(get_string_property("PARSER_SUBSTITUTE_ALTERNATE_RETURNS"), "STOP")!=0) {
          pc = CHAIN_SWORD(pc, ls1);
          /* free(ls1); */
        }
        else {
          /* The actual label cannot always be used because it might have been
             eliminated as part of dead code by PIPS since it is not used
             with the STOP option. */
          if(label_string_defined_in_current_module_p(ls1+1)) {
            pc = CHAIN_SWORD(pc, ls1);
          }
          else {
            entity els1 = find_label_entity(get_current_module_name(), ls1+1);
 
            /* The assertion may be wrong if this piece of code is used to
               print intermediate statements */
            pips_assert("Label els1 has been defined although it is not used anymore",
                        !entity_undefined_p(els1));
 
            pc = CHAIN_SWORD(pc, ls1);
            add_target_to_alternate_return_set(els1);
          }
        }
      }
      else {
        /* words_expression cannot be called because of the C comma
           operator which require surrounding parentheses in this
           context. Be careful with unary minus. */
        pc = gen_nconc(pc, words_subexpression(EXPRESSION(CAR(pa)),
                                               ASSIGN_OPERATOR_PRECEDENCE,
                                               true/*false*/,
                                               ppdl));
      }
      if (CDR(pa) != NIL)
        pc = CHAIN_SWORD(pc, space_p? ", ": ",");
    }
 
    pc = CHAIN_SWORD(pc, ")");
  }
  else if(!type_void_p(functional_result(type_functional(t))) ||
          !is_a_subroutine || prettyprint_language_is_c_p()) {
    pc = CHAIN_SWORD(pc, "()");
  }
 
  return pc;
}

References actual_label_replacement_p(), add_target_to_alternate_return_set(), asprintf, ASSIGN_OPERATOR_PRECEDENCE, call_arguments, call_compatible_type(), call_function, CAR, CDR, CHAIN_SWORD, ENDP, ENTITY_FALSE_P, ENTITY_IMPLIED_CMPLX_P, ENTITY_IMPLIED_DCMPLX_P, entity_initial, ENTITY_ISOC99_FSCANF_P, ENTITY_ISOC99_SCANF_P, ENTITY_ISOC99_SSCANF_P, ENTITY_ISOC99_VFSCANF_P, ENTITY_ISOC99_VSCANF_P, ENTITY_ISOC99_VSSCANF_P, entity_local_name(), ENTITY_MAX_P, ENTITY_MIN_P, entity_name, ENTITY_TRUE_P, entity_type, entity_undefined_p, entity_user_name(), ENTITY_VA_COPY_P, ENTITY_VA_END_P, ENTITY_VA_START_P, EXPRESSION, expression_call_p(), expression_syntax, f(), find_label_entity(), functional_result, gen_length(), gen_nconc(), get_bool_property(), get_current_module_name(), get_prettyprint_language_tag(), get_string_property(), is_language_c, is_language_fortran, is_language_fortran95, ISOC99_FSCANF_USER_FUNCTION_NAME, ISOC99_SCANF_USER_FUNCTION_NAME, ISOC99_SSCANF_USER_FUNCTION_NAME, ISOC99_VFSCANF_USER_FUNCTION_NAME, ISOC99_VSCANF_USER_FUNCTION_NAME, ISOC99_VSSCANF_USER_FUNCTION_NAME, LABEL_PREFIX, label_string_defined_in_current_module_p(), list_undefined, malloc(), NIL, pips_assert, PIPS_C_MAX_OPERATOR_NAME, PIPS_C_MIN_OPERATOR_NAME, pips_internal_error, pips_user_warning, POP, prettyprint_language_is_c_p(), syntax_call, type_functional, type_statement_p, type_void_p, value_constant_p, value_symbolic_p, and words_subexpression().

Referenced by words_call_intrinsic(), words_genuine_regular_call(), words_intrinsic_call(), and Words_Regular_Call().

Here is the call graph for this function:

Here is the caller graph for this function:

Words_Subexpression()

list Words_Subexpression	(	expression	obj,
		int	precedence,
		bool	leftmost
	)

Parameters

obj	bj
precedence	recedence
leftmost	eftmost

Definition at line 2695 of file misc.c.

{
  list pdl = NIL;
  list pc = words_subexpression(obj, precedence, leftmost, &pdl);
  gen_free_list(pdl);
  return pc;
}

References gen_free_list(), NIL, and words_subexpression().

Referenced by words_cmf_loop_range().

Here is the call graph for this function:

Here is the caller graph for this function:

words_subexpression()

list words_subexpression	(	expression	obj,
		int	precedence,
		bool	leftmost,
		list *	ppdl
	)

exported for cmfortran.c

Parameters

obj	bj
precedence	recedence
leftmost	eftmost
ppdl	pdl

Definition at line 2674 of file misc.c.

{
    list pc;
 
    if ( expression_call_p(obj) )
      pc = words_call(syntax_call(expression_syntax(obj)),
                      precedence, leftmost, false, ppdl);
    else if(expression_cast_p(obj)) {
      cast c = expression_cast(obj);
      pc = words_cast(c, precedence, ppdl);
    }
    else
      pc = words_syntax(expression_syntax(obj), ppdl);
 
    return pc;
}

References expression_call_p(), expression_cast(), expression_cast_p(), expression_syntax, syntax_call, words_call(), words_cast(), and words_syntax().

Referenced by C_loop_range(), ensure_comment_consistency(), eole_fmx_specific_op(), words_any_reference(), words_assign_op(), words_assign_substring_op(), words_comma_op(), words_conditional_op(), words_infix_binary_op(), words_infix_nary_op(), words_inverse_op(), words_loop_range(), words_nullary_op_c(), words_nullary_op_fortran(), words_postfix_unary_op(), words_prefix_unary_op(), words_regular_call(), Words_Subexpression(), words_substring_op(), words_unary_minus(), and words_variable_or_function().

Here is the call graph for this function:

Here is the caller graph for this function:

words_subscript_range()

list words_subscript_range	(	range	obj,
		list *	ppdl
	)

@description FI: array constructor R433, p.

37 in Fortran 90 standard, can be used anywhere in arithmetic expressions whereas the triplet notation is restricted to subscript expressions. The triplet notation is used to define array sections (see R619, p. 64).

Returns

a list of string corresponding to the range

if undefined I print a star, why not!?

Parameters

obj	bj
ppdl	pdl

Definition at line 629 of file misc.c.

                                                   {
  list pc = NIL;
 
  /* if undefined I print a star, why not!? */
  if(expression_undefined_p(range_lower(obj))) {
    pc = CONS(STRING, MAKE_SWORD("*"), NIL);
  } else {
    switch(get_prettyprint_language_tag()) {
    case is_language_fortran: {
      call c = syntax_call(expression_syntax(range_increment(obj)));
 
      pc = gen_nconc(pc, words_expression(range_lower(obj), ppdl));
      pc = CHAIN_SWORD(pc,":");
      pc = gen_nconc(pc, words_expression(range_upper(obj), ppdl));
      if(strcmp(entity_local_name(call_function(c)), "1") != 0) {
        pc = CHAIN_SWORD(pc,":");
        pc = gen_nconc(pc, words_expression(range_increment(obj), ppdl));
      }
      break;
    }
    case is_language_fortran95: {
      // Print the lower bound if != *
      if(!unbounded_expression_p(range_lower(obj))) {
        pc = gen_nconc(pc, words_expression(range_lower(obj), ppdl));
      }
 
      // Print the upper bound if != *
      pc = CHAIN_SWORD(pc,":");
      if(!unbounded_expression_p(range_upper(obj))) {
        pc = gen_nconc(pc, words_expression(range_upper(obj), ppdl));
      }
 
      // Print the increment if != 1
      call c = syntax_call(expression_syntax(range_increment(obj)));
      if(strcmp(entity_local_name(call_function(c)), "1") != 0) {
        pc = CHAIN_SWORD(pc,":");
        pc = gen_nconc(pc, words_expression(range_increment(obj), ppdl));
      }
      break;
    }
    case is_language_c:
      // T is no way to print range in C
      // The notation with ":" has been chosen to simplify prettyprint
      {
        // Print the lower bound if != *
        if(!unbounded_expression_p(range_lower(obj))) {
          pc = gen_nconc(pc, words_expression(range_lower(obj), ppdl));
        }
 
        // Print the upper bound if != *
        pc = CHAIN_SWORD(pc,":");
        if(!unbounded_expression_p(range_upper(obj))) {
          pc = gen_nconc(pc, words_expression(range_upper(obj), ppdl));
        }
 
        // Print the increment if != 1
        call c = syntax_call(expression_syntax(range_increment(obj)));
        if(strcmp(entity_local_name(call_function(c)), "1") != 0) {
          pc = CHAIN_SWORD(pc,":");
          pc = gen_nconc(pc, words_expression(range_increment(obj), ppdl));
        }
        break;
      }
    default:
      pips_internal_error("Language unknown !");
      break;
    }
  }
  return pc;
}

References call_function, CHAIN_SWORD, CONS, entity_local_name(), expression_syntax, expression_undefined_p, gen_nconc(), get_prettyprint_language_tag(), is_language_c, is_language_fortran, is_language_fortran95, MAKE_SWORD, NIL, pips_internal_error, range_increment, range_lower, range_upper, STRING, syntax_call, unbounded_expression_p(), and words_expression().

Referenced by words_any_reference().

Here is the call graph for this function:

Here is the caller graph for this function:

Words_Syntax()

list Words_Syntax

(

syntax

obj

)

Parameters

obj

bj

Definition at line 2664 of file misc.c.

{
  list npdl = NIL;
  list pc = words_syntax(obj, &npdl);
  gen_free_list(npdl);
  return pc;
}

References gen_free_list(), NIL, and words_syntax().

Referenced by comp_regions_of_syntax(), Words_Expression(), and xml_Argument().

Here is the call graph for this function:

Here is the caller graph for this function:

words_syntax()

list words_syntax	(	syntax	obj,
		list *	ppdl
	)

exported for expression.c

FI->SG: I do not know if in_type_declaration is true, false or a formal parameter

Parameters

obj	bj
ppdl	pdl

Definition at line 2623 of file misc.c.

{
    list pc = NIL;
 
    switch (syntax_tag(obj)) {
    case is_syntax_reference :
      pc = words_reference(syntax_reference(obj), ppdl);
      break;
    case is_syntax_range:
      pc = words_range(syntax_range(obj), ppdl);
      break;
    case is_syntax_call:
      pc = words_call(syntax_call(obj), 0, true, false, ppdl);
      break;
    case is_syntax_cast:
      pc = words_cast(syntax_cast(obj), 0, ppdl);
      break;
    case is_syntax_sizeofexpression: {
      /* FI->SG: I do not know if in_type_declaration is true, false
         or a formal parameter */
      bool in_type_declaration = true;
      pc = words_sizeofexpression(syntax_sizeofexpression(obj),
                                  in_type_declaration, ppdl);
      break;
    }
    case is_syntax_subscript:
      pc = words_subscript(syntax_subscript(obj), ppdl);
      break;
    case is_syntax_application:
      pc = words_application(syntax_application(obj), ppdl);
      break;
    case is_syntax_va_arg:
      pc = words_va_arg(syntax_va_arg(obj), ppdl);
      break;
    default:
      pips_internal_error("unexpected tag");
    }
 
    return(pc);
}

References is_syntax_application, is_syntax_call, is_syntax_cast, is_syntax_range, is_syntax_reference, is_syntax_sizeofexpression, is_syntax_subscript, is_syntax_va_arg, NIL, pips_internal_error, syntax_application, syntax_call, syntax_cast, syntax_range, syntax_reference, syntax_sizeofexpression, syntax_subscript, syntax_tag, syntax_va_arg, words_application(), words_call(), words_cast(), words_range(), words_reference(), words_sizeofexpression(), words_subscript(), and words_va_arg().

Referenced by fprint_expression(), print_syntax(), words_assign_op(), words_expression(), words_subexpression(), and Words_Syntax().

Here is the call graph for this function:

Here is the caller graph for this function:

Words_Type()

list Words_Type

(

type

obj

)

Parameters

obj

bj

Definition at line 891 of file declarations.c.

{
  list pdl = NIL;
  list pc =  words_type(obj, &pdl, false);
  return pc;
}

References NIL, and words_type().

Here is the call graph for this function:

words_type()

list words_type	(	type	obj,
		list *	ppdl,
		bool	argument_p
	)

obj is the type to describe

pdl is a list of already/previously declared data structures (not 100 % sure)

argument_p: the type is used as an argument type in a function declaration; if an argument appears with the "unknown" type it is explicitly declared "int"

returns a list of strings, called "words".

The default type is int. It can be skipped in direct declarations, but not as type of an argument in a function declaration

Parameters

obj	bj
ppdl	pdl
argument_p	rgument_p

Definition at line 821 of file declarations.c.

{
  list pc = NIL;
  switch (type_tag(obj))
    {
    case is_type_variable:
      {
        // FI: the qualifiers are dropped
        variable var = type_variable(obj);
        basic b = variable_basic(var);
        list ql = variable_qualifiers(var);
        list dl = variable_dimensions(var);
        pc = words_basic(b, ppdl);
        pc = gen_nconc(pc, words_dimensions(dl, ppdl));
        pc = gen_nconc(words_qualifiers(ql), pc);
        break;
      }
    case is_type_void:
      {
        list ql = type_void(obj);
        pc = CHAIN_SWORD(pc,"void");
        pc = gen_nconc(words_qualifiers(ql), pc);
        break;
      }
    case is_type_unknown:
      {
        /* The default type is int. It can be skipped in direct
           declarations, but not as type of an argument in a function
           declaration */
        if(argument_p)
          pc = CHAIN_SWORD(pc,"int");
        break;
      }
    case is_type_struct:
      {
        pc = CHAIN_SWORD(pc,"struct");
        break;
      }
    case is_type_union:
      {
        pc = CHAIN_SWORD(pc,"union");
        break;
      }
    case is_type_enum:
      {
        pc = CHAIN_SWORD(pc,"enum");
        break;
      }
    case is_type_functional:
      {
        string_buffer result = string_buffer_make(true);
        string rs = string_undefined;
        dump_functional(type_functional(obj), result);
        rs = string_buffer_to_string(result);
        pc = gen_nconc(pc, CONS(STRING, rs, NIL));
        string_buffer_free(&result);
        break;
      }
    case is_type_varargs:
      {
        pc = CHAIN_SWORD(pc,"...");
        break;
      }
    default:
      pips_internal_error("unexpected tag %d", type_tag(obj));
    }
  pips_debug(8, "End: \"\%s\"\n", list_to_string(pc));
  return pc;
}

References argument_p(), CHAIN_SWORD, CONS, dump_functional(), gen_nconc(), is_type_enum, is_type_functional, is_type_struct, is_type_union, is_type_unknown, is_type_varargs, is_type_variable, is_type_void, list_to_string(), NIL, pips_debug, pips_internal_error, STRING, string_buffer_free(), string_buffer_make(), string_buffer_to_string(), string_undefined, type_functional, type_tag, type_variable, type_void, variable_basic, variable_dimensions, variable_qualifiers, words_basic(), words_dimensions(), and words_qualifiers().

Referenced by ensure_comment_consistency(), generic_c_words_simplified_entity(), print_type(), string_of_type(), type_to_full_string_definition(), words_basic(), words_parameters(), Words_Type(), and words_va_arg().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

lib_ri_util_prettyprint_c_rcsid

char lib_ri_util_prettyprint_c_rcsid[]

extern

misc.c

Definition at line 29 of file misc.c.