c_syntax.h File Reference

#include "c_parser_private.h"

Include dependency graph for c_syntax.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	get_label_prefix()   "-"
	The labels in C have function scope... More...
#define	FIRST_C_LINE_NUMBER   (1)
	Error handling. More...
#define	UNDEFINED_C_LINE_NUMBER   (-1)
#define	CParserError(m)   c_parser_error(CURRENT_FUNCTION, m)
#define	c_parser_user_warning(...)    c_parser_user_warning_func(CURRENT_FUNCTION, __FILE__, __LINE__, __VA_ARGS__)

Functions
int	c_lex ()
int	c_parse ()
entity	GetFunction (void)
	cproto workaround More...
void	reset_expression_comment (void)
	we don't want an expression comment with new lines, it is disgracefull More...
string	pop_block_scope (string)
	The scope is moved up the scope tree and a NULL is return when there are no more scope to explore. More...
string	scope_to_block_scope (string)
	Allocate a new string containing only block scope information. More...
c_parser_context	CreateDefaultContext (void)
void	InitScope (void)
int	ScopeStackSize (void)
string	GetScope (void)
string	GetParentScope (void)
void	ExitScope (void)
void	PushContext (c_parser_context)
void	PopContext (void)
c_parser_context	GetContext (void)
c_parser_context	GetContextCopy (void)
void	reset_declaration_counter (void)
int	get_declaration_counter (void)
void	init_c_parser_scope_stack (void)
void	reset_c_parser_scope_stack (void)
void	force_reset_c_parser_scope_stack (void)
	To be used by an error handler. More...
void	push_new_c_parser_scope (void)
void	pop_c_parser_scope_stack (void)
bool	c_parser_scope_stack_empty_p (void)
string	get_c_parser_current_scope (void)
string	get_c_parser_nth_scope (int)
int	c_parser_number_of_scopes (void)
int	get_previous_c_lineno (void)
unsigned int	character_occurences_in_string (string, char)
	Use a stack to survive to file inclusions if any. More...
int	get_current_C_line_number (void)
int	get_previous_C_line_number (void)
	Should be called just before get_current_C_line_number. More...
void	set_current_C_line_number (void)
void	push_current_C_line_number (void)
	The line number stack, designed for structured control structure, is not used yet. More...
int	pop_current_C_line_number (void)
void	reset_current_C_line_number (void)
void	error_reset_current_C_line_number (void)
void	reset_token_has_been_seen_p (void)
string	get_current_C_comment (void)
	Return the current comment as a string to be freed by the caller and reset the current comment. More...
void	push_current_C_comment (void)
	Push the current C comment so that we can get it back when building the statement later. More...
string	pop_current_C_comment (void)
	Pop the current comment. More...
void	update_C_comment (string)
	Add a comment to the current one. More...
void	remove_LFs_from_C_comment (int)
	Remove "extra_LF" trailing LF from C_current_comment if they can be found at the end of the comment string. More...
void	discard_C_comment (void)
	Discard a C comment because we don't know how to deal with it. More...
void	reset_C_comment (bool)
	reset and reset_error should be handled differently More...
void	error_reset_C_comment (bool)
void	clear_C_comment (void)
void	init_C_comment (void)
void	c_error (char *)
void	c_reset_lex (void)
int	c_wrap (void)
string	get_c_parser_current_input_file_name (void)
void	set_c_parser_current_input_file_name (string)
void	reset_c_parser_current_input_file_name (void)
void	error_reset_c_parser_current_input_file_name (void)
string	get_c_parser_current_user_input_file_name (void)
void	set_c_parser_current_user_input_file_name (string)
void	reset_c_parser_current_user_input_file_name (void)
void	error_reset_c_parser_current_user_input_file_name (void)
void	init_entity_type_storage_table (void)
void	put_to_entity_type_stack_table (entity, stack value)
stack	get_from_entity_type_stack_table (entity)
void	remove_entity_type_stack (entity)
void	remove_entity_type_stacks (list)
void	reset_entity_type_stack_table (void)
void	parser_init_keyword_typedef_table (void)
bool	c_parser_error (const char *, const char *)
	Output a parser message error. More...
void	make_predefined_C_entities (string)
bool	c_parser (const char *)
bool	compilation_unit_parser (const char *)
void	MakeCurrentModule (entity)
	is used for switch statements also, because we do not distinguish a break in a loop or a switch More...
void	ResetCurrentModule (void)
void	InitializeBlock (void)
statement	MakeBlock (list)
	Create a block statement. More...
statement	FindStatementFromLabel (entity)
statement	MakeLabeledStatement (string, statement, string)
	Construct a new statement from. More...
statement	MakeGotoStatement (string)
entity	MakeCLabel (string)
statement	MakeWhileLoop (list, statement, bool)
statement	MakeForloop (expression, expression, expression, statement)
	Create a for-loop statement with some parser-specific characteristics. More...
statement	MakeForloopWithIndexDeclaration (list, expression, expression, statement)
	Create a C99 for-loop statement with a declaration as first parameter in the for clause, with some parser-specific characteristics. More...
statement	MakeSwitchStatement (statement)
statement	MakeCaseStatement (expression)
	Transform. More...
statement	MakeDefaultStatement (void)
statement	MakeBreakStatement (string)
statement	MakeContinueStatement (string)
statement	ExpressionToStatement (expression)
	e is now owned by returned statement More...
list	add_prettyprint_control_list_to_declaration_statement (statement, list)
	The control list is hidden as arguments to the call to CONTROL in the declaration statement s. More...
void	set_prettyprint_control_list_to_extern (void)
bool	extern_prettyprint_control_list_p (void)
	void reset_prettyprint_control_list_to_extern(void) More...
void	set_prettyprint_control_list_to_dummy (void)
bool	dummy_prettyprint_control_list_p (void)
	Provide the information only once. More...
void	c_parser_user_warning_alist (const char *, const char *, const int, const char *, va_list *)
	util.c More...
void	c_parser_user_warning_func (const char *, const char *, const int, const char *,...)
void	reset_current_dummy_parameter_number (void)
entity	get_top_level_entity (void)
void	MakeTopLevelEntity (void)
void	init_c_areas (void)
	In C we have 4 areas. More...
entity	make_C_constant_entity (string, tag, size_t)
void	init_c_implicit_variables (entity)
entity	get_current_compilation_unit_entity (void)
void	MakeCurrentCompilationUnitEntity (const char *)
	A compilation unit is also considered as a module. More...
void	ResetCurrentCompilationUnitEntity (bool)
expression	MakeFunctionExpression (expression, list)
	e is now owned by returned expression and must not be used any longer More...
expression	MemberDerivedIdentifierToExpression (type, string)
expression	MemberIdentifierToExpression (expression, string)
expression	IdentifierToExpression (string)
expression	MakeArrayExpression (expression, list)
	FI: this function is called for a bracketed comma expression. More...
entity	FindEntityFromLocalName (string)
entity	FindOrCreateEntityFromLocalNameAndPrefix (string, string, bool)
entity	FindOrCreateEntityFromLocalNameAndPrefixAndScope (string, string, string, bool)
entity	FindEntityFromLocalNameAndPrefixAndScope (string, string, string)
	The parameter "scope" is potentially destroyed. More...
entity	FindEntityFromLocalNameAndPrefix (string, string)
entity	CreateEntityFromLocalNameAndPrefix (string, string, bool)
bool	CheckExternList (void)
void	c_parser_put_new_typedef (const char *)
	Store named type for the lexical analyzer, which has to decide if a character string is the name of a type or the name of a variable. More...
void	put_new_typedef (const char *)
	This function is used by libraries "step"* and "task_parallelization". More...
entity	FindOrCreateCurrentEntity (string, stack, stack, stack, bool)
void	UpdateParenEntity (entity, list)
dimension	MakeDimension (list, list)
type	UpdateFinalPointer (type, type)
void	UpdatePointerEntity (entity, type, list)
void	UpdateArrayEntity (entity, list, list)
entity	RenameFunctionEntity (entity)
	Rename function oe if necessary. More...
void	UpdateFunctionEntity (entity, list)
	The parser has found out that an entity is a function and partially sets its type. More...
type	UpdateType (type, type)
	This function replaces the undefined field in t1 by t2. More...
void	CCompilationUnitMemoryAllocations (entity, bool)
	This function allocates the memory to the Current Compilation Unit. More...
void	CCompilationUnitMemoryAllocation (entity)
void	CCompilationUnitMemoryReallocation (entity)
void	CModuleMemoryAllocation (entity)
	This function is for MemoryAllocation for Module of C programs. More...
void	UseDummyArguments (entity)
	If f has regular formal parameters, destroy them. More...
void	UseFormalArguments (entity)
	If f has dummy formal parameters, replace them by standard formal parameters. More...
void	RemoveDummyArguments (entity, list)
	To chase formals in type declarations. More...
void	SubstituteDummyParameters (entity, list)
void	CreateReturnEntity (entity)
	If necessary, create the return entity, which is a hidden variable used in PIPS internal representation to carry the value returned by a function. More...
void	UpdateEntity2 (entity, stack, stack)
void	UpdateEntity (entity, stack, stack, stack, stack, bool, bool)
	Update the entity with final type, storage and initial value; and also (sometimes?) declare it at the module level. More...
void	UpdateEntities (list, stack, stack, stack, stack, bool, bool)
void	CleanUpEntities (list)
void	UpdateAbstractEntity (entity, stack)
void	RemoveFromExterns (entity)
void	AddToExterns (entity, entity)
void	AddToDeclarations (entity, entity)
	FI: check the difference with AddEntityToDeclarations() More...
void	UpdateDerivedEntity (list, entity, stack)
list	TakeDerivedEntities (list)
void	UpdateDerivedEntities (list, list, stack)
void	InitializeEnumMemberValues (list)
entity	MakeDerivedEntity (string, list, bool, int)
storage	MakeStorageRam (entity, bool, bool)
	The storage part should not be called twice when reparsing compilation unit. More...
string	CreateMemberScope (string, bool)
value	MakeEnumeratorInitialValue (list, int)
int	ComputeAreaOffset (entity, entity)
list	MakeParameterList (list, list, stack)
parameter	FindParameterEntity (string, int, list)
void	AddToCalledModules (entity)
void	NStackPop (stack, int)
	Pop n times the stack s. More...
void	StackPop (stack)
	The OffsetStack is poped n times, where n is the number of formal arguments of the actual function. More...
void	StackPush (stack)
	The OffsetStack is pushed incrementally. More...
void	set_entity_initial (entity, expression)
	Be careful if the initial value has already been set. More...
bool	check_declaration_uniqueness_p (statement)
	This is designed for standard C functions, not for compilation units. More...
list	insert_qualifier (list, qualifier)
	if qualifier "nq" does not already belong to qualifier list "ql", add it in front of the list. More...
void	reset_preprocessor_line_analysis (void)
int	analyze_preprocessor_line (string, int)
	Analyze information about user line number provided by the C preprocessor and by PIPS file splitter and return the C line number in the source file. More...
entity	Generate_C_ReturnLabel (entity)
	return.c More...
statement	Generate_C_ReturnStatement (void)
void	Reset_C_ReturnStatement (void)
	The return statement must be reset when it is used by the parser to add the return statement to the function body or when a parser error is encountered. More...
statement	Get_C_ReturnStatement (void)
	This function is used to generate all goto's towards the unique return used to C replace return statement and to insert this unique return at the end of the current function's body. More...
statement	C_MakeReturnStatement (list, int, string)
	This function creates a goto instruction to label end_label. More...
int	GetReturnNumber (void)
void	FixCReturnStatements (statement)
	When return statements have been encountered, each of them has been replaced by a goto to a unique return statement. More...
void	c_restart (FILE *)
void	c_pop_buffer_state (void)
int	c_get_lineno (void)
FILE *	c_get_in (void)
FILE *	c_get_out (void)
int	c_get_leng (void)
char *	c_get_text (void)
void	c_set_lineno (int)
void	c_set_in (FILE *)
void	c_set_out (FILE *)
int	c_get_debug (void)
void	c_set_debug (int)
int	c_lex_destroy (void)
void *	c_alloc (yy_size_t)
void *	c_realloc (void *, yy_size_t)
void	c_free (void *)

Variables
FILE *	c_in
	Warning! Do not modify this file that is automatically generated! More...
int	c_lineno
	the file read in by the c_lexer More...
entity	DynamicArea
	These global variables are declared in ri-util/util.c. More...
entity	StaticArea
entity	HeapArea
entity	StackArea
entity	AllocatableArea
int	C_line_increment
	from "clex.l" More...
string	compilation_unit_name
	cproto-generated files More...
list	CalledModules
statement	ModuleStatement
stack	ContextStack
stack	FunctionStack
stack	FormalStack
stack	OffsetStack
stack	StructNameStack
int	loop_counter
	Global counter. More...
int	derived_counter
bool	compilation_unit_parser_is_running_p
	To pass down the information to functions used by the syntactical analyzer. More...
list	removable_extern_entities
stack	BlockStack
	statement.c More...
list	LabeledStatements
	BlockStack is used to handle block scope. More...
stack	SwitchGotoStack
	list of labeled statements of the current module More...
stack	SwitchControllerStack
stack	LoopStack
int	c_debug
int	c_char
int	c_nerrs
int	c_leng
	clexer.c More...
FILE *	c_out
int	c__flex_debug
char *	c_text

Macro Definition Documentation

c_parser_user_warning

#define c_parser_user_warning

(

...

)

c_parser_user_warning_func(CURRENT_FUNCTION, __FILE__, __LINE__, __VA_ARGS__)

Definition at line 63 of file c_syntax.h.

CParserError

#define CParserError

(

m

)

c_parser_error(CURRENT_FUNCTION, m)

Definition at line 62 of file c_syntax.h.

FIRST_C_LINE_NUMBER

#define FIRST_C_LINE_NUMBER   (1)

Error handling.

Definition at line 59 of file c_syntax.h.

get_label_prefix

#define get_label_prefix

(

)

"-"

The labels in C have function scope...

but beware of inlining... and conflict with user labels To disambiguate labels, in case inlining is performed later and to suppress the potential for conflicts with user labels.

Temporary entities have to be generated to be replaced later by the final labels. The temporary entities should be eliminated from the symbol table...

Definition at line 49 of file c_syntax.h.

UNDEFINED_C_LINE_NUMBER

#define UNDEFINED_C_LINE_NUMBER   (-1)

Definition at line 60 of file c_syntax.h.

Function Documentation

add_prettyprint_control_list_to_declaration_statement()

list add_prettyprint_control_list_to_declaration_statement	(	statement	s,
		list	initialization_expressions
	)

The control list is hidden as arguments to the call to CONTROL in the declaration statement s.

It is made of 0 and 1 constant expressions.

The first element tells the prettyprinter if the "extern" keyword must be printed out.

The next expressions tells the prettyprinter which variables should be initialized by this statement.

The control list for the initializations is built by the C parser, cyacc.y.

This is only useful for global variables which can be declared multiple times in multiple files and in multiple ways. See Prettyprint/double_declaration01-14.c.

The parser generated the initialization control list backwards

Try to patch the initialization list for derived entities assuming that derived entities are located anywhere in the declaration list. See decl64-65 and struct14-15.c

Place holder variables have been removed. Even if a compilation unit is being parsed, initialization_expressions should have no impact.

The initialization list is OK

We could assert here than in = dn, but this is asserted below with more explanations. However, only in debug mode 8.

Preserve the "extern" information right away before the C parser updates it each time it encounters a global declaration.

An extern declaration?

Provide debugging information

Build the prettyprint control list: extern first and the initializations

Update the declaration statement

Parameters

initialization_expressions

nitialization_expressions

Definition at line 919 of file statement.c.

{
  list dl = statement_declarations(s); // declaration list
 
  if(ENDP(dl)) {
    if(ENDP(initialization_expressions)) {
      // FI: Well, the parser has declared fields for instance...
      return NIL;
    }
    else {
      pips_internal_error("Not expected\n");
      return initialization_expressions;
    }
  }
  else {
    /* The parser generated the initialization control list backwards */
    list iel = gen_nreverse(initialization_expressions);
 
    int dn = (int) gen_length(dl); // declaration number
    int in = (int) gen_length(iel); // initialization number
    entity first = ENTITY(CAR(dl));
 
    list niel = NIL;
 
    /* Try to patch the initialization list for derived entities
     * assuming that derived entities are located anywhere in the
     * declaration list. See decl64-65 and struct14-15.c
     */
 
    if(dn<in) {
      /* Place holder variables have been removed. Even if a
       * compilation unit is being parsed, initialization_expressions
       * should have no impact.
       */
      list ciel = iel;
      int i;
      for(i=0;i<dn-1;i++) {
        ciel = CDR(ciel);
      }
      list liel = CDR(ciel);
      CDR(ciel) = NIL;
      gen_full_free_list(liel);
      niel = iel;
      pips_assert("Same number of elements in both lists",
                  (int) gen_length(niel)==dn);
    }
    else if(dn>in) {
      list ciel = iel;
      FOREACH(ENTITY, e, dl) {
        // FI: we could instead check variable_entity_p()?
        if(derived_entity_p(e) || typedef_entity_p(e)) {
          niel = CONS(EXPRESSION, int_to_expression(0), niel);
          in++;
        }
        else {
          niel = CONS(EXPRESSION, EXPRESSION(CAR(ciel)), niel);
          POP(ciel);
        }
      }
      niel = gen_nreverse(niel);
      gen_free_list(iel); // initialization_expressions is dead
    }
    else {
      /* The initialization list is OK */
      niel = iel;
    }
 
 
    /* We could assert here than in = dn, but this is asserted below
     * with more explanations. However, only in debug mode 8. */
 
    /* Preserve the "extern" information right away before the C parser
       updates it each time it encounters a global declaration. */
 
    /* An extern declaration? */
 
    bool is_extern_statement_p = extern_prettyprint_control_list_p();
    bool is_dummy_statement_p = dummy_prettyprint_control_list_p();
    expression extern_declaration_p =
      int_to_expression((is_extern_statement_p? 1 : 0) +
                        (is_dummy_statement_p? 2 : 0));
 
    /* Provide debugging information */
 
    ifdebug(8) {
      fprintf(stderr, "Variable \"%s\" is %sdeclared EXTERN.\n", entity_user_name(first), is_extern_statement_p? "" : "not ");
      fprintf(stderr, "Number of declared variables: %d\n", dn);
      print_entities(dl);
      fprintf(stderr, "Number of initialization expressions: %d\n", in);
 
      // For debugging
      extern void print_expressions(list);
      print_expressions(niel);
      //printf("\nis_external = %s\n", bool_to_string(is_external));
    }
 
    /* Build the prettyprint control list: extern first and the initializations */
    list cel = CONS(EXPRESSION, extern_declaration_p, niel); // control expression list
 
    ifdebug(8) {
      fprintf(stderr, "Number of control expressions: %d\n", (int) gen_length(cel));
      print_expressions(cel);
      if(gen_length(dl)!=gen_length(niel)) {
        print_entities(dl);
        pips_assert("The number of variables declared is equal to the number of expressions", gen_length(dl)==gen_length(niel));
      }
      fprintf(stderr, "**************************\n");
    }
 
    /* Update the declaration statement */
 
    add_initialization_information_to_declaration_statement(s, cel);
 
    // reset the initialization_expressions list in the caller
    // initialization_expressions = NIL;
    return NIL;
  }
}

References add_initialization_information_to_declaration_statement(), CAR, CDR, CONS, derived_entity_p(), dummy_prettyprint_control_list_p(), ENDP, ENTITY, entity_user_name(), EXPRESSION, extern_declaration_p, extern_prettyprint_control_list_p(), FOREACH, fprintf(), gen_free_list(), gen_full_free_list(), gen_length(), gen_nreverse(), ifdebug, initialization_expressions, int, int_to_expression(), NIL, pips_assert, pips_internal_error, POP, print_entities(), print_expressions(), statement_declarations, and typedef_entity_p().

Here is the call graph for this function:

AddToCalledModules()

void AddToCalledModules

(

entity

e

)

Definition at line 3413 of file util.c.

{
  if (!intrinsic_entity_p(e))
    {
      bool already_here = false;
      //string n = top_level_entity_p(e)?entity_local_name(e):entity_name(e);
      const char* n = entity_local_name(e);
      MAP(STRING,s,
      {
        if (strcmp(n, s) == 0)
          {
            already_here = true;
            break;
          }
      }, CalledModules);
 
      if (! already_here)
        {
          pips_debug(2, "Adding %s to list of called modules\n", n);
          CalledModules = CONS(STRING, strdup(n), CalledModules);
        }
    }
}

References CalledModules, CONS, entity_local_name(), intrinsic_entity_p(), MAP, pips_debug, strdup(), and STRING.

Referenced by MakeFunctionExpression().

Here is the call graph for this function:

Here is the caller graph for this function:

AddToDeclarations()

void AddToDeclarations	(	entity	e,
		entity	mod
	)

FI: check the difference with AddEntityToDeclarations()

Here, the declared entity is added to the module declarations only.

Parameters

mod

od

Definition at line 2924 of file util.c.

{
  list dl = code_declarations(value_code(entity_initial(mod)));
 
  if (!gen_in_list_p(e,dl))
    {
      pips_debug(5,"Add entity \"%s\" (\"%s\") to module %s\n",
                 entity_user_name(e),
                 entity_name(e),
                 entity_user_name(mod));
      code_declarations(value_code(entity_initial(mod)))
        = gen_nconc(code_declarations(value_code(entity_initial(mod))),
                    CONS(ENTITY,e,NIL));
    }
}

References code_declarations, CONS, ENTITY, entity_initial, entity_name, entity_user_name(), gen_in_list_p(), gen_nconc(), NIL, pips_debug, and value_code.

Referenced by CreateReturnEntity(), MakeFunctionExpression(), MakeParameterList(), and UpdateEntity().

Here is the call graph for this function:

Here is the caller graph for this function:

AddToExterns()

void AddToExterns	(	entity	e,
		entity	mod
	)

Parameters

mod

od

Definition at line 2898 of file util.c.

{
  // the entity e can be extern variable and extern functions
  list le = code_externs(value_code(entity_initial(mod)));
 
  pips_assert("le is an entity list", entity_list_p(le));
 
  if(!gen_in_list_p(e, le))
  {
    pips_debug(5,"Add entity %s to extern declaration %s \n",
               entity_user_name(e), entity_user_name(mod));
    pips_assert("e is an entity", entity_domain_number(e)==entity_domain);
    pips_assert("mod is an entity", entity_domain_number(mod)==entity_domain);
    code_externs(value_code(entity_initial(mod)))
      = gen_nconc(code_externs(value_code(entity_initial(mod))),
                  CONS(ENTITY,e,NIL));
 
    le = code_externs(value_code(entity_initial(mod)));
    pips_assert("le is an entity list", entity_list_p(le));
  }
}

References code_externs, CONS, ENTITY, entity_domain, entity_domain_number, entity_initial, entity_list_p(), entity_user_name(), gen_in_list_p(), gen_nconc(), NIL, pips_assert, pips_debug, and value_code.

Referenced by FindOrCreateCurrentEntity(), and UpdateEntity().

Here is the call graph for this function:

Here is the caller graph for this function:

analyze_preprocessor_line()

int analyze_preprocessor_line	(	string	line,
		int	C_line_number
	)

Analyze information about user line number provided by the C preprocessor and by PIPS file splitter and return the C line number in the source file.

We do not have specs and must evolve with C preprocessors such as cpp.

We assume that information about the lines in the included files is only provided for compilation unit.

We assume that information about user line in a module is always related to the user source file, and that the first line has been generated by PIPS file splitter with syntax "x nnn", with no information about the user source file name.

See examples line00.c, line01.c, line02.c and line03.c. And do not forget cominc02 for the compilation unit case. And missing01.c for synthesized code.

More examples needed for include lines placed within a function body, with C code or preprocessor definitions: line04 and line05.

the C preprocessors, such as cpp, and PIPS file splitter provide line information in pragmas which are not line pragmas.

Not too sure about C source code generated by PIPS by passes initializer, clone, outlining, inlinging...

strstr(line, "#line")==line &&

Not to sure about this case

The next lines have been imported from an included file. Ignore information about include files, preserve the current C_line_number.

Not to sure about this case: internal error?

Parameters

line	ine
C_line_number	_line_number

Definition at line 3617 of file util.c.

{
  // In compilation units, ignore information about include files
  // Could be used so size "buffer", but not "init_buffer"
  // int s = strlen(line);
  char buffer[1024];
  static char init_buffer[1024];
 
  pips_debug(9,"Pragma-like comment %s\n",line);
 
  /* the C preprocessors, such as cpp, and PIPS file splitter provide
   * line information in pragmas which are not #line pragmas.
   *
   * Not too sure about C source code generated by PIPS by passes
   * initializer, clone, outlining, inlinging...
   */
 
  if(/* strstr(line, "#line")==line && */ strlen(line)>=4) {
    int initial_C_line_number = -1;
    int items = sscanf(line+1, "%d %s", &initial_C_line_number, buffer);
    if(items==2) { 
      // if(C_line_number==UNDEFINED_C_LINE_NUMBER) {
      //if(C_line_number==FIRST_C_LINE_NUMBER) {
      // Local files are named either "./foo.c" or "foo.c"
      int skip = 0;
      if(buffer[1]=='.' && buffer[2]=='/') {
        skip = 2;
        buffer[2] = '"';
      }
      if(!buffer_initialized_p) {
        //if(strstr(buffer, ".h"))
        //fprintf(stderr, "Abnormal file name %s\n", buffer);
        buffer_initialized_p = true;
        C_line_number = initial_C_line_number;
        C_line_increment = 1;
        (void) strcpy(init_buffer, buffer+skip);
      }
      else if(same_string_p((string) (buffer+skip), (string) init_buffer)) {
        C_line_increment = 1;
        if(!compilation_unit_parser_is_running_p
              && C_line_number>initial_C_line_number) {
          int d = C_line_number-initial_C_line_number;
          remove_LFs_from_C_comment(d);
          C_line_number = initial_C_line_number;
        }
        else {
          /* Not to sure about this case */
          C_line_number = initial_C_line_number;
        }
      }
      else {
        /* The next lines have been imported from an included file.
         * Ignore information about include files, preserve the
         * current C_line_number.
         */
        C_line_increment = 0;
      }
    }
    else if(items==1) {
        /* Not to sure about this case: internal error? */
        C_line_number = initial_C_line_number;
    }
    else {
      // items==0
      pips_user_warning("No line number after a #: \"%s\".\n", line);
      CParserError("Ill. formated # pragma.\n");
    }
  }
  return C_line_number;
}

References buffer, buffer_initialized_p, C_line_increment, C_line_number, compilation_unit_parser_is_running_p, CParserError(), line, pips_debug, pips_user_warning, remove_LFs_from_C_comment(), and same_string_p.

Here is the call graph for this function:

c_alloc()

void* c_alloc

(

yy_size_t

)

c_error()

void c_error

(

char *

)

c_free()

void c_free

(

void *

)

c_get_debug()

int c_get_debug

(

void

)

c_get_in()

FILE* c_get_in

(

void

)

c_get_leng()

int c_get_leng

(

void

)

c_get_lineno()

int c_get_lineno

(

void

)

c_get_out()

FILE* c_get_out

(

void

)

c_get_text()

char* c_get_text

(

void

)

c_lex()

int c_lex

(

)

c_lex_destroy()

int c_lex_destroy

(

void

)

C_MakeReturnStatement()

statement C_MakeReturnStatement	(	list	el,
		int	ln,
		string	c
	)

This function creates a goto instruction to label end_label.

This is done to eliminate return statements.

Note: I was afraid the mouse trap would not work to analyze multiple procedures but there is no problem. I guess that MakeGotoInst() generates the proper label entity regardless of end_label. FI. Generates the internal representation of a C return statement. If e is an undefined expression, a goto returnlabel is generated. Else, e is assigned to the return value of the current function, a goto is generated and both are returned within a block.

Assign the expression to the return value of the current function

Parameters

el	l
ln	n

Definition at line 155 of file return.c.

{
  instruction inst = instruction_undefined;
  instruction ainst = instruction_undefined;
  instruction ginst = instruction_undefined;
  statement s = statement_undefined;
 
  last_returned_value = el;
 
  if(!ENDP(el)) {
    /* Assign the expression to the return value of the current
       function */
    entity f = get_current_module_entity();
    entity rv = function_to_return_value(f);
    if(ENDP(CDR(el))) {
      expression e = EXPRESSION(CAR(el));
      ainst = make_assign_instruction(entity_to_expression(rv), e);
    }
    else {
      pips_internal_error("This case is not implemented yet.");
    }
  }
 
  ginst = make_instruction_goto(Get_C_ReturnStatement());
 
  if(instruction_undefined_p(ainst)) {
    inst = ginst;
    s = make_statement(entity_empty_label(),
                       ln,
                       STATEMENT_ORDERING_UNDEFINED,
                       c,
                       inst,
                       NIL,
                       string_undefined,
                       empty_extensions(), make_synchronization_none());
  }
  else {
    statement as = make_statement(entity_empty_label(),
                     ln,
                     STATEMENT_ORDERING_UNDEFINED,
                     c,
                     ainst,
                     NIL,
                     string_undefined,
                     empty_extensions(), make_synchronization_none());
    statement gs = instruction_to_statement(ginst);
    list sl = CONS(STATEMENT, as, CONS(STATEMENT, gs, NIL));
    last_return_value_assignment = as;
    inst = make_instruction_block(sl);
    s = instruction_to_statement(inst);
  }
 
  pips_assert("inst is consistent", instruction_consistent_p(inst));
  pips_assert("s is consistent", statement_consistent_p(s));
 
 
  return s;
}

References CAR, CDR, CONS, empty_extensions(), ENDP, entity_empty_label(), entity_to_expression(), EXPRESSION, f(), function_to_return_value(), Get_C_ReturnStatement(), get_current_module_entity(), instruction_consistent_p(), instruction_to_statement(), instruction_undefined, instruction_undefined_p, last_return_value_assignment, last_returned_value, make_assign_instruction(), make_instruction_block(), make_instruction_goto(), make_statement(), make_synchronization_none(), NIL, pips_assert, pips_internal_error, STATEMENT, statement_consistent_p(), STATEMENT_ORDERING_UNDEFINED, statement_undefined, and string_undefined.

Here is the call graph for this function:

c_parse()

int c_parse

(

)

c_parser()

bool c_parser

(

const char *

module_name

)

When the compilation_unit is parsed, it is parsed a second time and multiple declarations are certain to happen.

Parameters

module_name

odule_name

Definition at line 739 of file c_parser.c.

{
  /* When the compilation_unit is parsed, it is parsed a second time
     and multiple declarations are certain to happen. */
   return actual_c_parser(module_name,DBR_C_SOURCE_FILE,false);
}

References actual_c_parser(), and module_name().

Here is the call graph for this function:

c_parser_error()

bool c_parser_error	(	const char *	func,
		const char *	msg
	)

Output a parser message error.

At the end there is a pips_user_error that launch an exception so that this function may not really exit but may be caught at a higher level...

This function is called by macro CParserError()

Since many information are lost by the various resetting, first save them for later display:

Reset the parser global variables ?

The error may occur before the current module entity is defined

Stacks are not allocated yet when dealing with external declarations. I assume that all stacks are declared simultaneously, hence a single test before freeing.

Reset them to stack_undefined_p instead of STACK_NULL

get rid of all collected comments

ffective_line_number,

Parameters

func	unc
msg	sg

Definition at line 266 of file c_parser.c.

{
  entity mod = get_current_module_entity();
  const char * mod_name = entity_undefined_p(mod)? "entity_undefined":entity_user_name(mod);
  /* Since many information are lost by the various resetting, first save
     them for later display: */
  int user_line_number = get_current_C_line_number();
  //int effective_line_number = c_lineno;
 
  pips_debug(1, "Parser error detected in function \"%s\".\n", func);
 
  c_reset_lex();
 
  /* Reset the parser global variables ?*/
 
  pips_debug(4,"Reset current module entity %s\n", mod_name);
 
  /* The error may occur before the current module entity is defined */
  error_reset_current_module_entity();
  reset_current_dummy_parameter_number();
  reset_declaration_counter();
 
  // Get rid of partly declared variables
  if(mod!=entity_undefined) {
    value v = entity_initial(mod);
    code c = value_code(v);
 
    code_declarations(c) = NIL;
    code_decls_text(c) = string_undefined;
    CleanLocalEntities(mod);
  }
 
  // Free CalledModules?
 
  // Could not rebuild filename (A. Mensi)
  // c_in = safe_fopen(file_name, "r");
  // safe_fclose(c_in, file_name);
 
  /* Stacks are not allocated yet when dealing with external
     declarations. I assume that all stacks are declared
     simultaneously, hence a single test before freeing. */
  if(!entity_undefined_p(mod)) {
    reset_entity_type_stack_table();
    force_reset_c_parser_scope_stack();
    if(!stack_undefined_p(SwitchGotoStack)) {
      stack_free(&SwitchGotoStack);
      stack_free(&SwitchControllerStack);
      stack_free(&LoopStack);
      stack_free(&BlockStack);
      /* Reset them to stack_undefined_p instead of STACK_NULL */
      SwitchGotoStack = stack_undefined;
      SwitchControllerStack = stack_undefined;
      LoopStack = stack_undefined;
      BlockStack = stack_undefined;
 
      stack_free(&ContextStack);
      stack_free(&FunctionStack);
      stack_free(&FormalStack);
      stack_free(&OffsetStack);
      stack_free(&StructNameStack);
      ContextStack = stack_undefined;
      FunctionStack = stack_undefined;
      FormalStack = stack_undefined;
      OffsetStack = stack_undefined;
      StructNameStack = stack_undefined;
    }
  }
 
  error_reset_current_C_line_number();
  /* get rid of all collected comments */
  reset_C_comment(true);
  reset_expression_comment();
  Reset_C_ReturnStatement();
 
  //debug_off();
 
  pips_user_warning("\nRecovery from C parser failure not (fully) implemented yet.\n"
                    "C parser is likely to fail later if re-used.\n");
  string fn = get_c_parser_current_user_input_file_name();
  error_reset_c_parser_current_input_file_name();
  error_reset_c_parser_current_user_input_file_name();
  pips_user_error("\n%s at user line %d in file \"%s\"\n",
                  msg, user_line_number, /*effective_line_number,*/ fn);
  // Never reached, but for compatibility with Fortran ParserError
  return true;
}

References BlockStack, c_reset_lex(), CleanLocalEntities(), code_declarations, code_decls_text, ContextStack, entity_initial, entity_undefined, entity_undefined_p, entity_user_name(), error_reset_c_parser_current_input_file_name(), error_reset_c_parser_current_user_input_file_name(), error_reset_current_C_line_number(), error_reset_current_module_entity(), force_reset_c_parser_scope_stack(), FormalStack, FunctionStack, get_c_parser_current_user_input_file_name(), get_current_C_line_number(), get_current_module_entity(), LoopStack, NIL, OffsetStack, pips_debug, pips_user_error, pips_user_warning, reset_C_comment(), Reset_C_ReturnStatement(), reset_current_dummy_parameter_number(), reset_declaration_counter(), reset_entity_type_stack_table(), reset_expression_comment(), stack_free(), stack_undefined, stack_undefined_p, string_undefined, StructNameStack, SwitchControllerStack, SwitchGotoStack, user_line_number, and value_code.

Referenced by make_C_constant_entity().

Here is the call graph for this function:

Here is the caller graph for this function:

c_parser_number_of_scopes()

int c_parser_number_of_scopes

(

void

)

Definition at line 587 of file cyacc.tab.c.

 {
   int n = stack_size(c_parser_scope_stack);
   return n;
 }

c_parser_put_new_typedef()

void c_parser_put_new_typedef

(

const char *

name

)

Store named type for the lexical analyzer, which has to decide if a character string is the name of a type or the name of a variable.

See is_c_parser_keyword_typedef() in clex.l

Parameters

name

ame

Definition at line 1060 of file util.c.

{
  string s = get_c_parser_current_scope();
  string sname = string_undefined;
  if(same_string_p(s, ""))
    sname = strdup(name);
  else
    sname = strdup(concatenate(name,"%", s, NULL));
  hash_put(keyword_typedef_table, sname,(void *) TK_NAMED_TYPE);
  pips_debug(5, "Add typedef name %s to hash table\n",sname);
}

References concatenate(), get_c_parser_current_scope(), hash_put(), keyword_typedef_table, pips_debug, same_string_p, strdup(), string_undefined, and TK_NAMED_TYPE.

Referenced by FindOrCreateCurrentEntity().

Here is the call graph for this function:

Here is the caller graph for this function:

c_parser_scope_stack_empty_p()

bool c_parser_scope_stack_empty_p

(

void

)

Definition at line 564 of file cyacc.tab.c.

{
  return stack_empty_p(c_parser_scope_stack);
}

Referenced by get_c_parser_current_scope().

Here is the caller graph for this function:

c_parser_user_warning_alist()

void c_parser_user_warning_alist	(	const char *	pips_func,
		const char *	pips_file,
		const int	pips_line,
		const char *	format,
		va_list *	args
	)

util.c

util.c

Parser warning on C code synthesized by PIPS

Parameters

pips_func	ips_func
pips_file	ips_file
pips_line	ips_line
format	ormat
args	rgs

Definition at line 60 of file util.c.

{
  if (get_bool_property("NO_USER_WARNING"))
    return;
 
  // First and current line number in PIPS preprocessed file (ifn)
  string ifn = get_c_parser_current_input_file_name();
  int fln = get_previous_c_lineno();
  int uln = c_lineno;
  string ifn_src = safe_get_line_interval(ifn, fln, uln);
 
  // Previous and current line numbers, in user input file (uifn)
  // ??? string_undefined for pips generated code?
  string uifn =  get_c_parser_current_user_input_file_name();
  int pln = get_previous_C_line_number();
  int cln = get_current_C_line_number();
 
  // Do not print more than 10 lines: the beginning of the user
  // input C file may be full of includes and comments all
  // considered related to the first declaration.
  pips_assert("consistent line numbers", 1 <= pln && pln <= cln);
  if (pln < cln-9)
    pln = cln-9;
 
  string uifn_src = safe_get_line_interval(uifn, pln, cln);
 
  string more;
 
  asprintf(&more,
           "Source code after preprocessing:\n%s"
           "Input source code, before preprocessing:\n%s",
           ifn_src, uifn_src);
 
  pips_log_alist(warning_log,
                 get_pips_current_pass_name(), get_pips_current_module(),
                 (const string) pips_func, (const string) pips_file, pips_line,
                 NULL, uifn, pln, cln,
                 NULL, more, (const string) format, args);
 
  free(more);
 
  // else???
  /* Parser warning on C code synthesized by PIPS */
  // pips_internal_error("Some synthesized code raises a "
  // "C parser warning.\n");
}

References asprintf, c_lineno, free(), get_bool_property(), get_c_parser_current_input_file_name(), get_c_parser_current_user_input_file_name(), get_current_C_line_number(), get_pips_current_module(), get_pips_current_pass_name(), get_previous_C_line_number(), get_previous_c_lineno(), pips_assert, pips_log_alist(), safe_get_line_interval(), and warning_log.

Referenced by c_parser_user_warning_func().

Here is the call graph for this function:

Here is the caller graph for this function:

c_parser_user_warning_func()

void c_parser_user_warning_func	(	const char *	pips_func,
		const char *	pips_file,
		const int	pips_line,
		const char *	format,
			...
	)

Parameters

pips_func	ips_func
pips_file	ips_file
pips_line	ips_line
format	ormat

Definition at line 112 of file util.c.

{
  va_list args;
  va_start(args, format);
  c_parser_user_warning_alist(pips_func, pips_file, pips_line, format, &args);
  va_end(args);
}

References c_parser_user_warning_alist().

Here is the call graph for this function:

c_pop_buffer_state()

void c_pop_buffer_state

(

void

)

c_realloc()

void* c_realloc	(	void *	,
		yy_size_t
	)

c_reset_lex()

void c_reset_lex

(

void

)

c_restart()

void c_restart

(

FILE *

)

c_set_debug()

void c_set_debug

(

int

)

c_set_in()

void c_set_in

(

FILE *

)

c_set_lineno()

void c_set_lineno

(

int

)

c_set_out()

void c_set_out

(

FILE *

)

c_wrap()

int c_wrap

(

void

)

CCompilationUnitMemoryAllocation()

void CCompilationUnitMemoryAllocation

(

entity

module

)

Parameters

module

odule

Definition at line 1967 of file util.c.

{
  CCompilationUnitMemoryAllocations(module, true);
}

References CCompilationUnitMemoryAllocations(), and module.

Referenced by ResetCurrentCompilationUnitEntity().

Here is the call graph for this function:

Here is the caller graph for this function:

CCompilationUnitMemoryAllocations()

void CCompilationUnitMemoryAllocations	(	entity	module,
		bool	first_p
	)

This function allocates the memory to the Current Compilation Unit.

Check that all variables used or defined are declared

Allocate variables

We are in trouble

check the type of variable here to avoid conflicting declarations

The C parser is no longer active when this warning is emitted. It is not possible to rely on its line numbers.

No way to know if a pointer is initialized or not

This may happen with variables such as "__morecore" which is a functional pointer to a malloc like function and which is declared in a header file.

It may or not be an error, depending on conflicting initializations or not. It seems better to leave this for gcc or clang to decide before running PIPS.

Do not modify the initial allocation

Do not allocate the memory for external variables: Set the offset of ram -2 which signifies UNKNOWN offset

Parameters

module	odule
first_p	irst_p

Definition at line 1881 of file util.c.

{
  list ld = entity_declarations(module);
  entity var = entity_undefined;
 
  pips_debug(8,"MEMORY ALLOCATION BEGINS\n");
 
  /* Check that all variables used or defined are declared */
  nodecl_p(module, ModuleStatement);
 
  /* Allocate variables */
  for(; !ENDP(ld); ld = CDR(ld)) {
    var = ENTITY(CAR(ld));
    if(!place_holder_variable_p(var) && type_variable_p(entity_type(var))) {
      storage s = entity_storage(var);
      type t = entity_type(var);
      type ut = ultimate_type(t);
 
      // Make sure that the ultimate type is variable */
      if(!type_variable_p(ut) && storage_ram_p(s)) {
        /* We are in trouble */
        pips_internal_error("Variable %s has not a variable type",
                            entity_user_name(var));
      }
 
      // Add some preconditions here
      if(storage_ram_p(s)) {
        ram r = storage_ram(s);
        entity a = ram_section(r);
        /* check the type of variable here to avoid conflicting declarations */
        // External variable list: evl
        list evl = code_externs(value_code(entity_initial(module)));
        if(!gen_in_list_p(var, evl)) {
          if(ram_offset(r) != UNDEFINED_RAM_OFFSET
             && ram_offset(r) != UNKNOWN_RAM_OFFSET
             && ram_offset(r) != DYNAMIC_RAM_OFFSET ) {
            if(first_p) {
              /* The C parser is no longer active when this warning is emitted.
               * It is not possible to rely on its line numbers.
               */
              // c_parser_user_warning
              pips_user_warning
                ("Multiple declarations of variable \"%s\" in different files\n",
                 entity_local_name(var));
              if(top_level_entity_p(a)
                 && (value_unknown_p(entity_initial(var))
                     /* No way to know if a pointer is initialized or
                        not */
                     ||value_code_p(entity_initial(var)))) {
                /* This may happen with variables such as
                   "__morecore" which is a functional pointer to a
                   malloc like function and which is declared in a
                   header file. */
                ;
              }
              else {
                // CParserError("Fix your source code!\n");
                /* It may or not be an error, depending on conflicting
                 * initializations or not. It seems better to leave
                 * this for gcc or clang to decide before running
                 * PIPS.
                 */
              }
              /* Do not modify the initial allocation */
              ;
            }
          }
          else {
            ram_offset(r) = area_size(type_area(entity_type(a)));
            add_C_variable_to_area(a,var);
          }
        }
        else {
          /* Do not allocate the memory for external variables:
             Set the offset of ram -2 which signifies UNKNOWN offset
          */
 
          // Check type here to avoid conflict declarations
          if(ram_offset(r) == UNKNOWN_RAM_OFFSET)
            ram_offset(r) = UNDEFINED_RAM_OFFSET;
        }
      }
    }
  }
}

References add_C_variable_to_area(), area_size, CAR, CDR, code_externs, DYNAMIC_RAM_OFFSET, ENDP, ENTITY, entity_declarations, entity_initial, entity_local_name(), entity_storage, entity_type, entity_undefined, entity_user_name(), gen_in_list_p(), module, ModuleStatement, nodecl_p(), pips_debug, pips_internal_error, pips_user_warning, place_holder_variable_p(), ram_offset, ram_section, storage_ram, storage_ram_p, top_level_entity_p(), type_area, type_variable_p, ultimate_type(), UNDEFINED_RAM_OFFSET, UNKNOWN_RAM_OFFSET, value_code, value_code_p, and value_unknown_p.

Referenced by CCompilationUnitMemoryAllocation(), and CCompilationUnitMemoryReallocation().

Here is the call graph for this function:

Here is the caller graph for this function:

CCompilationUnitMemoryReallocation()

void CCompilationUnitMemoryReallocation

(

entity

module

)

Parameters

module

odule

Definition at line 1972 of file util.c.

{
  CCompilationUnitMemoryAllocations(module, false);
}

References CCompilationUnitMemoryAllocations(), and module.

Referenced by ResetCurrentCompilationUnitEntity().

Here is the call graph for this function:

Here is the caller graph for this function:

character_occurences_in_string()

unsigned int character_occurences_in_string	(	string	s,
		char	c
	)

Use a stack to survive to file inclusions if any.

I guess that it is currently not used since file inclusion is already done by the preprocessor... RK To track the absolute line number in the file that is parsed use the default flex yylineno that is renamed c_lineno here Use a stack to survive to file inclusions if any Count the number of c in s.

Definition at line 1133 of file clexer.c.

{
  string p = string_undefined;
  unsigned int count = 0;
 
  for(p=s; *p!='\0'; p++) {
    count += (*p==c)? 1 : 0 ;
  }
  return count;
}

Referenced by discard_C_comment().

Here is the caller graph for this function:

check_declaration_uniqueness_p()

bool check_declaration_uniqueness_p

(

statement

s

)

This is designed for standard C functions, not for compilation units.

e must be a function: they can be declared several times

Definition at line 3540 of file util.c.

{
  list dl = statement_declarations(s);
  bool failure_p = false;
 
  FOREACH(ENTITY, e, dl) {
    int n = gen_occurences(e, dl);
    if(n>1) {
      /* e must be a function: they can be declared several times */
      type t = ultimate_type(entity_type(e));
 
      if(!type_functional_p(t)) {
        pips_debug(0, "Entity \"%s\" declared %d times.\n", entity_name(e), n);
        failure_p = true;
      }
    }
  }
  if(failure_p)
    pips_internal_error("Module declarations are not unique");
 
  return !failure_p;
}

References ENTITY, entity_name, entity_type, FOREACH, gen_occurences(), pips_debug, pips_internal_error, statement_declarations, type_functional_p, and ultimate_type().

Referenced by actual_c_parser().

Here is the call graph for this function:

Here is the caller graph for this function:

CheckExternList()

bool CheckExternList

(

void

)

Definition at line 1025 of file util.c.

{
    entity f = get_current_module_entity();
    if(entity_undefined_p(f))
      pips_debug(5,"Current module is undefined\n");
    else {
      value fv = entity_initial(f);
      pips_debug(5,"Current module is function \"%s\"\n", entity_name(f));
      if(!value_undefined_p(fv)) {
        code fc = value_code(fv);
        if(!code_undefined_p(fc)) {
          list el = code_externs(fc);
          list le = gen_last(el);
          pips_debug(8, "Number of extern variables and functions: %zd\n",
                     gen_length(el));
          if(gen_length(el)>0) {
            pips_debug(8, "Last entity %s in cons %p with car=%p and cdr=%p\n",
                       entity_name(ENTITY(CAR(le))),
                       le,
                       &(le->car),
                       (void *) (le->cdr));
          }
          pips_assert("externs is an entity list", entity_list_p(el));
        }
      }
    }
    return true;
}

References cons::car, CAR, cons::cdr, code_externs, code_undefined_p, ENTITY, entity_initial, entity_list_p(), entity_name, entity_undefined_p, f(), gen_last(), gen_length(), get_current_module_entity(), pips_assert, pips_debug, value_code, and value_undefined_p.

Here is the call graph for this function:

CleanUpEntities()

void CleanUpEntities

(

list

le

)

update entity in module declarations

Update storage area

Update entity in current entity list

Remove entity from potentially removable externs and add it the new entity

Apparently, formal parameters may have been declared for such an entity and PIPS code dumps when the symbol table is written.

See decl62.c and decl63.c

Parameters

le

e

Definition at line 2772 of file util.c.

{
  list ce = list_undefined;
  bool found = false;
 
  for(ce=le; !ENDP(ce); POP(ce)) {
    entity e = ENTITY(CAR(ce));
    entity ne = CleanUpEntity(e);
    if(ne!=e) {
      entity m = get_current_module_entity();
      list d = code_declarations(value_code(entity_initial(m)));
      list de = list_undefined;
      storage s = entity_storage(e);
 
      /* update entity in module declarations */
      found = false;
      for(de=d; !ENDP(de); POP(de)) {
        entity ed = ENTITY(CAR(de));
        if(ed==e) {
          CAR(de).p = (gen_chunk *) ne;
          found = true;
        }
      }
      if(!found)
        pips_internal_error("Entity to be replaced not declared");
 
      /* Update storage area */
      found = false;
      if(storage_ram_p(s)) {
        ram r = storage_ram(s);
        entity a = ram_section(r);
        list ld = area_layout(type_area(entity_type(a)));
        list lde = list_undefined;
 
        for(lde=ld; !ENDP(lde); POP(lde)) {
          entity ed = ENTITY(CAR(lde));
          if(ed==e) {
            found = true;
            CAR(lde).p = (gen_chunk *) ne;
          }
        }
        if(!found)
          pips_internal_error("Entity to be replaced not allocated in its ram area");
      }
      else {
        pips_internal_error("Unexpected storage kind");
      }
 
      /* Update entity in current entity list */
      CAR(ce).p = (gen_chunk *) ne;
 
      /* Remove entity from potentially removable externs and add it
         the new entity */
      gen_remove(&removable_extern_entities, (void *) e);
      removable_extern_entities = CONS(ENTITY, ne, removable_extern_entities);
 
      /* Apparently, formal parameters may have been declared for such
       * an entity and PIPS code dumps when the symbol table is
       * written.
       *
       * See decl62.c and decl63.c
       */
      //free_entity(e);
    }
  }
}

References area_layout, CAR, CleanUpEntity(), code_declarations, CONS, ENDP, ENTITY, entity_initial, entity_storage, entity_type, gen_remove(), get_current_module_entity(), list_undefined, pips_internal_error, POP, ram_section, removable_extern_entities, storage_ram, storage_ram_p, type_area, and value_code.

Here is the call graph for this function:

clear_C_comment()

void clear_C_comment

(

void

)

Comments in the compilation unit and outside of function bodies are lost because they are related only to declarations and because comments on declarations are lost.

Definition at line 1489 of file clexer.c.

{
  if(!string_undefined_p(C_current_comment)) {
    free(C_current_comment);
    C_current_comment = string_undefined;
  }
  /* Comments in the compilation unit and outside of function bodies
     are lost because they are related only to
     declarations and because comments on declarations are lost.*/
  if(!comments_empty_p()) {
    int count = 0;
    pips_debug(3, "Comments stack is not empty:\n");
    while(!comments_empty_p()) {
      string c = comments_pop();
      count++;
      pips_debug(3, "Element %d: \"%s\"\n",
                 count, string_undefined_p(c) ? "string undefined" : c);
      if(!string_undefined_p(c))
        free(c);
    }
  }
  pips_assert("The comment stack is empty\n", comments_empty_p());
}

Referenced by error_reset_C_comment(), and reset_C_comment().

Here is the caller graph for this function:

CModuleMemoryAllocation()

void CModuleMemoryAllocation

(

entity

module

)

This function is for MemoryAllocation for Module of C programs.

Parameters

module

odule

Definition at line 1979 of file util.c.

{
  list ld = entity_declarations(module);
  entity var = entity_undefined;
 
  pips_debug(8,"MEMORY ALLOCATION BEGINS\n");
  nodecl_p(module,ModuleStatement);
  //print_entities(ld);
  for(; !ENDP(ld); ld = CDR(ld))
    {
      var = ENTITY(CAR(ld));
 
      if(!place_holder_variable_p(var) && type_variable_p(entity_type(var)))
        {
          storage s = entity_storage(var);
          if(storage_ram_p(s))
            {
              ram r = storage_ram(s);
              entity a = ram_section(r);
              if(!gen_in_list_p(var, code_externs(value_code(entity_initial(module))))) {
                ram_offset(r) = area_size(type_area(entity_type(a)));
                if(a == StackArea)
                  ram_offset(r) = DYNAMIC_RAM_OFFSET;
                else
                  add_C_variable_to_area(a,var);
              }
              else{
                if(ram_offset(r) == UNKNOWN_RAM_OFFSET)
                ram_offset(r) = UNDEFINED_RAM_OFFSET;
              }
            }
          if(storage_formal_p(s))
            {
              //DO NOTHING
            }
        }
    }
}

References add_C_variable_to_area(), area_size, CAR, CDR, code_externs, DYNAMIC_RAM_OFFSET, ENDP, ENTITY, entity_declarations, entity_initial, entity_storage, entity_type, entity_undefined, gen_in_list_p(), module, ModuleStatement, nodecl_p(), pips_debug, place_holder_variable_p(), ram_offset, ram_section, StackArea, storage_formal_p, storage_ram, storage_ram_p, type_area, type_variable_p, UNDEFINED_RAM_OFFSET, UNKNOWN_RAM_OFFSET, and value_code.

Referenced by ResetCurrentModule().

Here is the call graph for this function:

Here is the caller graph for this function:

compilation_unit_parser()

bool compilation_unit_parser

(

const char *

module_name

)

Parameters

module_name

odule_name

Definition at line 746 of file c_parser.c.

{
  return actual_c_parser(module_name,DBR_C_SOURCE_FILE,true);
}

References actual_c_parser(), module_name(), and STUB_ERROR.

Referenced by AddEntityToCompilationUnit(), and outliner_independent().

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeAreaOffset()

int ComputeAreaOffset	(	entity	a,
		entity	v
	)

Update the size and layout of the area aa. This function is called too earlier, we may not have the size of v. To be changed !!!

FI: who wrote this? when should the offsets be computed? how do we deal with scoping?

area_size(aa) = offset + 0;

Definition at line 3324 of file util.c.

{
  type ta = entity_type(a);
  area aa = type_area(ta);
  int offset = area_size(aa);
 
  pips_assert("Not used", false);
 
  /* Update the size and layout of the area aa.
     This function is called too earlier, we may not have the size of v.
     To be changed !!!
 
     FI: who wrote this? when should the offsets be computed? how do we deal with
     scoping?
  */
 
  pips_assert("Type is correctly defined", CSafeSizeOfArray(v)!=0);
 
  /* area_size(aa) = offset + 0; */
  area_size(aa) = offset + CSafeSizeOfArray(v);
  area_layout(aa) = gen_nconc(area_layout(aa), CONS(ENTITY, v, NIL));
  return offset;
}

References area_layout, area_size, CONS, CSafeSizeOfArray(), ENTITY, entity_type, gen_nconc(), NIL, offset, pips_assert, and type_area.

Here is the call graph for this function:

CreateDefaultContext()

c_parser_context CreateDefaultContext

(

void

)

Definition at line 292 of file cyacc.tab.c.

{
  c_parser_context c = make_c_parser_context(empty_scope(),
                                             type_undefined,
                                             storage_undefined,
                                             NIL,
                                             false,
                                             false);
  pips_debug(8, "New default context %p\n", c);
  return c;
}

Referenced by EnterScope().

Here is the caller graph for this function:

CreateEntityFromLocalNameAndPrefix()

entity CreateEntityFromLocalNameAndPrefix	(	string	name,
		string	prefix,
		bool	is_external
	)

We have to know the context:

• if the entity is declared outside any function, their scope is the CurrentCompilationUnit
• if the entity is declared inside a function, we have to know the CurrentBlock, which is omitted for the moment
• if the function is static, their scope is CurrentCompilationUnit::CurrentModule
• if the function is global, their scope is CurrentModule

The entity is created local to the file. For instance, derived and user-named types. This makes type checking more difficult as types such as FILE * vary from C file to C file, but this is consistent with the C standard and the behavior of production compilers: the same local name can be used for two different types in two different files.

These types are created globally, which makes type checking much easier but forbid homonym types in different files.

Parameters

name	ame
prefix	refix
is_external	s_external

Definition at line 962 of file util.c.

{
 /* We have to know the context:
 
    - if the entity is declared outside any function, their scope is
    the CurrentCompilationUnit
 
    - if the entity is declared inside a function, we have to know
    the CurrentBlock, which is omitted for the moment
 
    - if the function is static, their scope is
    CurrentCompilationUnit#CurrentModule
 
    - if the function is global, their scope is CurrentModule
 */
  entity ent = entity_undefined;
 
  if (is_external) {
    pips_debug(5,"Entity local name is %s with prefix %s\n",name,prefix);
    char *local_name;
    asprintf(&local_name,"%s%s",prefix,name);
    // See TRAC Ticket #787
#define FILE_LOCAL_USER_DEFINED_TYPES_P (true)
    if(FILE_LOCAL_USER_DEFINED_TYPES_P) {
      /* The entity is created local to the file. For instance,
       * derived and user-named types. This makes type checking more
       * difficult as types such as FILE * vary from C file to C file,
       * but this is consistent with the C standard and the behavior
       * of production compilers: the same local name can be used for
       * two different types in two different files. 
       */
      ent = FindOrCreateEntity(compilation_unit_name, local_name);
    }
    else {
      /* These types are created globally, which makes type checking
       * much easier but forbid homonym types in different files.
       */
      ent = FindOrCreateEntity(TOP_LEVEL_MODULE_NAME, local_name);
    }
    free(local_name);
  }
  else {
      string scope = scope_to_block_scope(GetScope());
 
      pips_debug(5,"Entity local name is %s with prefix %s and scope \"%s\"\n",
              name,prefix,scope);
      pips_assert("scope is a block scope", string_block_scope_p(scope));
 
      char * local_name;
      asprintf(&local_name,"%s%s%s",scope,prefix,name);
      if (static_module_p(get_current_module_entity())) {
          ent = FindOrCreateEntity( get_current_module_name(),  local_name);
      }
      else {
          ent = FindOrCreateEntity(get_current_module_name(), local_name);
      }
      free(local_name);
      free(scope);
  }
  pips_debug(5,"Entity global name is %s\n",entity_name(ent));
  return ent;
}

References asprintf, compilation_unit_name, entity_name, entity_undefined, FILE_LOCAL_USER_DEFINED_TYPES_P, FindOrCreateEntity(), free(), get_current_module_entity(), get_current_module_name(), GetScope(), is_external, local_name(), pips_assert, pips_debug, prefix, scope_to_block_scope(), static_module_p(), string_block_scope_p(), and TOP_LEVEL_MODULE_NAME.

Referenced by FindOrCreateCurrentEntity(), FindOrCreateEntityFromLocalNameAndPrefix(), FindOrCreateEntityFromLocalNameAndPrefixAndScope(), and MakeDerivedEntity().

Here is the call graph for this function:

Here is the caller graph for this function:

CreateMemberScope()

string CreateMemberScope	(	string	derived,
		bool	is_external
	)

We have to know the context :

• if the struct/union is declared outside any function, its scope is the CurrentCompilationUnit
• if the struct/union is declared inside a function, we have to know the CurrentBlock, which is omitted for the moment
• if the function is static, its scope is CurrentCompilationUnit!CurrentModule
• if the function is global, its scope is CurrentModule

The name of the struct/union is then added to the field entity name, with the MEMBER_SEP_STRING

ompilation_unit_name,

Parameters

derived	erived
is_external	s_external

Definition at line 3261 of file util.c.

{
  /* We have to know the context :
     - if the struct/union is declared outside any function, its scope is the CurrentCompilationUnit
     - if the struct/union is declared inside a function, we have to know the CurrentBlock,
     which is omitted for the moment
     - if the function is static, its scope is CurrentCompilationUnit!CurrentModule
     - if the function is global, its scope is CurrentModule
 
     The name of the struct/union is then added to the field entity name, with
     the MEMBER_SEP_STRING */
 
  string s = string_undefined;
 
  pips_debug(3,"Struc/union name is %s\n",derived);
 
  if (is_external)
    s = strdup(concatenate(compilation_unit_name, MODULE_SEP_STRING, derived, MEMBER_SEP_STRING, NULL));
  else {
    string scope = scope_to_block_scope(GetScope());
 
    pips_assert("scope is a block scope", string_block_scope_p(scope));
 
    if (static_module_p(get_current_module_entity()))
      s = strdup(concatenate(/*compilation_unit_name,*/
                             get_current_module_name(), MODULE_SEP_STRING,
                             scope, derived, MEMBER_SEP_STRING, NULL));
    else
      s = strdup(concatenate(get_current_module_name(), MODULE_SEP_STRING,
                             scope, derived, MEMBER_SEP_STRING, NULL));
  }
 
  pips_debug(3,"The struct/union member's scope is %s\n",s);
 
  return s;
}

References compilation_unit_name, concatenate(), get_current_module_entity(), get_current_module_name(), GetScope(), is_external, MEMBER_SEP_STRING, MODULE_SEP_STRING, pips_assert, pips_debug, scope_to_block_scope(), static_module_p(), strdup(), string_block_scope_p(), and string_undefined.

Here is the call graph for this function:

CreateReturnEntity()

void CreateReturnEntity

(

entity

f

)

If necessary, create the return entity, which is a hidden variable used in PIPS internal representation to carry the value returned by a function.

c_parser_user_warning() should not be called as it may be some times too late to get significant line numbers.

Create the return value

set the language

Definition at line 2382 of file util.c.

{
  if(type_undefined_p(entity_type(f))) {
    /* c_parser_user_warning() should not be called as it may be some
     * times too late to get significant line numbers.
     */
    c_parser_user_warning("Type of \"%s\" is undefined."
                          " Return value cannot be created.\n",
                          entity_user_name(f));
  }
  else {
    type ft = ultimate_type(entity_type(f));
 
    pips_debug(8, "For module \"%s\"\n", entity_name(f));
 
    if(type_functional_p(ft)) {
      type rt = functional_result(type_functional(ft));
 
      if(type_undefined_p(rt)) {
        c_parser_user_warning("Return type of \"%s\" is undefined."
                              " Return value cannot be created.\n",
                              entity_user_name(f));
      }
      else if(!type_void_p(rt)) {
        /* Create the return value */
        const char* fn = entity_local_name(f);
        entity re = FindOrCreateEntity(fn,fn);
        if(type_undefined_p(entity_type(re))) {
          entity_type(re) = copy_type(rt);
          entity_storage(re) = make_storage_return(f);
          /* set the language */
          entity_initial(re) = make_value_unknown();
          AddToDeclarations(re, f);
        }
      }
    }
    else
      pips_internal_error("This function should only be called with a function entity");
  }
}

References AddToDeclarations(), c_parser_user_warning, copy_type(), entity_initial, entity_local_name(), entity_name, entity_storage, entity_type, entity_user_name(), f(), FindOrCreateEntity(), functional_result, make_storage_return(), make_value_unknown(), pips_debug, pips_internal_error, type_functional, type_functional_p, type_undefined_p, type_void_p, and ultimate_type().

Referenced by UpdateEntity(), and UpdateEntity2().

Here is the call graph for this function:

Here is the caller graph for this function:

discard_C_comment()

void discard_C_comment

(

void

)

Discard a C comment because we don't know how to deal with it.

The comments are only made of '
', just silently discarding them

Definition at line 1426 of file clexer.c.

{
  if(!string_undefined_p(C_current_comment)) {
    if (character_occurences_in_string(C_current_comment, '\n')
        == strlen(C_current_comment)) {
      /* The comments are only made of '\n', just silently discarding them */
      pips_debug(3,"The \\n are lost, so the code presentation may be wrong...\n");
    }
    else {
      /*
      pips_user_warning("Comment \"%s\" is lost at line %d, "
                        "probably because comments cannot be attached to declarations.\n",
                        C_current_comment, C_line_number);
      */
      pips_debug(8, "Comment \"%s\" is lost at line %d, "
                 "probably because comments cannot be attached to declarations.\n",
                 C_current_comment, C_line_number);
    }
    free(C_current_comment);
    C_current_comment = string_undefined;
  }
}

dummy_prettyprint_control_list_p()

bool dummy_prettyprint_control_list_p

(

void

)

Provide the information only once.

Definition at line 1090 of file statement.c.

{
  bool b = dummy_declaration_p;
  dummy_declaration_p = false;
  return b;
}

References dummy_declaration_p.

Referenced by add_prettyprint_control_list_to_declaration_statement().

Here is the caller graph for this function:

error_reset_C_comment()

void error_reset_C_comment

(

bool

)

error_reset_c_parser_current_input_file_name()

void error_reset_c_parser_current_input_file_name

(

void

)

Definition at line 81 of file c_parser.c.

{
  c_parser_current_file_name = string_undefined;
}

References c_parser_current_file_name, and string_undefined.

Referenced by c_parser_error().

Here is the caller graph for this function:

error_reset_c_parser_current_user_input_file_name()

void error_reset_c_parser_current_user_input_file_name

(

void

)

Definition at line 112 of file c_parser.c.

{
  c_parser_current_user_input_file_name = string_undefined;
}

References c_parser_current_user_input_file_name, and string_undefined.

Referenced by c_parser_error().

Here is the caller graph for this function:

error_reset_current_C_line_number()

void error_reset_current_C_line_number

(

void

)

Definition at line 1224 of file clexer.c.

{
  C_line_number = UNDEFINED_C_LINE_NUMBER;
  previous_C_line_number = UNDEFINED_C_LINE_NUMBER;
  c_lineno = FIRST_C_LINE_NUMBER;
  previous_c_lineno = UNDEFINED_C_LINE_NUMBER;
 
  free_line_number_stack();
  free_absolute_line_number_stack();
}

ExitScope()

void ExitScope

(

void

)

Definition at line 400 of file cyacc.tab.c.

{
  c_parser_context c = (c_parser_context) stack_head(ContextStack);
 
  pop_c_parser_scope_stack();
 
  pips_assert("The current context is defined", !c_parser_context_undefined_p(c));
  pips_assert("The current context scope is defined",
              !string_undefined_p(c_parser_context_scope(c))
              && c_parser_context_scope(c)!=NULL);
  pips_assert("The current context only contains scope information",
              //type_undefined_p(c_parser_context_type(c)) &&
              storage_undefined_p(c_parser_context_storage(c))
              && ENDP(c_parser_context_qualifiers(c))
              //&& !c_parser_context_typedef(c)
              //&& !c_parser_context_static(c)
              );
  pips_debug(8, "Exiting context scope \"\%s\" in context %p\n",
             c_parser_context_scope(c), c);
  free_c_parser_context(c);
  (void) stack_pop(ContextStack);
  if(!stack_empty_p(ContextStack)) {
    c_parser_context oc = (c_parser_context) stack_head(ContextStack);
    //pips_assert("ycontext is consistant with stack_head(ContextStack)",
    //          ycontext==stack_head(ContextStack));
    pips_debug(8, "Back to context scope \"\%s\" in context %p\n",
               c_parser_context_scope(oc), oc);
  }
  else {
    // ycontext = c_parser_context_undefined;
    pips_debug(8, "Back to undefined context scope\n");
  }
}

ExpressionToStatement()

statement ExpressionToStatement

(

expression

e

)

e is now owned by returned statement

Definition at line 880 of file statement.c.

{
  syntax s = expression_syntax(e);
  statement st = statement_undefined;
  string c = get_current_C_comment();
 
  if (syntax_call_p(s)) {
    st = call_to_statement(syntax_call(s));
    syntax_call(s)=call_undefined;
    free_expression(e);
  }
  else
    st = instruction_to_statement(make_instruction_expression(e));
 
  statement_number(st) = get_current_C_line_number();
  if(!string_undefined_p(c)) {
    statement_comments(st) = c;
  }
 
  return st;
}

References call_to_statement, call_undefined, expression_syntax, free_expression(), get_current_C_comment(), get_current_C_line_number(), instruction_to_statement(), make_instruction_expression(), statement_comments, statement_number, statement_undefined, string_undefined_p, syntax_call, and syntax_call_p.

Here is the call graph for this function:

extern_prettyprint_control_list_p()

bool extern_prettyprint_control_list_p

(

void

)

void reset_prettyprint_control_list_to_extern(void)

{ extern_declaration_p = false; } Provide the information only once

Definition at line 1053 of file statement.c.

{
  bool b = extern_declaration_p;
  extern_declaration_p = false;
  return b;
}

References extern_declaration_p.

Referenced by add_prettyprint_control_list_to_declaration_statement().

Here is the caller graph for this function:

FindEntityFromLocalName()

entity FindEntityFromLocalName

(

string

name

)

Find an entity from its local name. We have to look for all possible prefixes, which are: blank, STRUCT_PREFIX, UNION_PREFIX, ENUM_PREFIX, TYPEDEF_PREFIX

How about multiple results ? The order of prefixes ?

Is it a static function? It must have been parsed in the compilation unit

Parameters

name

ame

Definition at line 778 of file util.c.

{
  /* Find an entity from its local name.
     We have to look for all possible prefixes, which are:
     blank, STRUCT_PREFIX, UNION_PREFIX, ENUM_PREFIX, TYPEDEF_PREFIX
 
     How about multiple results ? The order of prefixes ?  */
 
  entity ent = entity_undefined;
  string prefixes[] = {"",STRUCT_PREFIX, UNION_PREFIX, ENUM_PREFIX, TYPEDEF_PREFIX,NULL};
  int i;
  //c_parser_context cpc = GetScope();
  //string scope = scope_to_block_scope(c_parser_context_scope(cpc));
 
  for (i=0; prefixes[i]!=NULL; i++)
    {
      if ((ent = FindEntityFromLocalNameAndPrefix(name,prefixes[i])) != entity_undefined)
        return ent;
    }
 
  if(entity_undefined_p(ent)) {
    /* Is it a static function? It must have been parsed in the compilation unit */
    string sname = strdup(concatenate(compilation_unit_name, name, NULL));
    ent = FindEntity(compilation_unit_name, sname);
    free(sname);
    return ent;
  }
 
  c_parser_user_warning("Cannot find entity %s\n", name);
 
  return entity_undefined;
}

References c_parser_user_warning, compilation_unit_name, concatenate(), entity_undefined, entity_undefined_p, ENUM_PREFIX, FindEntity(), FindEntityFromLocalNameAndPrefix(), free(), prefixes, strdup(), STRUCT_PREFIX, TYPEDEF_PREFIX, and UNION_PREFIX.

Referenced by IdentifierToExpression().

Here is the call graph for this function:

Here is the caller graph for this function:

FindEntityFromLocalNameAndPrefix()

entity FindEntityFromLocalNameAndPrefix	(	string	name,
		string	prefix
	)

Find an entity from its local name and prefix. We have to look from the most enclosing scope.

Possible name combinations and the looking order:

1. FILE!MODULE:BLOCKPREFIXname or MODULE:BLOCKPREFIXname
2. FILE!MODULE:PREFIXname or MODULE:PREFIXname
3. FILE!:PREFIXname (used to be FILE!PREFIXname)
4. TOP-LEVEL:PREFIXname

with 5 possible prefixes: blank, STRUCT_PREFIX, UNION_PREFIX, ENUM_PREFIX, TYPEDEF_PREFIX

"!" is FILE_SEP_STRING and ":" is MODULE_SEP_STRING and "`" is BLOCK_SEP_STRING

First, look up the surrounding scopes

Is it a formal parameter not yet converted in the function frame?

Should we change the current dummy parameter number?

Is it a static variable declared in the compilation unit?

we have an issue there : a static function will be declared FILE!MODULE:FILE!name, but a static variable will be declared FILE!MODULE:name so try both ... CleanupEntity has been fixed to remove buggy situations ...

Is it a global variable declared in the compilation unit?

Is it a local type used within a function declaration?

It may be a parser error or a normal behavior when an entity is used before it is defined as, for example, a struct in a typedef: typedef struct foo foo;

CParserError("Variable appears to be undefined\n");

Parameters

name	ame
prefix	refix

Definition at line 877 of file util.c.

{
  /* Find an entity from its local name and prefix.
     We have to look from the most enclosing scope.
 
     Possible name combinations and the looking order:
 
     1. FILE!MODULE:BLOCK`PREFIXname or MODULE:BLOCK`PREFIXname
     2. FILE!MODULE:PREFIXname or MODULE:PREFIXname
     3. FILE!:PREFIXname (used to be FILE!PREFIXname)
     4. TOP-LEVEL:PREFIXname
 
     with 5 possible prefixes: blank, STRUCT_PREFIX, UNION_PREFIX, ENUM_PREFIX, TYPEDEF_PREFIX
 
     "!" is FILE_SEP_STRING and ":" is MODULE_SEP_STRING and "`" is BLOCK_SEP_STRING
 */
 
  entity ent = entity_undefined;
  string global_name = string_undefined;
  string scope = scope_to_block_scope(GetScope());
  string ls = strdup(scope);
  string ls_head = ls;
 
  pips_debug(5,"Entity local name is \"%s\" with prefix \"%s\" and scope \"%s\"\n",
             name,prefix,scope);
  pips_assert("Scope is a block scope", string_block_scope_p(scope));
  free(scope);
 
  /* First, look up the surrounding scopes */
  ent = FindEntityFromLocalNameAndPrefixAndScope(name, prefix, ls);
 
  /* Is it a formal parameter not yet converted in the function frame? */
  if(entity_undefined_p(ent)) {
    /* Should we change the current dummy parameter number? */
    string sn = int2a(get_current_dummy_parameter_number());
 
    global_name = (concatenate(DUMMY_PARAMETER_PREFIX,sn,MODULE_SEP_STRING,
                                     prefix,name,NULL));
    ent = gen_find_tabulated(global_name,entity_domain);
    free(sn);
  }
 
  /* Is it a static variable declared in the compilation unit? */
  /* we have an issue there : a static function will be declared  FILE!MODULE:FILE!name,
   * but a static variable will be declared FILE!MODULE:name
   * so try both ... CleanupEntity has been fixed to remove buggy situations ...*/
  if(entity_undefined_p(ent)) {
    global_name = (concatenate(compilation_unit_name,MODULE_SEP_STRING,
                                     prefix,name,NULL));
    ent = gen_find_tabulated(global_name,entity_domain);
  }
  if(entity_undefined_p(ent)) {
    global_name = (concatenate(compilation_unit_name,MODULE_SEP_STRING,compilation_unit_name,
                                     prefix,name,NULL));
    ent = gen_find_tabulated(global_name,entity_domain);
  }
 
  /* Is it a global variable declared in the compilation unit? */
  if(entity_undefined_p(ent)) {
    global_name = (concatenate(TOP_LEVEL_MODULE_NAME,MODULE_SEP_STRING,
                                     prefix,name,NULL));
    ent = gen_find_tabulated(global_name,entity_domain);
  }
 
  /* Is it a local type used within a function declaration? */
  if(entity_undefined_p(ent) && strcmp(ls, "")==0 && ScopeStackSize()>=2) {
    string lls = strdup(scope_to_block_scope(GetParentScope()));
    ent = FindEntityFromLocalNameAndPrefixAndScope(name, prefix, lls);
    free(lls);
  }
 
  if(entity_undefined_p(ent)) {
    pips_debug(8, "Cannot find entity with local name \"%s\" with prefix \"%s\" at line %d\n",
               name, prefix, get_current_C_line_number());
    /* It may be a parser error or a normal behavior when an entity is
       used before it is defined as, for example, a struct in a typedef:
       typedef struct foo foo; */
    /* CParserError("Variable appears to be undefined\n"); */
  } else
    pips_debug(5,"Entity global name is %s\n",entity_name(ent));
  //free(global_name);
  free(ls_head);
  return ent;
}

References compilation_unit_name, concatenate(), DUMMY_PARAMETER_PREFIX, entity_domain, entity_name, entity_undefined, entity_undefined_p, FindEntityFromLocalNameAndPrefixAndScope(), free(), gen_find_tabulated(), get_current_C_line_number(), get_current_dummy_parameter_number(), GetParentScope(), GetScope(), int2a(), MODULE_SEP_STRING, pips_assert, pips_debug, prefix, scope_to_block_scope(), ScopeStackSize(), strdup(), string_block_scope_p(), string_undefined, and TOP_LEVEL_MODULE_NAME.

Referenced by FindEntityFromLocalName(), FindOrCreateEntityFromLocalNameAndPrefix(), and FindOrCreateEntityFromLocalNameAndPrefixAndScope().

Here is the call graph for this function:

Here is the caller graph for this function:

FindEntityFromLocalNameAndPrefixAndScope()

entity FindEntityFromLocalNameAndPrefixAndScope	(	string	name,
		string	prefix,
		string	scope
	)

The parameter "scope" is potentially destroyed.

Add block scope case here

ompilation_unit_name,

return values are not C variables... but they are entities.

Parameters

name	ame
prefix	refix
scope	cope

Definition at line 850 of file util.c.

{
  entity ent = entity_undefined;
 
  if (!entity_undefined_p(get_current_module_entity())) {
    string global_name = string_undefined;
    /* Add block scope case here */
    do {
      if (static_module_p(get_current_module_entity()))
        global_name = (concatenate(/*compilation_unit_name,*/
                                         get_current_module_name(),MODULE_SEP_STRING,
                                         scope,prefix,name,NULL));
      else
        global_name = (concatenate(get_current_module_name(),MODULE_SEP_STRING,
                                         scope,prefix,name,NULL));
      ent = gen_find_tabulated(global_name,entity_domain);
      /* return values are not C variables... but they are entities. */
      if(!entity_undefined_p(ent)
         && !storage_undefined_p(entity_storage(ent))
         && storage_return_p(entity_storage(ent))) {
        ent = entity_undefined;
      }
    } while(entity_undefined_p(ent) && (scope = pop_block_scope(scope))!=NULL);
  }
  return ent;
}

References concatenate(), entity_domain, entity_storage, entity_undefined, entity_undefined_p, gen_find_tabulated(), get_current_module_entity(), get_current_module_name(), MODULE_SEP_STRING, pop_block_scope(), prefix, static_module_p(), storage_return_p, storage_undefined_p, and string_undefined.

Referenced by FindEntityFromLocalNameAndPrefix().

Here is the call graph for this function:

Here is the caller graph for this function:

FindOrCreateCurrentEntity()

entity FindOrCreateCurrentEntity	(	string	,
		stack	,
		stack	,
		stack	,
		bool
	)

FindOrCreateEntityFromLocalNameAndPrefix()

entity FindOrCreateEntityFromLocalNameAndPrefix	(	string	name,
		string	prefix,
		bool	is_external
	)

Parameters

name	ame
prefix	refix
is_external	s_external

Definition at line 811 of file util.c.

{
  entity e;
 
  if ((e = FindEntityFromLocalNameAndPrefix(name,prefix)) != entity_undefined)
    return e;
  return CreateEntityFromLocalNameAndPrefix(name,prefix,is_external);
}

References CreateEntityFromLocalNameAndPrefix(), entity_undefined, FindEntityFromLocalNameAndPrefix(), is_external, and prefix.

Here is the call graph for this function:

FindOrCreateEntityFromLocalNameAndPrefixAndScope()

entity FindOrCreateEntityFromLocalNameAndPrefixAndScope	(	string	name,
		string	prefix,
		string	scope,
		bool	is_external
	)

The current scope will be automatically added

Parameters

name	ame
prefix	refix
scope	cope
is_external	s_external

Definition at line 820 of file util.c.

{
  entity e = entity_undefined;
  string ls = strdup(scope);
  string ls_head = ls;
 
  pips_assert("Should not be used", false);
 
  pips_assert("scope is a block scope", string_block_scope_p(scope));
 
  do {
    string sname = strdup(concatenate(ls, name, NULL));
    e = FindEntityFromLocalNameAndPrefix(sname,prefix);
    free(sname);
  }
  while(e != entity_undefined && (ls = pop_block_scope(ls)));
 
  if(entity_undefined_p(e)) {
    /* The current scope will be automatically added */
    e = CreateEntityFromLocalNameAndPrefix(name,prefix,is_external);
  }
  free(ls_head);
  pips_debug(8, "Entity returned: \"%s\"\n", entity_name(e));
  return e;
}

References concatenate(), CreateEntityFromLocalNameAndPrefix(), entity_name, entity_undefined, entity_undefined_p, FindEntityFromLocalNameAndPrefix(), free(), is_external, pips_assert, pips_debug, pop_block_scope(), prefix, strdup(), and string_block_scope_p().

Here is the call graph for this function:

FindParameterEntity()

parameter FindParameterEntity	(	string	s,
		int	offset,
		list	l
	)

to be verified in C, when by reference, when by value

Parameters

offset

ffset

Definition at line 3384 of file util.c.

{
  FOREACH(ENTITY,e,l)
  {
    const char* name = entity_user_name(e);
    if (strcmp(name,s)==0)
      {
        type t = entity_type(e);
        mode m = make_mode_value(); /* to be verified in C, when by reference, when by value*/
        /*
          What about the storage of
 
          void AMMPmonitor( vfs,ffs,nfs,op )
          int  (*vfs[])(),(*ffs[])();
          int nfs;
          FILE *op;*/
 
        storage st = entity_storage(e);
        if (storage_formal_p(st))
          {
            formal f = storage_formal(st);
            formal_offset(f) = offset;
          }
        return make_parameter(t,m,make_dummy_identifier(e)); // FI: Could be entity_undefined
      }
  }
  return parameter_undefined;
}

References ENTITY, entity_storage, entity_type, entity_user_name(), f(), FOREACH, formal_offset, make_dummy_identifier(), make_mode_value(), make_parameter(), offset, parameter_undefined, storage_formal, and storage_formal_p.

Referenced by MakeParameterList().

Here is the call graph for this function:

Here is the caller graph for this function:

FindStatementFromLabel()

statement FindStatementFromLabel

(

entity

l

)

Definition at line 189 of file statement.c.

{
  MAP(STATEMENT,s,
  {
    if (statement_label(s) == l)
      return s;
  },LabeledStatements);
  return statement_undefined;
}

References LabeledStatements, MAP, STATEMENT, statement_label, and statement_undefined.

Referenced by MakeForloop(), MakeGotoStatement(), MakeLabeledStatement(), MakeSwitchStatement(), and MakeWhileLoop().

Here is the caller graph for this function:

FixCReturnStatements()

void FixCReturnStatements

(

statement

ms

)

When return statements have been encountered, each of them has been replaced by a goto to a unique return statement.

This unique return statement may have to be added to the function body.

How many return statements have been encountered?

nothing to be done

If the return statement is the last statement of the module statement, the goto and the assignment can be replaced by a call to return. Otherwise, a return statement with the proper label must be added at the end of the module statement ms

The goto instruction and, possibly, the return value assignment can be removed: just remove the label?

Do not forget to declare the return variable...

Parameters

ms

s

Definition at line 223 of file return.c.

{
  if(get_bool_property("C_PARSER_RETURN_SUBSTITUTION")) {
    /* How many return statements have been encountered? */
    int nrs = GetReturnNumber();
    int replace_p = false;
    if(nrs==-1 || nrs==0)
      ; /* nothing to be done */
    else if(nrs==1) {
      /* If the return statement is the last statement of the module
         statement, the goto and the assignment can be replaced by a
         call to return. Otherwise, a return statement with the
         proper label must be added at the end of the module statement
         ms */
      //statement ls = find_last_statement(ms);
      statement ls = last_statement(ms);
      if(!statement_undefined_p(ls)) {
        instruction li = statement_instruction(ls);
        if(instruction_goto_p(li)) {
          statement ts = instruction_goto(li);
          if(ts==C_return_statement) {
            //instruction lrvai =
            //  statement_instruction(last_return_value_assignment);
            /* The goto instruction and, possibly, the return value
               assignment can be removed: just remove the label? */
            statement_instruction(ls) = call_to_instruction
              (make_call(CreateIntrinsic(C_RETURN_FUNCTION_NAME),
                         last_returned_value));
            if(!statement_undefined_p(last_return_value_assignment))
              statement_instruction(last_return_value_assignment) =
                make_continue_instruction();
            free_instruction(li);
            //free_instruction(lrvai); contains the expression resued above!
            replace_p = false;
          }
          else
            replace_p = true;
        }
        else
          replace_p = true;
      }
      else
        replace_p = true;
    }
    else if(nrs>1)
      replace_p = true;
    else
      pips_internal_error("The number of return statements has"
                          " not been initialized");
 
    if(replace_p) {
      /* Do not forget to declare the return variable... */
      if(!entity_undefined_p(return_value_entity)) {
        pips_assert("ms is a block", statement_block_p(ms));
        set_current_module_entity(return_current_module);
        AddLocalEntityToDeclarations(return_value_entity,
                                     return_current_module,
                                     ms);
        reset_current_module_entity();
      }
      insert_statement(ms, C_return_statement, false);
    }
  }
  Reset_C_ReturnStatement();
}

References AddLocalEntityToDeclarations(), C_RETURN_FUNCTION_NAME, C_return_statement, call_to_instruction, CreateIntrinsic(), entity_undefined_p, free_instruction(), get_bool_property(), GetReturnNumber(), insert_statement(), instruction_goto, instruction_goto_p, last_return_value_assignment, last_returned_value, last_statement(), make_call(), make_continue_instruction(), pips_assert, pips_internal_error, Reset_C_ReturnStatement(), reset_current_module_entity(), return_current_module, return_value_entity, set_current_module_entity(), statement_block_p, statement_instruction, and statement_undefined_p.

Referenced by actual_c_parser().

Here is the call graph for this function:

Here is the caller graph for this function:

force_reset_c_parser_scope_stack()

void force_reset_c_parser_scope_stack

(

void

)

To be used by an error handler.

Definition at line 539 of file cyacc.tab.c.

 {
   if(c_parser_scope_stack != stack_undefined) {
       stack_free(&c_parser_scope_stack);
       c_parser_scope_stack = stack_undefined;
   }
   c_parser_scope_number = SCOPE_UNDEFINED;
   return;
 }

Generate_C_ReturnLabel()

entity Generate_C_ReturnLabel

(

entity

m

)

return.c

return.c

Unlike Fortran return statements, C return statements carry the value returned by functions. In some sense, they have a continuation since they return to the caller, but there is no local continuation. So C return cannot be simply replaced by goto statements. This only preserves the control semantics. An additional variable, the return value, must be declared and used to collect information about the different values that are returned. This translation can be removed when there is only one return at the end of the function body. Note that pass restructure_control may be useful for procedure with several returns because unspaghettify, called by the controlizer, is not strong enough.

Francois Irigoin

Definition at line 58 of file return.c.

{
  entity l = make_label(entity_module_name(m), LABEL_PREFIX RETURN_LABEL_NAME);
  return l;
}

References entity_module_name(), LABEL_PREFIX, make_label(), and RETURN_LABEL_NAME.

Referenced by Generate_C_ReturnStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

Generate_C_ReturnStatement()

statement Generate_C_ReturnStatement

(

void

)

Definition at line 84 of file return.c.

{
  instruction i = instruction_undefined;
  entity m = get_current_module_entity();
  entity l = Generate_C_ReturnLabel(m);
  statement s = statement_undefined;
  type mt = entity_type(m);
  functional f = type_functional(mt);
  type r = functional_result(f);
 
  if(type_void_p(r))
    i = make_call_instruction(entity_intrinsic(C_RETURN_FUNCTION_NAME), NIL);
  else {
    entity rv = function_to_return_value(m);
    expression arg = entity_to_expression(rv);
    return_value_entity = rv;
    return_current_module = m;
    i = make_call_instruction(entity_intrinsic(C_RETURN_FUNCTION_NAME),
                              CONS(EXPRESSION, arg, NIL));
  }
 
  // FI: I'd like to add a return label to this special statement...
  s = instruction_to_statement(i);
  statement_label(s) = l;
  return s;
}

References C_RETURN_FUNCTION_NAME, CONS, entity_intrinsic(), entity_to_expression(), entity_type, EXPRESSION, f(), function_to_return_value(), functional_result, Generate_C_ReturnLabel(), get_current_module_entity(), instruction_to_statement(), instruction_undefined, make_call_instruction(), NIL, return_current_module, return_value_entity, statement_label, statement_undefined, type_functional, and type_void_p.

Referenced by Get_C_ReturnStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

get_c_parser_current_input_file_name()

string get_c_parser_current_input_file_name

(

void

)

Definition at line 58 of file c_parser.c.

{
  if(string_undefined_p(c_parser_current_file_name))
    pips_internal_error("c_parser_current_file_name not initialized.\n");
  return c_parser_current_file_name;
}

References c_parser_current_file_name, pips_internal_error, and string_undefined_p.

Referenced by c_parser_user_warning_alist(), and UpdateEntity().

Here is the caller graph for this function:

get_c_parser_current_scope()

string get_c_parser_current_scope

(

void

)

Definition at line 569 of file cyacc.tab.c.

 {
   string sn = string_undefined;
   if(c_parser_scope_stack_empty_p()) {
     // We are at the global level: no scope has been entered yet
     sn = "";
   }
   else
     sn = (string) stack_head(c_parser_scope_stack);
   return sn;
 }

get_c_parser_current_user_input_file_name()

string get_c_parser_current_user_input_file_name

(

void

)

Definition at line 89 of file c_parser.c.

{
  if(string_undefined_p(c_parser_current_user_input_file_name))
    pips_internal_error("c_parser_current_user_input_file_name not initialized.\n");
  return c_parser_current_user_input_file_name;
}

References c_parser_current_user_input_file_name, pips_internal_error, and string_undefined_p.

Referenced by c_parser_error(), and c_parser_user_warning_alist().

Here is the caller graph for this function:

get_c_parser_nth_scope()

string get_c_parser_nth_scope

(

int

n

)

Definition at line 581 of file cyacc.tab.c.

 {
   string sn = (string) stack_nth(c_parser_scope_stack, n);
   return sn;
 }

Get_C_ReturnStatement()

statement Get_C_ReturnStatement

(

void

)

This function is used to generate all goto's towards the unique return used to C replace return statement and to insert this unique return at the end of the current function's body.

Definition at line 130 of file return.c.

{
  if(statement_undefined_p(C_return_statement)) {
    pips_assert("No return statement yet\n",  number_of_return_statements==-1);
    number_of_return_statements = 0;
    C_return_statement = Generate_C_ReturnStatement();
  }
  number_of_return_statements++;
  return C_return_statement;
}

References C_return_statement, Generate_C_ReturnStatement(), number_of_return_statements, pips_assert, and statement_undefined_p.

Referenced by C_MakeReturnStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

get_current_C_comment()

string get_current_C_comment

(

void

)

Return the current comment as a string to be freed by the caller and reset the current comment.

If the current comment is undefined, returns a copy of the empty string, "".

Reset also the current comment.

If the comment begins with a new-line, it is indeed the new-line that ends the previous statement, so skip it. Quicker than strlen()

• memmove():

Note there won't be a memory leak since the orginal '\0' is in the malloc() bloc to be free()ed anyway...

If the comment is only an empty one, do not retain it:

Do retain it to keep the statement data structure easy to use, allowing strdup() on its text fields

Remove the trailing new-line if any since the RI is already line-oriented at the comment level: This is already done above.

It is a trailing new-line: just get rid of it:

pips_debug(3, "get_current_C_comment comment \"s"
", cc);

Definition at line 1282 of file clexer.c.

{
  string cc = C_current_comment;
  C_current_comment = string_undefined;
  if (cc != string_undefined) {
    if (cc[0] == '\n') {
      /* If the comment begins with a new-line, it is indeed the new-line
         that ends the previous statement, so skip it. Quicker than strlen()
         + memmove(): */
      char * p = &cc[0];
      do {
        p[0] = p[1];
      }
      while (*p++ != '\0');
      /* Note there won't be a memory leak since the orginal '\0' is in the
         malloc() bloc to be free()ed anyway... */
    }
    /* If the comment is only an empty one, do not retain it: */
    if (cc[0] == '\0') {
      /* Do retain it to keep the statement data structure easy to use, allowing strdup() on its text fields */
      //free(cc);
      //cc = string_undefined;
      ;
    }
    else {
      /* Remove the trailing new-line if any since the RI is already
         line-oriented at the comment level: This is already done above. */
      char * last_newline = strrchr(cc, '\n');
      if (last_newline != NULL && last_newline[1] == '\0') {
        /* It is a trailing new-line: just get rid of it: */
        //last_newline[0] = '\0';
        ;
      }
    }
  }
  else
    cc = strdup("");
  /* pips_debug(3, "get_current_C_comment comment \"%s\"\n",
     cc); */
  // Too early
  // token_has_been_seen_p = false;
  return cc;
}

Referenced by push_current_C_comment().

Here is the caller graph for this function:

get_current_C_line_number()

int get_current_C_line_number

(

void

)

FI: I assume that get_current_C_line_number is called only by some kind of make_statement()

The PIPS preprocessed C function files contain a specific first line to convert the line number in the workspace unto a line number in the user source file.

Definition at line 1146 of file clexer.c.

{
  /* FI: I assume that get_current_C_line_number is called only 
   * by some kind of make_statement()
   *
   * The PIPS preprocessed C function files contain a specific first line
   * to convert the line number in the workspace unto a line number in the
   * user source file.
   */
  previous_C_line_number = C_line_number;
  previous_c_lineno = c_lineno;
  return C_line_number;
}

Referenced by pop_current_C_comment(), push_current_C_comment(), and push_current_C_line_number().

Here is the caller graph for this function:

get_current_compilation_unit_entity()

entity get_current_compilation_unit_entity

(

void

)

Definition at line 320 of file util.c.

{
  return FindOrCreateEntity(TOP_LEVEL_MODULE_NAME,compilation_unit_name);
}

References compilation_unit_name, FindOrCreateEntity(), and TOP_LEVEL_MODULE_NAME.

Referenced by callnodeclfilter(), FindOrCreateCurrentEntity(), MakeFunctionExpression(), MakeStorageRam(), and referencenodeclfilter().

Here is the call graph for this function:

Here is the caller graph for this function:

get_declaration_counter()

int get_declaration_counter

(

void

)

Definition at line 497 of file cyacc.tab.c.

 {
   return declaration_counter;
 }

get_from_entity_type_stack_table()

stack get_from_entity_type_stack_table

(

entity

key

)

Parameters

key

ey

Definition at line 146 of file c_parser.c.

{
  void * p = hash_get(entity_to_type_stack_table, entity_name(key));
 
  if(p==HASH_UNDEFINED_VALUE)
    return stack_undefined;
  else
    return ((stack) p);
}

References entity_name, entity_to_type_stack_table, hash_get(), HASH_UNDEFINED_VALUE, and stack_undefined.

Referenced by FindOrCreateCurrentEntity(), RenameFunctionEntity(), SubstituteDummyParameters(), UpdateAbstractEntity(), UpdateDerivedEntity(), UpdateEntity(), and UseFormalArguments().

Here is the call graph for this function:

Here is the caller graph for this function:

get_previous_C_line_number()

int get_previous_C_line_number

(

void

)

Should be called just before get_current_C_line_number.

Definition at line 1161 of file clexer.c.

{
  return previous_C_line_number;
}

get_previous_c_lineno()

int get_previous_c_lineno

(

void

)

Definition at line 1115 of file clexer.c.

{
  return previous_c_lineno;
}

get_top_level_entity()

entity get_top_level_entity

(

void

)

Definition at line 152 of file util.c.

{
  return FindOrCreateEntity(TOP_LEVEL_MODULE_NAME,TOP_LEVEL_MODULE_NAME);
}

References FindOrCreateEntity(), and TOP_LEVEL_MODULE_NAME.

Referenced by MakeStorageRam(), and step_parameter().

Here is the call graph for this function:

Here is the caller graph for this function:

GetContext()

c_parser_context GetContext

(

void

)

Definition at line 458 of file cyacc.tab.c.

{
 
    c_parser_context c = c_parser_context_undefined;
 
    if(!stack_empty_p(ContextStack))
      c = (c_parser_context) stack_head(ContextStack);
    else
      // Should we return a default context?
      // Not really compatible with a clean memory allocation policy
      pips_internal_error("No current context");
 
  pips_debug(8, "Context %p is obtained from stack position %d\n",
             c, stack_size(ContextStack));
 
  return c;
}

GetContextCopy()

c_parser_context GetContextCopy

(

void

)

Definition at line 476 of file cyacc.tab.c.

{
  c_parser_context c = (c_parser_context) stack_head(ContextStack);
  c_parser_context cc = copy_c_parser_context(c);
  pips_debug(8, "Context copy %p with scope \"%s\" is obtained from context %p with scope \"%s\" at stack position %d\n",
             cc, c_parser_context_scope(cc),
             c, c_parser_context_scope(c),
             stack_size(ContextStack));
  return cc;
}

GetFunction()

entity GetFunction

(

void

)

cproto workaround

cyacc.tab.c

from "cyacc.y"

cyacc.tab.c

from "cyacc.y"

Definition at line 146 of file cyacc.tab.c.

{
  entity f = stack_head(FunctionStack);
  return f;
}

GetParentScope()

string GetParentScope

(

void

)

Definition at line 387 of file cyacc.tab.c.

{
  string s = "";
 
  if(!stack_empty_p(ContextStack) && stack_size(ContextStack)>=2) {
    c_parser_context c = (c_parser_context) stack_nth(ContextStack,2);
 
    s = c_parser_context_scope(c);
  }
 
  return s;
}

GetReturnNumber()

int GetReturnNumber

(

void

)

Definition at line 214 of file return.c.

{
  return number_of_return_statements;
}

References number_of_return_statements.

Referenced by FixCReturnStatements().

Here is the caller graph for this function:

GetScope()

string GetScope

(

void

)

FI: I do not know if it wouldn't be better to initialize the ContextStack with a default context before calling the C parser

Definition at line 371 of file cyacc.tab.c.

{
  string s = "";
 
  /* FI: I do not know if it wouldn't be better to initialize the
     ContextStack with a default context before calling the C
     parser */
  if(!stack_empty_p(ContextStack)) {
    c_parser_context c = (c_parser_context) stack_head(ContextStack);
 
    s = c_parser_context_scope(c);
  }
 
  return s;
}

IdentifierToExpression()

expression IdentifierToExpression

(

string

s

)

Could this be non declared variables ?

This identifier has not been passed by the parser. It is probably a function call => try this case now and complete others later. The scope of this function is global

This may be a call or a reference in case a functional pointer is initialized

eturn MakeNullaryCall(ent);

FI: This may happen when a variable is used to initialize another variable within the same declaration statement: see decl29.c. This might not be a general fix as the type could be functional: to be checked. But setting up type earlier would require a huge change in the parser rules. Unless FindOrCreateCurrentEntity() could do a better job? But the information added is later destroyed by the parser.

Generate a call to an enum member

Definition at line 650 of file util.c.

{
  entity ent = FindEntityFromLocalName(s);
  expression exp = expression_undefined;
 
  pips_debug(5,"Identifier is \"%s\" and entity_name is \"\%s\"\n",
             s, safe_entity_name(ent));
 
  if (entity_undefined_p(ent)) {
      /* Could this be non declared variables ?*/
      /* This identifier has not been passed by the parser.
         It is probably a function call => try this case now and complete others later.
         The scope of this function is global */
      pips_debug(5,"Create unparsed global function: %s\n",s);
      ent = FindOrCreateEntity(TOP_LEVEL_MODULE_NAME,s);
      //entity_storage(ent) = make_storage_return(ent);
      entity_storage(ent) = make_storage_rom();
      entity_type(ent) = make_type_functional(make_functional(NIL,make_type_unknown()));
      entity_initial(ent) = make_value(is_value_code,make_code(NIL,strdup(""),make_sequence(NIL),NIL, make_language_c()));
      /* This may be a call or a reference in case a functional pointer is initialized */
      exp = make_expression(make_syntax_reference(make_reference(ent,NIL)),normalized_undefined);
      /*return MakeNullaryCall(ent);*/
    }
  else if(type_undefined_p(entity_type(ent))) {
    /* FI: This may happen when a variable is used to initialize another
       variable within the same declaration statement: see
       decl29.c. This might not be a general fix as the type could be
       functional: to be checked. But setting up type earlier would require a huge
       change in the parser rules. Unless FindOrCreateCurrentEntity()
       could do a better job? But the information added is later
       destroyed by the parser. */
    exp = make_expression(make_syntax_reference(make_reference(ent,NIL)),
                          normalized_undefined);
  }
  else {
    switch (type_tag(entity_type(ent))) {
    case is_type_variable:
    case is_type_functional:
      {
        value iv = entity_initial(ent);
 
        if(!value_undefined_p(iv) && value_symbolic_p(iv))
          /* Generate a call to an enum member */
          exp = make_expression(make_syntax_call(make_call(ent, NIL)), normalized_undefined);
        else
      exp = make_expression(make_syntax_reference(make_reference(ent,NIL)),
                                               normalized_undefined);
 
        break;
      }
    default:
      {
        CParserError("Which kind of expression?\n");
      }
    }
  }
  return exp;
}

References CParserError(), entity_initial, entity_storage, entity_type, entity_undefined_p, exp, expression_undefined, FindEntityFromLocalName(), FindOrCreateEntity(), is_type_functional, is_type_variable, is_value_code, make_call(), make_code(), make_expression(), make_functional(), make_language_c(), make_reference(), make_sequence(), make_storage_rom(), make_syntax_call(), make_syntax_reference(), make_type_functional(), make_type_unknown(), make_value(), NIL, normalized_undefined, pips_debug, safe_entity_name(), strdup(), TOP_LEVEL_MODULE_NAME, type_tag, type_undefined_p, value_symbolic_p, and value_undefined_p.

Referenced by MemberDerivedIdentifierToExpression().

Here is the call graph for this function:

Here is the caller graph for this function:

init_c_areas()

void init_c_areas

(

void

)

In C we have 4 areas.

1. globalStaticArea: For the Global Variables, these variables are added into StaticArea.
2. moduleStaticArea: For the Static module variables
3. localStaticArea(SticArea): General Static variables
4. DynamicArea The GlobalStaticArea and ModuleStaticArea are basically static areas but they are not defined globally. It is to be added to the Declarations for C

Create a hidden pointer in the heap area to modelize malloc and free effects and to keep track of the corresponding abstract state.

FI: I use a complex type to avoid seeing this variable in the transformers and preconditions... OK, it's not a clean way to do it. Should we create another area to allocate this abstract heap state?

FI: I keep the code below, because it may turn useful again if context-insensitive address values must be generated.

This is because of the reparsing of the compilation unit The area is set to zero and all the declarations are overrided and the memory is reallocated The area is reset to only when it is called by same compilation unit twice. The code is dangerous hence it is commented. Please have a look

if( get_current_compilation_unit_entity() == get_current_module_entity() && (get_current_compilation_unit_entity() == previouscompilationunit)) area_size(type_area(entity_type(msae))) = 0;

if( get_current_compilation_unit_entity() == get_current_module_entity() && (get_current_compilation_unit_entity() == previouscompilationunit)) area_size(type_area(entity_type(gsae))) = previoussizeofGlobalArea ;

Definition at line 186 of file util.c.

{
  DynamicArea = FindOrCreateEntity(get_current_module_name(), DYNAMIC_AREA_LOCAL_NAME);
  entity_type(DynamicArea) = make_type(is_type_area, make_area(0, NIL));
  entity_storage(DynamicArea) = make_storage_rom();
  entity_initial(DynamicArea) = make_value_unknown();
  entity_kind(DynamicArea) = ABSTRACT_LOCATION|ENTITY_DYNAMIC_AREA;
  AddEntityToDeclarations(DynamicArea, get_current_module_entity());
 
  StaticArea = FindOrCreateEntity(get_current_module_name(), STATIC_AREA_LOCAL_NAME);
  entity_type(StaticArea) = make_type(is_type_area, make_area(0, NIL));
  entity_storage(StaticArea) = make_storage_rom();
  entity_initial(StaticArea) = make_value_unknown();
  entity_kind(StaticArea) = ABSTRACT_LOCATION|ENTITY_STATIC_AREA;
  AddEntityToDeclarations(StaticArea, get_current_module_entity());
 
  //HeapArea = FindOrCreateEntity(compilation_unit_name, HEAP_AREA_LOCAL_NAME);
  HeapArea = FindOrCreateEntity(get_current_module_name(), HEAP_AREA_LOCAL_NAME);
  entity_type(HeapArea) = make_type(is_type_area, make_area(0, NIL));
  entity_storage(HeapArea) = make_storage_rom();
  entity_initial(HeapArea) = make_value_unknown();
  entity_kind(HeapArea) = ABSTRACT_LOCATION|ENTITY_HEAP_AREA;
  AddEntityToDeclarations(HeapArea, get_current_module_entity());
 
  /* Create a hidden pointer in the heap area to modelize malloc and
     free effects and to keep track of the corresponding abstract
     state. */
    /* FI: I use a complex type to avoid seeing this variable in the
       transformers and preconditions... OK, it's not a clean way to
       do it. Should we create another area to allocate this abstract
       heap state? */
  /* FI: I keep the code below, because it may turn useful again if
     context-insensitive address values must be generated. */
  /*
  if(!compilation_unit_entity_p(get_current_module_entity())) {
    make_entity(AddPackageToName(get_current_module_name(),
                                 MALLOC_EFFECTS_NAME),
                make_scalar_complex_type(DEFAULT_COMPLEX_TYPE_SIZE),
 
                Chose a storage... Maybe in MALLOC_EFFECTS_PACKAGE_NAME?
 
                make_storage(is_storage_ram,
                make_ram(entity_undefined, DynamicArea, 0, NIL))
                
                make_storage(is_storage_ram,
                             make_ram(get_current_module_entity(),
                                      HeapArea,
                                      0, NIL)),
                make_value(is_value_unknown, UU));
  }
  */
 
  // Dynamic variables whose size are not known are stored in Stack area
  StackArea = FindOrCreateEntity(get_current_module_name(), STACK_AREA_LOCAL_NAME);
  entity_type(StackArea) = make_type(is_type_area, make_area(0, NIL));
  entity_storage(StackArea) = make_storage_rom();
  entity_initial(StackArea) = make_value_unknown();
  entity_kind(StackArea) = ABSTRACT_LOCATION|ENTITY_STACK_AREA;
  AddEntityToDeclarations(StackArea, get_current_module_entity());
 
  entity msae = FindOrCreateEntity(compilation_unit_name,  STATIC_AREA_LOCAL_NAME);
  entity_kind(msae) = ABSTRACT_LOCATION|ENTITY_STATIC_AREA;
  AddEntityToDeclarations(msae, get_current_module_entity());
 
  entity gsae = FindOrCreateEntity(TOP_LEVEL_MODULE_NAME,  STATIC_AREA_LOCAL_NAME);
  entity_kind(gsae) = ABSTRACT_LOCATION|ENTITY_STATIC_AREA;
  AddEntityToDeclarations(gsae, get_current_module_entity());
 
  /* This is because of the reparsing of the compilation unit
     The area is set to zero and all the declarations are overrided and the memory is reallocated
     The area is reset to only when it is called by same compilation unit twice.
     The code is dangerous hence it is commented. Please have a look
 
     if( get_current_compilation_unit_entity() == get_current_module_entity() &&
     (get_current_compilation_unit_entity() == previouscompilationunit))
     area_size(type_area(entity_type(msae))) = 0;
 
     if( get_current_compilation_unit_entity() == get_current_module_entity() &&
     (get_current_compilation_unit_entity() == previouscompilationunit))
     area_size(type_area(entity_type(gsae))) = previoussizeofGlobalArea ;
  */
}

References ABSTRACT_LOCATION, AddEntityToDeclarations(), compilation_unit_name, DYNAMIC_AREA_LOCAL_NAME, DynamicArea, ENTITY_DYNAMIC_AREA, ENTITY_HEAP_AREA, entity_initial, entity_kind, ENTITY_STACK_AREA, ENTITY_STATIC_AREA, entity_storage, entity_type, FindOrCreateEntity(), get_current_module_entity(), get_current_module_name(), HEAP_AREA_LOCAL_NAME, HeapArea, is_type_area, make_area(), make_storage_rom(), make_type(), make_value_unknown(), NIL, STACK_AREA_LOCAL_NAME, StackArea, STATIC_AREA_LOCAL_NAME, StaticArea, and TOP_LEVEL_MODULE_NAME.

Referenced by MakeCurrentCompilationUnitEntity(), and MakeCurrentModule().

Here is the call graph for this function:

Here is the caller graph for this function:

init_C_comment()

void init_C_comment

(

void

)

Definition at line 1513 of file clexer.c.

{
  bracket_depth = 0;
  if(!string_undefined_p(C_current_comment)) {
    pips_internal_error("Missing reset for C_current_comment");
  }
  if(!stack_undefined_p(comments_stack) && !STACK_NULL_P(comments_stack) && !comments_empty_p()) {
    pips_internal_error("Comment stack is not empty");
  }
  make_comments_stack();
  token_has_been_seen_p = false;
}

init_c_implicit_variables()

void init_c_implicit_variables

(

entity

m

)

Function name variable function and FUNCTION

Should be static, but not compatible with FREIA inlining.

It is not clear if the encoding is correct or not. It may also be correct but not supported. This could be checked by computing the preconditions for strings and/or by adding initial values to the symbol table display.

Since the declarations are not added to a statement_declarations field, they are not going to be prettyprinted.

Definition at line 277 of file util.c.

{
  /* Function name variable __function__ and __FUNCTION__ */
  const char * mn = entity_local_name(m);
  string bs = "0`"; // first local scope in a module: should be
                    // returned by a function to stay consistent in
                    // case of change
  string fn1 = strdup(concatenate(bs, IMPLICIT_VARIABLE_NAME_1, NULL));
  string fn2 = strdup(concatenate(bs, IMPLICIT_VARIABLE_NAME_2, NULL));
  entity func_name1 = FindOrCreateEntity(mn, fn1);
  entity func_name2 = FindOrCreateEntity(mn, fn2);
  const char * name = entity_user_name(m);
  string cn = strdup(concatenate("\"", mn, "\"", NULL));
  entity fn = make_C_constant_entity(cn,
                                     is_basic_string,
                                     strlen(name)+1);
  free(cn);
  entity a = DynamicArea; /* Should be static, but not compatible with
                           FREIA inlining. */
 
  entity_type(func_name1) = make_char_array_type(strlen(name)+1);
  entity_storage(func_name1) =
    make_storage_ram(make_ram(m, a, UNKNOWN_RAM_OFFSET, NIL));
  /* It is not clear if the encoding is correct or not. It may also
     be correct but not supported. This could be checked by computing
     the preconditions for strings and/or by adding initial values to
     the symbol table display. */
  entity_initial(func_name1) = make_value_expression(make_call_expression(fn, NIL));
  AddEntityToDeclarations(func_name1, m);
 
  entity_type(func_name2) = make_char_array_type(strlen(name)+1);
  entity_storage(func_name2) =
    make_storage_ram(make_ram(m, a, UNKNOWN_RAM_OFFSET, NIL));
  entity_initial(func_name2) = make_value_expression(make_call_expression(fn, NIL));
  AddEntityToDeclarations(func_name2, m);
  /* Since the declarations are not added to a statement_declarations
     field, they are not going to be prettyprinted. */
 
  free(fn1);
  free(fn2);
}

References AddEntityToDeclarations(), concatenate(), DynamicArea, entity_initial, entity_local_name(), entity_storage, entity_type, entity_user_name(), FindOrCreateEntity(), free(), IMPLICIT_VARIABLE_NAME_1, IMPLICIT_VARIABLE_NAME_2, is_basic_string, make_C_constant_entity(), make_call_expression(), make_char_array_type(), make_ram(), make_storage_ram(), make_value_expression(), NIL, strdup(), and UNKNOWN_RAM_OFFSET.

Referenced by MakeCurrentModule().

Here is the call graph for this function:

Here is the caller graph for this function:

init_c_parser_scope_stack()

void init_c_parser_scope_stack

(

void

)

Definition at line 514 of file cyacc.tab.c.

 {
   c_parser_scope_number = 0;
   pips_assert("The stack is undefined",
               stack_undefined_p(c_parser_scope_stack));
   c_parser_scope_stack = stack_make(string_domain, 0, 0);
 }

init_entity_type_storage_table()

void init_entity_type_storage_table

(

void

)

Definition at line 131 of file c_parser.c.

{
  if(!hash_table_undefined_p(entity_to_type_stack_table))
      reset_entity_type_stack_table();
  entity_to_type_stack_table = hash_table_make(hash_string,0);
  //put_stack_storage_table("test","T");
}

References entity_to_type_stack_table, hash_string, hash_table_make(), hash_table_undefined_p, and reset_entity_type_stack_table().

Referenced by actual_c_parser().

Here is the call graph for this function:

Here is the caller graph for this function:

InitializeBlock()

void InitializeBlock

(

void

)

Definition at line 143 of file statement.c.

{
  BlockStack = stack_make(statement_domain,0,0);
}

References BlockStack, stack_make(), and statement_domain.

Here is the call graph for this function:

InitializeEnumMemberValues()

void InitializeEnumMemberValues

(

list

lem

)

The expression evaluation may have been delayed

Parameters

lem

em

Definition at line 3104 of file util.c.

{
  // enum member with implicit values are not yet fully instantiated
  list cem = list_undefined;
  _int cv = 0;
 
  for(cem = lem; !ENDP(cem); POP(cem)) {
    entity em = ENTITY(CAR(cem));
    value emv = entity_initial(em);
 
    if(value_undefined_p(emv)) {
      entity_initial(em) =
        make_value_symbolic(make_symbolic(int_to_expression(cv),
                                          make_constant(is_constant_int, (void *) cv)));
    }
    else {
      symbolic s = value_symbolic(emv);
      constant c = symbolic_constant(s);
 
      if(expression_undefined_p(symbolic_expression(s))) {
        symbolic_expression(s) = int_to_expression(cv);
        symbolic_constant(s) =  make_constant(is_constant_int, (void *) cv);
      }
      else if(constant_unknown_p(c)) {
      /* The expression evaluation may have been delayed */
        value nv = EvalExpression(symbolic_expression(s));
        if(value_constant_p(nv) && constant_int_p(value_constant(nv)))
          symbolic_constant(s) = value_constant(nv);
      }
      cv = constant_int(symbolic_constant(value_symbolic(emv)));
      pips_assert("The symbolic field is consisten", symbolic_consistent_p(s));
    }
    cv++;
  }
}

References CAR, constant_int, constant_int_p, constant_unknown_p, ENDP, ENTITY, entity_initial, EvalExpression(), expression_undefined_p, int_to_expression(), is_constant_int, list_undefined, make_constant(), make_symbolic(), make_value_symbolic(), pips_assert, POP, symbolic_consistent_p(), symbolic_constant, symbolic_expression, value_constant, value_constant_p, value_symbolic, and value_undefined_p.

Here is the call graph for this function:

InitScope()

void InitScope

(

void

)

Definition at line 306 of file cyacc.tab.c.

{
  C_scope_identifier = -1;
}

insert_qualifier()

list insert_qualifier	(	list	ql,
		qualifier	nq
	)

if qualifier "nq" does not already belong to qualifier list "ql", add it in front of the list.

The list is probably reversed somewhere else... for instance by the parsing grammar rules

FI: either the context was not stacked or it was not used and emptied...

Parameters

ql	l
nq	q

Definition at line 3567 of file util.c.

{
  bool found = false; // FI: Should never be useful...
  list nql = ql;
 
  FOREACH(QUALIFIER, q, ql) {
    if(qualifier_equal_p(q, nq)) {
      /* FI: either the context was not
         stacked or it was not used and
         emptied... */
      c_parser_user_warning("Dupliquate qualifier \"%s\"\n",
                            qualifier_to_string(q));
      found = true;
    }
  }
 
  if(!found)
    //c_parser_context_qualifiers(ycontext) =
    nql = CONS(QUALIFIER, nq, ql);
 
  return nql;
}

References c_parser_user_warning, CONS, FOREACH, QUALIFIER, qualifier_equal_p(), and qualifier_to_string().

Here is the call graph for this function:

make_C_constant_entity()

entity make_C_constant_entity	(	string	name,
		tag	bt,
		size_t	size
	)

Parameters

name	ame
bt	t
size	ize

Definition at line 269 of file util.c.

{
  return make_C_or_Fortran_constant_entity(name, bt, size, false, c_parser_error);
}

References c_parser_error(), and make_C_or_Fortran_constant_entity().

Referenced by init_c_implicit_variables().

Here is the call graph for this function:

Here is the caller graph for this function:

make_predefined_C_entities()

void make_predefined_C_entities

(

string

compilation_unit_name

)

Predefined type(s): __builtin_va_list

Let's lie about the real type

Predefined functions(s): __builtin_va_end (va_arg() is parsed directly)

Let's lie about the real type...

Let's lie about the real type

Let's lie about the real type

Parameters

compilation_unit_name

ompilation_unit_name

Definition at line 425 of file c_parser.c.

{
    entity built_in_va_list = entity_undefined;
    entity built_in_bool = entity_undefined;
    entity built_in_complex = entity_undefined;
    entity built_in_va_start = entity_undefined;
    entity built_in_va_end = entity_undefined;
    entity built_in_va_copy = entity_undefined;
 
  /* Predefined type(s): __builtin_va_list */
  built_in_va_list =
    FindOrCreateEntity(compilation_unit_name,TYPEDEF_PREFIX "__builtin_va_list" );
  if(storage_undefined_p(entity_storage(built_in_va_list))) {
    entity_storage(built_in_va_list) = make_storage_rom();
    /* Let's lie about the real type */
    entity_type(built_in_va_list) =
      make_type(is_type_variable,
                make_variable(make_basic_int(DEFAULT_INTEGER_TYPE_SIZE),
                              NIL,
                              NIL));
    entity_initial(built_in_va_list) = make_value_unknown();
  }
  built_in_bool =
    FindOrCreateEntity(compilation_unit_name,TYPEDEF_PREFIX "_Bool");
  if(storage_undefined_p(entity_storage(built_in_bool))) {
    entity_storage(built_in_bool) = make_storage_rom();
    entity_type(built_in_bool) =
      make_type(is_type_variable,
                make_variable(make_basic_logical(DEFAULT_LOGICAL_TYPE_SIZE),
                              NIL, NIL));
    entity_initial(built_in_bool) = make_value_unknown();
  }
  built_in_complex =
    FindOrCreateEntity(compilation_unit_name,TYPEDEF_PREFIX "_Complex");
  if(storage_undefined_p(entity_storage(built_in_complex))) {
    entity_storage(built_in_complex) = make_storage_rom();
    entity_type(built_in_complex) =
      make_type(is_type_variable,
                make_variable(make_basic_complex(DEFAULT_COMPLEX_TYPE_SIZE),
                              NIL, NIL));
    entity_initial(built_in_complex) = make_value_unknown();
  }
 
  /* Predefined functions(s): __builtin_va_end (va_arg() is parsed directly) */
  built_in_va_start =
    FindOrCreateEntity(compilation_unit_name,BUILTIN_VA_START);
  if(storage_undefined_p(entity_storage(built_in_va_start))) {
    basic va_list_b = make_basic(is_basic_typedef, built_in_va_list);
    type va_list_t =
      make_type(is_type_variable, make_variable(va_list_b, NIL, NIL));
    basic void_star_b = make_basic(is_basic_pointer, make_type_void(NIL));
    type void_start_t =
      make_type(is_type_variable, make_variable(void_star_b, NIL, NIL));
    entity_storage(built_in_va_start) = make_storage_rom();
    /* Let's lie about the real type... */
    entity_type(built_in_va_start) =
      make_type(is_type_functional,
                make_functional(CONS(PARAMETER,
                                     make_parameter(va_list_t,
                                                    make_mode(is_mode_value,
                                                              UU),
                                                    make_dummy_unknown()),
                                     CONS(PARAMETER,
                                          make_parameter(void_start_t,
                                                         make_mode(is_mode_value, UU),
                                                         make_dummy_unknown()),
                                          NIL)),
                                make_type(is_type_void,UU)));
    entity_initial(built_in_va_start) = make_value_intrinsic();
  }
 
  built_in_va_end =
    FindOrCreateEntity(compilation_unit_name,BUILTIN_VA_END);
  if(storage_undefined_p(entity_storage(built_in_va_end))) {
    basic va_list_b = make_basic(is_basic_typedef, built_in_va_list);
    type va_list_t =
      make_type(is_type_variable, make_variable(va_list_b, NIL, NIL));
    entity_storage(built_in_va_end) = make_storage_rom();
    /* Let's lie about the real type */
    entity_type(built_in_va_end) =
      make_type(is_type_functional,
                make_functional(CONS(PARAMETER,
                                     make_parameter(va_list_t,
                                                    make_mode(is_mode_value, UU),
                                                    make_dummy_unknown()),
                                     NIL),
                                make_type(is_type_void,UU)));
    entity_initial(built_in_va_end) = make_value_intrinsic();
  }
 
  built_in_va_copy =
    FindOrCreateEntity(compilation_unit_name,BUILTIN_VA_COPY);
  if(storage_undefined_p(entity_storage(built_in_va_copy))) {
    basic va_list_b = make_basic(is_basic_typedef, built_in_va_list);
    type va_list_t =
      make_type(is_type_variable, make_variable(va_list_b, NIL, NIL));
    parameter va_list_p = make_parameter(va_list_t,
                                         make_mode_value(),
                                         make_dummy_unknown());
    entity_storage(built_in_va_copy) = make_storage_rom();
    /* Let's lie about the real type */
    entity_type(built_in_va_copy) =
      make_type(is_type_functional,
                make_functional(CONS(PARAMETER,
                                     va_list_p,
                                     CONS(PARAMETER,
                                          copy_parameter(va_list_p),
                                          NIL)),
                                make_type(is_type_void,UU)));
    entity_initial(built_in_va_copy) = make_value_intrinsic();
  }
}

References BUILTIN_VA_COPY, BUILTIN_VA_END, BUILTIN_VA_START, compilation_unit_name, CONS, copy_parameter(), DEFAULT_COMPLEX_TYPE_SIZE, DEFAULT_INTEGER_TYPE_SIZE, DEFAULT_LOGICAL_TYPE_SIZE, entity_initial, entity_storage, entity_type, entity_undefined, FindOrCreateEntity(), is_basic_pointer, is_basic_typedef, is_mode_value, is_type_functional, is_type_variable, is_type_void, make_basic(), make_basic_complex(), make_basic_int(), make_basic_logical(), make_dummy_unknown(), make_functional(), make_mode(), make_mode_value(), make_parameter(), make_storage_rom(), make_type(), make_type_void(), make_value_intrinsic(), make_value_unknown(), make_variable(), NIL, PARAMETER, storage_undefined_p, TYPEDEF_PREFIX, and UU.

Referenced by actual_c_parser().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeArrayExpression()

expression MakeArrayExpression	(	expression	exp,
		list	lexp
	)

FI: this function is called for a bracketed comma expression.

The two arguments are (should be) reused within the returned expression

There are two cases:

1. Simple array reference, where the first argument is a simple array or pointer name. We create a reference expression (syntax = reference).
2. Complicated subscripting array, where the first argument can be a function call (foo()[]), a structure or union member (str[5].field[7], ... We create a subscripting expression (syntax = subscript).

FI: Memory leak with exp?

FI: we might have preexisting subscript? No, in this context, only one index due to lack of type information?

Parameters

exp	xp
lexp	exp

Definition at line 713 of file util.c.

{
  /* There are two cases:
 
   1. Simple array reference, where the first argument is a simple
   array or pointer name. We create a reference expression (syntax =
   reference).
 
   2. Complicated subscripting array, where the first argument can be
   a function call (foo()[]), a structure or union member
   (str[5].field[7], ... We create a subscripting expression (syntax =
   subscript).
 */
 
  expression e = expression_undefined;
  syntax s = expression_syntax(exp);
  list sl = lexp;
 
  if(!ENDP(CDR(lexp))) {
    expression se = MakeCommaExpression(lexp);
    sl = CONS(EXPRESSION, se, NIL);
  }
 
  switch(syntax_tag(s)) {
  case is_syntax_reference:
    {
      /* FI: Memory leak with exp? */
      reference r = syntax_reference(s);
      entity ent = reference_variable(r);
      list l = reference_indices(r);
      pips_debug(6,"Normal reference expression\n");
      e = reference_to_expression(make_reference(ent,gen_nconc(l,sl)));
      break;
    }
  case is_syntax_call:
  case is_syntax_range:
  case is_syntax_cast:
  case is_syntax_sizeofexpression:
  case is_syntax_subscript:
  case is_syntax_application:
    {
      /* FI: we might have preexisting subscript? No, in this
         context, only one index due to lack of type information? */
      subscript a = make_subscript(exp,sl);
      syntax s = make_syntax_subscript(a);
      pips_debug(6,"Subscripting array expression\n");
      e = make_expression(s,normalized_undefined);
      break;
    }
  default:
    {
      pips_internal_error("unexpected syntax tag: %d", syntax_tag(s));
    }
  }
  return e;
}

References CDR, CONS, ENDP, exp, EXPRESSION, expression_syntax, expression_undefined, gen_nconc(), is_syntax_application, is_syntax_call, is_syntax_cast, is_syntax_range, is_syntax_reference, is_syntax_sizeofexpression, is_syntax_subscript, lexp, make_expression(), make_reference(), make_subscript(), make_syntax_subscript(), MakeCommaExpression(), NIL, normalized_undefined, pips_debug, pips_internal_error, reference_indices, reference_to_expression(), reference_variable, syntax_reference, and syntax_tag.

Here is the call graph for this function:

MakeBlock()

statement MakeBlock

(

list

stmts

)

Create a block statement.

It also gather all the declarations in the statements and declare them in the block sequence.

To please to current RI choices about Fortran, blocks cannot carry line numbers nor comments

Anyway, it might be much too late to retrieve the comment associated to the beginning of the block. The lost comment appears after the last statement of the block. To save it, as is done in Fortran, an empty statement should be added at the end of the sequence.

get_current_C_line_number()

get_current_C_comment()

Parameters

stmts

tmts

Definition at line 153 of file statement.c.

{
  /* To please to current RI choices about Fortran, blocks cannot carry
     line numbers nor comments */
  /* Anyway, it might be much too late to retrieve the comment
     associated to the beginning of the block. The lost comment
     appears after the last statement of the block. To save it, as is
     done in Fortran, an empty statement should be added at the end of
     the sequence. */
  // Gather all the direct declaration entities from the statements:
  list dl = statements_to_direct_declarations(stmts);
 
  statement s = make_statement(entity_empty_label(),
                               STATEMENT_NUMBER_UNDEFINED /* get_current_C_line_number() */,
                               STATEMENT_ORDERING_UNDEFINED,
                               empty_comments /* get_current_C_comment() */,
                               make_instruction_sequence(make_sequence(stmts)),
                               dl, string_undefined, empty_extensions (), make_synchronization_none());
 
  discard_C_comment();
 
  ifdebug(1) {
      fprintf(stderr, "Declaration list: ");
      if(ENDP(statement_declarations(s)))
        fprintf(stderr, "NONE\n");
      else {
        print_entities(statement_declarations(s));
        fprintf(stderr, "\n");
      }
    }
 
  pips_assert("Block statement is consistent",statement_consistent_p(s));
  return s;
}

References discard_C_comment(), empty_comments, empty_extensions(), ENDP, entity_empty_label(), fprintf(), ifdebug, make_instruction_sequence(), make_sequence(), make_statement(), make_synchronization_none(), pips_assert, print_entities(), statement_consistent_p(), statement_declarations, STATEMENT_NUMBER_UNDEFINED, STATEMENT_ORDERING_UNDEFINED, statements_to_direct_declarations(), and string_undefined.

Here is the call graph for this function:

MakeBreakStatement()

statement MakeBreakStatement

(

string

cmt

)

NN : I did not add a bool variable to distinguish between loop and switch statements :-( FI: Also, there is no protection in case the same label has been used by the programmer...

Parameters

cmt

mt

Definition at line 849 of file statement.c.

{
  /* NN : I did not add a bool variable to distinguish between loop
     and switch statements :-( FI: Also, there is no protection in case
     the same label has been used by the programmer... */
  int i = basic_int((basic) stack_head(LoopStack));
  string lab;
  asprintf(&lab,"%sbreak_%d", get_label_prefix(), i);
  statement bs = MakeGotoStatement(lab);
  free(lab);
 
  statement_comments(bs) = cmt;
 
  return bs;
}

References asprintf, basic_int, free(), get_label_prefix, LoopStack, MakeGotoStatement(), stack_head(), and statement_comments.

Referenced by MakeSwitchStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeCaseStatement()

statement MakeCaseStatement

(

expression

e

)

Transform.

case e:

to

switch_xxx_case_e: ;

and generate

if (c == e) goto switch_xxx_case_e

where c is retrieved from SwitchControllerStack xxx is unique from LoopStack

Before the code can be generated, expression e must be statically evaluated, transformer into a character string, and this character string must be made compatible with C constraints for labels.

It might be easier to evaluate e since e must be evaluable at compile time... And it is necessary if e contains operators whose name cannot be part of a label: see switch04

We chose to ignore the impact of casts

You must evaluate the constant expression. Hopefully it is an integer expression...

The expression may be a character

remove the quotes

Make sure "restr" only contains C characters valid for a label if a character constant is used: is_letter || is_digit || '_'.

illegal characters such as '?' or ',' or '.' must be converted as well as octal constant such as '\001' and special characters such as '
'

Must be an illegal character for a label

FI: not too safe to make it octal among decimal because it can generate a label conflict.

octal character

hexadecimal character, unicode character

FI: let's deal with special cases such as
, \r, \t,... The initialization to zero is meaningless but avoids a warning.

Definition at line 712 of file statement.c.

{
  int i = basic_int((basic) stack_head(LoopStack));
  string lab = NULL;
  /* It might be easier to evaluate e since e must be evaluable at
     compile time... And it is necessary if e contains operators whose
     name cannot be part of a label: see switch04 */
  string estr = string_undefined;
  expression ne = e;
 
  /* We chose to ignore the impact of casts */
  if(expression_cast_p(e)) {
    cast c = expression_cast(e);
    ne = cast_expression(c);
  }
 
  if(expression_constant_p(ne)) {
    estr = expression_to_string(ne);
  }
  else {
    /* You must evaluate the constant expression. Hopefully it is an
       integer expression... */
    intptr_t val;
    if(expression_integer_value(ne, &val)) {
      asprintf(&estr, "%lld", (long long int) val);
    }
    else {
      set_prettyprint_language_tag(is_language_c);
      c_parser_user_warning("Expression \"%s\" not supported as case expression.\n",
                            expression_to_string(ne));
      CParserError("Unsupported case expression\n");
    }
  }
 
  string restr = estr;
 
  /* The expression may be a character */
  if(*estr=='\'') {
    /* remove the quotes */
    restr++;
    *(estr+strlen(estr)-1) = '\000';
  }
 
  /* Make sure "restr" only contains C characters valid for a label if
     a character constant is used: is_letter || is_digit || '_'. */
  if(strspn(restr,
      "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_abcdefghijklmnopqrstuvwxyz")!=strlen(restr) && *estr=='\'') {
    /* illegal characters such as '?' or ',' or '.' must be converted
       as well as octal constant such as '\001' and special
       characters such as '\n' */
    if(strlen(restr)==1) {
      /* Must be an illegal character for a label */
      /* FI: not too safe to make it octal among decimal because it
         can generate a label conflict. */
      asprintf(&lab,"%sswitch_%d_case_%hhd",get_label_prefix(),i,*restr);
    }
    else if(*restr=='\\') {
      if(*(restr+1)=='0'||*(restr+1)=='1'||*(restr+1)=='2'||*(restr+1)=='3')
        /* octal character */
        asprintf(&lab,"%sswitch_%d_case_o%s",get_label_prefix(),i,restr+1);
      else if(*(restr+1)=='x'||*(restr+1)=='u'||*(restr+1)=='U')
        /* hexadecimal character, unicode character */
        asprintf(&lab,"%sswitch_%d_case_%s",get_label_prefix(),i,restr+1);
      else {
        /* FI: let's deal with special cases such as \n, \r, \t,...
         * The initialization to zero is meaningless but avoids a warning.
         */
        char labc = 0; // A string would carry more ASCII information
        if(*(restr+1)=='a') // bell
          labc = '\a'; // "BEL"
        else if(*(restr+1)=='b') // backspace
          labc = '\b'; // "BS"
        else if(*(restr+1)=='f') // form feed
          labc = '\f'; // "FF"
        else if(*(restr+1)=='n') // new line
          labc = '\n'; // "LF"
        else if(*(restr+1)=='t') // horizontal tab
          labc = '\t'; // "HT"
        else if(*(restr+1)=='r') // carriage return
          labc = '\r'; // "CR"
        else if(*(restr+1)=='v') // vertical tab
          labc = '\v'; // "VT"
        else if(*(restr+1)=='\'') // quote
          labc = '\''; //
        else if(*(restr+1)=='\"') // double quote
          labc = '\"'; //
        else if(*(restr+1)=='\\') // backslash
          labc = '\\'; //
        else if(*(restr+1)=='\?') // question mark
          labc = '\?'; //
        else
          pips_internal_error("Unexpected case. %s\n", (restr));
        asprintf(&lab,"%sswitch_%d_case_%hhd",get_label_prefix(),i,labc);
      }
    }
  }
  else
    asprintf(&lab,"%sswitch_%d_case_%s",get_label_prefix(),i,restr);
 
  free(estr);
 
  statement s = MakeLabeledStatement(lab,
      make_continue_statement(entity_empty_label()),
      get_current_C_comment());
  expression cond = call_to_expression(make_call(entity_intrinsic("=="),
      CONS(EXPRESSION, stack_head(SwitchControllerStack),
          CONS(EXPRESSION, e, NIL))));
  test t = make_test(cond,MakeGotoStatement(lab),make_continue_statement(entity_undefined));
  sequence CurrentSwitchGotoStack = stack_head(SwitchGotoStack);
  sequence_statements(CurrentSwitchGotoStack) = gen_nconc(sequence_statements(CurrentSwitchGotoStack),
      CONS(STATEMENT,test_to_statement(t),NULL));
 
  return s;
}

References asprintf, basic_int, c_parser_user_warning, call_to_expression(), cast_expression, CONS, CParserError(), entity_empty_label(), entity_intrinsic(), entity_undefined, EXPRESSION, expression_cast(), expression_cast_p(), expression_constant_p(), expression_integer_value(), expression_to_string(), free(), gen_nconc(), get_current_C_comment(), get_label_prefix, intptr_t, is_language_c, LoopStack, make_call(), make_continue_statement(), make_test(), MakeGotoStatement(), MakeLabeledStatement(), NIL, pips_internal_error, sequence_statements, set_prettyprint_language_tag(), stack_head(), STATEMENT, string_undefined, SwitchControllerStack, SwitchGotoStack, and test_to_statement.

Here is the call graph for this function:

MakeCLabel()

entity MakeCLabel

(

string

s

)

Definition at line 278 of file statement.c.

{
  string ename = strdup(concatenate(LABEL_PREFIX,s,NULL));
  entity l = FindOrCreateEntity(get_current_module_name(),ename);
  free(ename);
  if (entity_type(l) == type_undefined)
    {
      pips_debug(7,"Label %s\n", s);
      entity_type(l) = MakeTypeStatement();
      entity_storage(l) = make_storage_rom();
      entity_initial(l) = make_value(is_value_constant,
                                     make_constant_litteral());
    }
  else
    pips_debug(7, "Label %s already exists\n", s);
  return(l);
}

References concatenate(), entity_initial, entity_storage, entity_type, FindOrCreateEntity(), free(), get_current_module_name(), is_value_constant, LABEL_PREFIX, make_constant_litteral(), make_storage_rom(), make_value(), MakeTypeStatement(), pips_debug, strdup(), and type_undefined.

Referenced by MakeForloop(), MakeGotoStatement(), MakeLabeledStatement(), MakeSwitchStatement(), and MakeWhileLoop().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeContinueStatement()

statement MakeContinueStatement

(

string

cmt

)

Unique label with the LoopStack

Parameters

cmt

mt

Definition at line 865 of file statement.c.

{
  /* Unique label with the LoopStack */
  int i = basic_int((basic) stack_head(LoopStack));
  string lab;
  asprintf(&lab, "%sloop_end_%d", get_label_prefix(), i);
  statement cs = MakeGotoStatement(lab);
  free(lab);
 
  statement_comments(cs) = cmt;
 
  return cs;
}

References asprintf, basic_int, free(), get_label_prefix, LoopStack, MakeGotoStatement(), stack_head(), and statement_comments.

Here is the call graph for this function:

MakeCurrentCompilationUnitEntity()

void MakeCurrentCompilationUnitEntity

(

const char *

name

)

A compilation unit is also considered as a module.

value v = entity_initial(e);

if(value_code_p(v)) {

code c = value_code(v);

language l = code_language(c);

if(language_unknown_p(l))

code_language(c) = make_language_c();

else if(language_fortran_p(l) || language_fortran95_p(l))

pips_internal_error("A compilation unit should have language \"C".
");

}

else

pips_internal_error("A compilation unit should have value \"code".
");

Parameters

name

ame

Definition at line 328 of file util.c.

{
  entity e = MakeCompilationUnitEntity(name);
  /* value v = entity_initial(e); */
  /* if(value_code_p(v)) { */
  /*   code c = value_code(v); */
  /*   language l = code_language(c); */
  /*   if(language_unknown_p(l)) */
  /*     code_language(c) = make_language_c(); */
  /*   else if(language_fortran_p(l) || language_fortran95_p(l)) */
  /*     pips_internal_error("A compilation unit should have language \"C\".\n"); */
  /* } */
  /* else */
  /*   pips_internal_error("A compilation unit should have value \"code\".\n"); */
 
  pips_debug(4,"Set current module entity for compilation unit %s\n",name);
  set_current_module_entity(e);
  //init_stack_storage_table();
  init_c_areas();
}

References init_c_areas(), MakeCompilationUnitEntity(), pips_debug, and set_current_module_entity().

Referenced by actual_c_parser().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeCurrentModule()

void MakeCurrentModule

(

entity

e

)

is used for switch statements also, because we do not distinguish a break in a loop or a switch

This must be changed later, the storage is of type return and we have to create a new entity

make_storage_return(e)

code_declaration to be updated : only need formal parameters, because the others are added in block statement declaration ?

The next two tests are replicated from the Fortran parser, Syntax/procedure.c, MakeCurrentFunction()

In case the module is parsed a second time, clean up the symbol table to avoid variable redefinition warnings and errors

Clean up existing local entities in case of a recompilation.

Let's hope cf is not an intrinsic: name conflict (the problem may have been detected earlier in UpdateEntity() if there are arguments)

Unfortunately, an intrinsics cannot be redefined, just like a user function or subroutine after editing because intrinsics are not handled like user functions or subroutines. They are not added to the called_modules list of other modules, unless the redefining module is parsed FIRST. There is not mechanism in PIPS to control the parsing order.

Definition at line 67 of file statement.c.

{
  /* This must be changed later, the storage is of type return and we
     have to create a new entity*/
  entity_storage(e) = make_storage_rom() /* make_storage_return(e) */;
  if (value_undefined_p(entity_initial(e)))
    entity_initial(e) = make_value(is_value_code,
                                   make_code(NIL,strdup(""),
                                             make_sequence(NIL),
                                             NIL,
                                             make_language_c()));
  /* code_declaration to be updated : only need formal parameters, because the others are added in
     block statement declaration ? */
  pips_debug(4,"Set current module entity %s\n",entity_user_name(e));
 
  /* The next two tests are replicated from the Fortran parser,
     Syntax/procedure.c, MakeCurrentFunction() */
 
  /* In case the module is parsed a second time, clean up the symbol
     table to avoid variable redefinition warnings and errors */
  if(!value_undefined_p(entity_initial(e))) {
    if(value_code_p(entity_initial(e))) {
      code c = value_code(entity_initial(e));
      if(!code_undefined_p(c) && !ENDP(code_declarations(c))) {
        /* Clean up existing local entities in case of a recompilation. */
        CCleanLocalEntities(e);
      }
    }
  }
 
  /* Let's hope cf is not an intrinsic: name conflict (the problem may
     have been detected earlier in UpdateEntity() if there are
     arguments) */
  if( entity_type(e) != type_undefined
      && intrinsic_entity_p(e) ) {
    pips_user_warning("Intrinsic %s redefined.\n"
                      "This is not supported by PIPS. Please rename %s\n",
                      entity_local_name(e), entity_local_name(e));
    /* Unfortunately, an intrinsics cannot be redefined, just like a user function
     * or subroutine after editing because intrinsics are not handled like
     * user functions or subroutines. They are not added to the called_modules
     * list of other modules, unless the redefining module is parsed FIRST.
     * There is not mechanism in PIPS to control the parsing order.
     */
    CParserError("Name conflict between a "
                 "function and an intrinsic\n");
  }
 
 
  set_current_module_entity(e);
  init_c_areas();
  init_c_implicit_variables(e);
  LabeledStatements = NIL;
  SwitchGotoStack = stack_make(sequence_domain,0,0);
  SwitchControllerStack = stack_make(expression_domain,0,0);
  LoopStack = stack_make(basic_domain,0,0);
}

References basic_domain, CCleanLocalEntities(), code_declarations, code_undefined_p, CParserError(), ENDP, entity_initial, entity_local_name(), entity_storage, entity_type, entity_user_name(), expression_domain, init_c_areas(), init_c_implicit_variables(), intrinsic_entity_p(), is_value_code, LabeledStatements, LoopStack, make_code(), make_language_c(), make_sequence(), make_storage_rom(), make_value(), NIL, pips_debug, pips_user_warning, sequence_domain, set_current_module_entity(), stack_make(), strdup(), SwitchControllerStack, SwitchGotoStack, type_undefined, value_code, value_code_p, and value_undefined_p.

Here is the call graph for this function:

MakeDefaultStatement()

statement MakeDefaultStatement

(

void

)

Return the labeled statement switch_xxx_default: ; and add goto switch_xxx_default; to the switch header

If the default case is not last, it must be moved later in the sequence_statements(CurrentSwitchGoto)

Definition at line 827 of file statement.c.

{
  /* Return the labeled statement
       switch_xxx_default: ;
     and add
       goto switch_xxx_default;
     to the switch header */
  int i = basic_int((basic) stack_head(LoopStack));
  string lab;
  asprintf(&lab,"%sswitch_%d_default", get_label_prefix(), i);
  statement s = MakeLabeledStatement(lab,
                                     make_continue_statement(entity_empty_label()),
                                     get_current_C_comment());
  sequence CurrentSwitchGoto = stack_head(SwitchGotoStack);
  /* If the default case is not last, it must be moved later in the
     sequence_statements(CurrentSwitchGoto) */
  sequence_statements(CurrentSwitchGoto) = gen_nconc(sequence_statements(CurrentSwitchGoto),
                                                               CONS(STATEMENT,MakeGotoStatement(lab),NULL));
  free(lab);
  return s;
}

References asprintf, basic_int, CONS, entity_empty_label(), free(), gen_nconc(), get_current_C_comment(), get_label_prefix, LoopStack, make_continue_statement(), MakeGotoStatement(), MakeLabeledStatement(), sequence_statements, stack_head(), STATEMENT, and SwitchGotoStack.

Here is the call graph for this function:

MakeDerivedEntity()

entity MakeDerivedEntity	(	string	name,
		list	members,
		bool	is_external,
		int	i
	)

FI: What should the initial value be?

Parameters

name	ame
members	embers
is_external	s_external

Definition at line 3140 of file util.c.

{
  entity ent = entity_undefined;
  switch (i) {
  case is_type_struct:
    {
      ent = CreateEntityFromLocalNameAndPrefix(name,STRUCT_PREFIX,is_external);
      entity_type(ent) = make_type_struct(members);
      break;
    }
  case is_type_union:
    {
      ent = CreateEntityFromLocalNameAndPrefix(name,UNION_PREFIX,is_external);
      entity_type(ent) = make_type_union(members);
      break;
    }
  case is_type_enum:
    {
      ent = CreateEntityFromLocalNameAndPrefix(name,ENUM_PREFIX,is_external);
      entity_type(ent) = make_type_enum(members);
      break;
    }
  }
  entity_storage(ent) = make_storage_rom();
  /* FI: What should the initial value be? */
  if (value_undefined_p(entity_initial(ent)))
    entity_initial(ent) = make_value_unknown();
  AddEntityToDeclarations(ent, get_current_module_entity());
 
  return ent;
}

References AddEntityToDeclarations(), CreateEntityFromLocalNameAndPrefix(), entity_initial, entity_storage, entity_type, entity_undefined, ENUM_PREFIX, get_current_module_entity(), is_external, is_type_enum, is_type_struct, is_type_union, make_storage_rom(), make_type_enum(), make_type_struct(), make_type_union(), make_value_unknown(), STRUCT_PREFIX, UNION_PREFIX, and value_undefined_p.

Here is the call graph for this function:

MakeDimension()

dimension MakeDimension	(	list	le,
		list	ql
	)

Take only the first expression of le, do not know why it can be a list ?

use the integer value

If we do this, we cannot restitute the source code

Build a new expression e' == e-1

Parameters

le	e
ql	l

Definition at line 1389 of file util.c.

{
  dimension d;
  if (le == NIL)
    {
      d = make_dimension(int_to_expression(0),make_unbounded_expression(), NIL);
      pips_debug(5,"Unbounded dimension\n");
    }
  else
    {
      /* Take only the first expression of le, do not know why it can be a list ?*/
      expression e = EXPRESSION(CAR(le));
      intptr_t up;
 
      if (false && expression_integer_value(e,&up))
        /* use the integer value */ /* If we do this, we cannot restitute the source code */
        d = make_dimension(int_to_expression(0), int_to_expression(up-1), NIL);
      else
        /* Build a new expression e' == e-1 */
        d = make_dimension(int_to_expression(0),
                           MakeBinaryCall(CreateIntrinsic(MINUS_C_OPERATOR_NAME),
                                          e,
                                          int_to_expression(1)),
                           ql);
 
      ifdebug(9)
        {
          pips_debug(5,"Array dimension:");
          print_expression(e);
          pips_debug(8,"Array lower bound:");
          print_expression(dimension_lower(d));
          pips_debug(5,"Array dimension:");
          print_expression(dimension_upper(d));
        }
    }
  return d;
}

References CAR, CreateIntrinsic(), dimension_lower, dimension_upper, EXPRESSION, expression_integer_value(), ifdebug, int_to_expression(), intptr_t, make_dimension(), make_unbounded_expression(), MakeBinaryCall(), MINUS_C_OPERATOR_NAME, NIL, pips_debug, and print_expression().

Referenced by UpdateArrayEntity().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeEnumeratorInitialValue()

value MakeEnumeratorInitialValue	(	list	enum_list,
		int	counter
	)

The initial value = 0 if this is the first member in the enumerator list else, it is equal to : intial_value(predecessor) + 1

Find the predecessor of the counter-th member

Parameters

enum_list	num_list
counter	ounter

Definition at line 3299 of file util.c.

{
  /* The initial value = 0 if this is the first member in the enumerator list
     else, it is equal to : intial_value(predecessor) + 1 */
  value v = value_undefined;
  if (counter == 1)
    v = make_value_constant(make_constant_int(0));
  else
    {
      /* Find the predecessor of the counter-th member */
      entity pre = ENTITY(gen_nth(counter-1, enum_list));
      value vp = entity_initial(pre);
      if (value_constant_p(vp))
        {
          constant c = value_constant(vp);
          if (constant_int_p(c))
            {
              int i = constant_int(c);
              v = make_value_constant(make_constant_int(i+1));
            }
        }
    }
  return v;
}

References constant_int, constant_int_p, ENTITY, entity_initial, gen_nth(), make_constant_int(), make_value_constant(), value_constant, value_constant_p, and value_undefined.

Here is the call graph for this function:

MakeForloop()

statement MakeForloop	(	expression	e1,
		expression	e2,
		expression	e3,
		statement	body
	)

Create a for-loop statement with some parser-specific characteristics.

A more generic implementation would have been in ri-util instead.

There are assumptions that 2 comments have been pushed in the parser before.

Parameters

[in]	e1	is the init part of the for
[in]	e2	is the conditional part of the for
[in]	e3	is the increment part of the for
[in]	body	is the loop body statement

Returns

a statement with the for

Beware that a block is returned instead of a forloop when a break has been processed. The forloop is somewhere in there...

A bool C constant cannot be used because stdbool.h may not be included

cond = make_call_expression(MakeConstant(TRUE_OPERATOR_NAME,

is_basic_logical),

NIL);

Create some land-pad labels to deal with break and continue.

Looks like some memory leaks if no break or continue...

What happens if this label is already used by the programmer? If I increment i, the label may not be retrieved when needed... unless LoopStack is updated...

This loop has a continue statement which has been transformed to goto.

Add the labeled statement at the end of loop body

The for clause may contain declarations

This loop has a break statement which has been transformed to goto Add the labeled statement after the loop

ifdebug(5) {

printf("For loop statement: \n");

print_statement(smt);

}

Parameters

e1	1
e2	2
e3	3
body	ody

Definition at line 358 of file statement.c.

                                      {
  forloop f;
  statement smt;
  // Assume this push have been done in the parser:
  int sn = pop_current_C_line_number();
  expression init = e1;
  expression cond = e2;
  expression inc = e3;
 
  pips_assert("For loop body consistent",statement_consistent_p(body));
 
  if(expression_undefined_p(init))
    init = make_call_expression(entity_intrinsic(CONTINUE_FUNCTION_NAME),
                                NIL);
  else
    simplify_C_expression(init);
 
  if(expression_undefined_p(cond))
    /* A bool C constant cannot be used
       because stdbool.h may not be
       included */
    /* cond = make_call_expression(MakeConstant(TRUE_OPERATOR_NAME, */
    /* is_basic_logical), */
    /* NIL); */
    cond = int_to_expression(1);
  else
    simplify_C_expression(cond);
 
  if(expression_undefined_p(inc))
    inc = make_call_expression(entity_intrinsic(CONTINUE_FUNCTION_NAME),
                               NIL);
  else
    simplify_C_expression(inc);
 
  int i = basic_int((basic) stack_head(LoopStack));
  /* Create some land-pad labels to deal with break and continue.
 
     Looks like some memory leaks if no break or continue...
 
     What happens if this label is already used by the programmer? If
     I increment i, the label may not be retrieved when
     needed... unless LoopStack is updated...
 */
  string lab1 = string_undefined;
  //do {
  //if(!string_undefined_p(lab1)) free(lab1);
  asprintf(&lab1, "%s%s%d", get_label_prefix(), "loop_end_", i);
    //i++;
    //} while(label_string_defined_in_current_module_p(lab1)()
  statement s1 = FindStatementFromLabel(MakeCLabel(lab1));
  free(lab1);
 
  string lab2 = string_undefined;
  //do {
  //if(!string_undefined_p(lab2)) free(lab2);
    asprintf(&lab2, "%s%s%d", get_label_prefix(), "break_", i);
    //i++;
    //} while(label_string_defined_in_current_module_p(lab1)()
  statement s2 = FindStatementFromLabel(MakeCLabel(lab2));
  free(lab2);
 
  if (!statement_undefined_p(s1))
    /* This loop has a continue statement which has been transformed to goto.
 
       Add the labeled statement at the end of loop body*/
    insert_statement(body, s1, false);
 
  /*  The for clause may contain declarations*/
  f = make_forloop(init, cond, inc, body);
  smt = make_statement(entity_empty_label(),
                       get_current_C_line_number(),
                       STATEMENT_ORDERING_UNDEFINED,
                       string_undefined,
                       make_instruction_forloop(f),
                       NIL, string_undefined,
                       empty_extensions(), make_synchronization_none());
 
  if (!statement_undefined_p(s2))
    /* This loop has a break statement which has been transformed to goto
       Add the labeled statement after the loop */
    insert_statement(smt, s2, false);
 
  // Assume these 2 push have been done in the parser:
  string comment_after_for_clause = pop_current_C_comment();
  string comment_before_for_clause = pop_current_C_comment();
  string sc = strdup(concatenate(comment_before_for_clause,
                                 comment_after_for_clause,
                                 NULL));
  free(comment_after_for_clause);
  free(comment_before_for_clause);
  smt = add_comment_and_line_number(smt, sc, sn);
  stack_pop(LoopStack);
  pips_assert("For loop consistent", statement_consistent_p(smt));
 
  pips_assert("For loop is consistent", forloop_consistent_p(f));
  /* ifdebug(5) { */
  /*   printf("For loop statement: \n"); */
  /*   print_statement(smt); */
  /* } */
  return smt;
}

References add_comment_and_line_number(), asprintf, basic_int, concatenate(), CONTINUE_FUNCTION_NAME, empty_extensions(), entity_empty_label(), entity_intrinsic(), expression_undefined_p, f(), FindStatementFromLabel(), forloop_consistent_p(), free(), get_current_C_line_number(), get_label_prefix, init, insert_statement(), int_to_expression(), LoopStack, make_call_expression(), make_forloop(), make_instruction_forloop(), make_statement(), make_synchronization_none(), MakeCLabel(), NIL, pips_assert, pop_current_C_comment(), pop_current_C_line_number(), s1, simplify_C_expression(), stack_head(), stack_pop(), statement_consistent_p(), STATEMENT_ORDERING_UNDEFINED, statement_undefined_p, strdup(), and string_undefined.

Referenced by MakeForloopWithIndexDeclaration().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeForloopWithIndexDeclaration()

statement MakeForloopWithIndexDeclaration	(	list	decls,
		expression	e2,
		expression	e3,
		statement	body
	)

Create a C99 for-loop statement with a declaration as first parameter in the for clause, with some parser-specific characteristics.

To represent for(int i = a;...;...) we generate instead: { int i; for(int i = a;...;...) }

The for could be generated back into the original form by the prettyprinter. To differentiate between such a C99 for loop or a for-loop that was really written with the i declaration just before, west may mark the for loop with an extension here so that the prettyprinter could use this hint to know if it has to do some resugaring or not.

Parameters

[in,out]	decls	is the init part of the for. It is a declaration statement list
[in]	e2	is the conditional part of the for
[in]	e3	is the increment part of the for
[in]	body	is the loop body statement

Returns

a statement that contains the declaration and the for

ifdebug(6) {

printf("For loop statement declarations: \n");

print_statements(decls);

}

First generate naive but more robust version in the RI, such as:

{ int i = a; for(;...;...) }

We inject the for in its declaration statement to have the naive representation:

We try to refine to inject back an initialization in the for-clause.

Note split_initializations_in_statemen() works only on a block

We are interested in solving the simple case when there are 3 statements because we should be in the form of: int i; i = a; for(;...;...)

We need to remove the decl block statement and move the index declaration directly in the for statement.

Not yet implemented because it needs to extend declaration_statement_p for any kind of loops, the loop restructurers...

Parameters

decls	ecls
e2	2
e3	3
body	ody

Definition at line 508 of file statement.c.

                                                          {
  /* ifdebug(6) { */
  /*   printf("For loop statement declarations: \n"); */
  /*   print_statements(decls); */
  /* } */
  // FI: modified because insert_statement() should not be used with
  // declaration statements although it would be OK in this special case
  // statement decl = make_statement_from_statement_list_or_empty_block(decls);
  statement decl = make_block_statement(decls);
  /* First generate naive but more robust version in the RI, such as:
 
     {
       int i = a;
       for(;...;...)
     }
  */
  statement for_s = MakeForloop(expression_undefined, e2, e3, body);
  /* We inject the for in its declaration statement to have the naive
     representation: */
  // insert_statement(decl, for_s, false);
  append_statement_to_block_statement(decl, for_s);
  // Gather all the direct declarations from the statements in the block
  list dl = statements_to_direct_declarations(statement_block(decl));
  // to put them on the block statement:
  statement_declarations(decl) = dl;
 
  if (!get_bool_property("C_PARSER_GENERATE_NAIVE_C99_FOR_LOOP_DECLARATION")) {
    /* We try to refine to inject back an initialization in the for-clause.
 
       Note split_initializations_in_statemen() works only on a block */
    split_initializations_in_statement(decl);
    list l = statement_block(decl);
    size_t len = gen_length(l);
    ifdebug(6)
      printf("Number of statements in the block: %zd\n", len);
    if (len == 3) {
      /* We are interested in solving the simple case when there are 3
         statements because we should be in the form of:
         int i;
         i = a;
         for(;...;...)
      */
      // So we pick the initialization part which is the second statement:
      statement init = STATEMENT(gen_nth(1, l));
      // Remove it from the enclosing declaration statement:
      gen_remove(&l, init);
      // Get the assignment:
      call c = statement_call(init);
      // Housekeeping: first protect what we want to keep somewhere else...
      instruction_call(statement_instruction(init)) = call_undefined;
      // ... and free the now useless container:
      free_statement(init);
      // Make from it an expression that can appear inside the for clause:
      expression e = call_to_expression(c);
      // Get the for-loop:
      forloop f = find_forloop_in_statement(for_s);
      // Remove the default-generated initialization expression:
      free_expression(forloop_initialization(f));
      // Put the new one instead:
      forloop_initialization(f) = e;
      if (get_bool_property("C_PARSER_GENERATE_COMPACT_C99_FOR_LOOP_DECLARATION")) {
        /* We need to remove the decl block statement and move the index
           declaration directly in the for statement. */
 
        /* Not yet implemented because it needs to extend
           declaration_statement_p for any kind of loops, the loop
           restructurers... */
        ;
      }
    }
  }
  return decl;
}

References append_statement_to_block_statement(), call_to_expression(), call_undefined, expression_undefined, f(), find_forloop_in_statement(), forloop_initialization, free_expression(), free_statement(), gen_length(), gen_nth(), gen_remove(), get_bool_property(), ifdebug, init, instruction_call, make_block_statement(), MakeForloop(), printf(), split_initializations_in_statement(), STATEMENT, statement_block(), statement_call(), statement_declarations, statement_instruction, and statements_to_direct_declarations().

Here is the call graph for this function:

MakeFunctionExpression()

expression MakeFunctionExpression	(	expression	e,
		list	le
	)

e is now owned by returned expression and must not be used any longer

There are 2 cases:

1. The first argument corresponds to a function name (an entity).

   In this case, we create a normal call expression and the corresponding entity is added to the list of callees.

2. The first argument can be any expression denoting a called function (a pointer to a function,... such as (*ctx->Driver.RenderString)() in the benchmark mesa in SPEC2000). In this case, we create a function application expression.

Must be a pointer to a function

Undeclared functions return int by default

This cannot be checked unless bootstrap typing is improved for varargs intrinsics, mostly IOs.

Parameters

le

e

Definition at line 368 of file util.c.

{
  /* There are 2 cases:
 
     1. The first argument corresponds to a function name (an entity).
 
        In this case, we create a normal call expression and the
        corresponding entity is added to the list of callees.
 
     2. The first argument can be any expression denoting a called
        function (a pointer to a function,... such as
        (*ctx->Driver.RenderString)() in the benchmark mesa in
        SPEC2000).  In this case, we create a function application
        expression.
  */
  expression exp = expression_undefined;
  syntax s = expression_syntax(e);
  switch (syntax_tag(s))
    {
    case is_syntax_reference:
      {
        entity ent = reference_variable(syntax_reference(s));
    free_expression(e);
        entity cf = get_current_module_entity();
 
        ifdebug(8) {
          pips_debug(8, "Call to \"\%s\" with %zd argument(s)\n",
                     entity_name(ent), gen_length(le));
          print_expressions(le);
        }
 
        if(!intrinsic_entity_p(ent)) {
          entity cu = get_current_compilation_unit_entity();
          list cudl = code_declarations(value_code(entity_initial(cu)));
          type ut = ultimate_type(entity_type(ent));
 
          if(type_functional_p(ut))
            AddToCalledModules(ent);
          else {
            /* Must be a pointer to a function */
            const char * eun = entity_user_name(ent);
            c_parser_user_warning("Call to an unknown function via function pointer \"\%s\"\n",
                              eun);
          }
 
          if(!gen_in_list_p(ent, cudl)) {
            /* Undeclared functions return int by default */
            type ft = entity_type(ent);
            functional f = type_functional(ft);
 
            pips_assert("function's type is ultimately functional or pointer to functional",
                        call_compatible_type_p(ft));
            f = type_functional(ft);
            if(type_functional_p(ft) && type_unknown_p(functional_result(f)))
              functional_result(f) = MakeIntegerResult();
            AddToDeclarations(ent, cf);
          }
        }
        pips_debug(6,"Normal function or intrinsics call\n");
    (void)check_C_function_type(ent,le);
        exp = make_call_expression(ent,le);
        /* This cannot be checked unless bootstrap typing is improved
           for varargs intrinsics, mostly IOs. */
        /*
        if(!ok) {
          c_parser_user_warning("Actual arguments do not fit the declared formal "
                            "arguments of function \"%s\"\n",
                            entity_user_name(ent));
          CParserError("Type mismatch\n");
          }
        */
        break;
      }
    case is_syntax_call:
      {
        application a = make_application(e,le);
        pips_debug(6,"Application function call\n");
        exp = make_expression(make_syntax_application(a),normalized_undefined);
        break;
      }
    case is_syntax_range:
    case is_syntax_cast:
    case is_syntax_sizeofexpression:
    case is_syntax_subscript:
    case is_syntax_application:
      CParserError("This is not a functional expression\n");
      break;
    default:
      {
        pips_internal_error("unexpected syntax tag: %d", syntax_tag(s));
      }
    }
  return exp;
}

References AddToCalledModules(), AddToDeclarations(), c_parser_user_warning, call_compatible_type_p(), check_C_function_type(), code_declarations, CParserError(), entity_initial, entity_name, entity_type, entity_user_name(), exp, expression_syntax, expression_undefined, f(), free_expression(), functional_result, gen_in_list_p(), gen_length(), get_current_compilation_unit_entity(), get_current_module_entity(), ifdebug, intrinsic_entity_p(), is_syntax_application, is_syntax_call, is_syntax_cast, is_syntax_range, is_syntax_reference, is_syntax_sizeofexpression, is_syntax_subscript, make_application(), make_call_expression(), make_expression(), make_syntax_application(), MakeIntegerResult(), normalized_undefined, pips_assert, pips_debug, pips_internal_error, print_expressions(), reference_variable, syntax_reference, syntax_tag, type_functional, type_functional_p, type_unknown_p, ultimate_type(), and value_code.

Here is the call graph for this function:

MakeGotoStatement()

statement MakeGotoStatement

(

string

label

)

Find the corresponding statement from its label, if not found, create a pseudo one, which will be replaced lately when we see the statement (label: statement)

Parameters

label

abel

Definition at line 254 of file statement.c.

{
  entity l = MakeCLabel(label);
  statement gts = statement_undefined;
 
  /* Find the corresponding statement from its label,
     if not found, create a pseudo one, which will be replaced lately when
     we see the statement (label: statement) */
 
  statement s = FindStatementFromLabel(l);
  if (s == statement_undefined) {
    s = make_continue_statement(l);
    LabeledStatements = CONS(STATEMENT,s,LabeledStatements);
  }
  gts = make_statement(entity_empty_label(),
                       get_current_C_line_number(),
                       STATEMENT_ORDERING_UNDEFINED,
                       get_current_C_comment(),
                       make_instruction(is_instruction_goto,s),NIL,NULL,
                       empty_extensions (), make_synchronization_none());
 
  return gts;
}

References CONS, empty_extensions(), entity_empty_label(), FindStatementFromLabel(), get_current_C_comment(), get_current_C_line_number(), is_instruction_goto, LabeledStatements, make_continue_statement(), make_instruction(), make_statement(), make_synchronization_none(), MakeCLabel(), NIL, STATEMENT, STATEMENT_ORDERING_UNDEFINED, and statement_undefined.

Referenced by MakeBreakStatement(), MakeCaseStatement(), MakeContinueStatement(), and MakeDefaultStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeLabeledStatement()

statement MakeLabeledStatement	(	string	label,
		statement	s,
		string	comment
	)

Construct a new statement from.

Parameters

s	by adding a
label	and a
comment.	If it is possible to do it without creating a new statement, retun the old one modified according to.

There is no other statement already associated with this label...

Add a label and deal all the gory details about the PIPS internal representation:

There is already a statement stub smt associated to this label with some gotos pointing to it, so keep it as the labeled target.

The statement does not have a label and can accept one, so patch in place smt:

The statement can not accept a label or another one, just keep the previous label in front:

Parameters

label	abel
comment	omment

Definition at line 204 of file statement.c.

                                                                          {
  entity l = MakeCLabel(label);
  statement labeled_statement;
  // Get the statement with the l label, if any:
  statement smt = FindStatementFromLabel(l);
  if (smt == statement_undefined) {
    /* There is no other statement already associated with this
       label... */
    /* Add a label and deal all the gory details about the PIPS internal
     representation: */
    s = add_label_to_statement(l, s, &labeled_statement);
    // Keep a track of this statement associated to a label:
    LabeledStatements = CONS(STATEMENT, labeled_statement, LabeledStatements);
  }
  else {
    /* There is already a statement stub smt associated to this label with
       some gotos pointing to it, so keep it as the labeled target. */
    if (!instruction_sequence_p(statement_instruction(s))
        && unlabelled_statement_p(s)) {
      /* The statement does not have a label and can accept one, so
         patch in place smt: */
      statement_instruction(smt) =  statement_instruction(s);
      statement_comments(smt) = statement_comments(s);
      // Discard the old statement:
      statement_instruction(s) = instruction_undefined;
      statement_comments(s) = string_undefined;
      free_statement(s);
      // And keep the old one:
      s = smt;
      labeled_statement = s;
    }
    else {
      /* The statement can not accept a label or another one, just keep
         the previous label in front: */
      list stmts = gen_statement_cons(s, NIL);
      stmts = gen_statement_cons(smt, stmts);
      statement seq = make_block_statement(stmts);
      labeled_statement = smt;
      s = seq;
    }
  }
  // Associate the current comment to the statement with the label:
  if (comment != string_undefined) {
    insert_comments_to_statement(labeled_statement, comment);
    free(comment);
  }
  return s;
}

References add_label_to_statement(), comment(), CONS, FindStatementFromLabel(), free(), free_statement(), gen_statement_cons(), insert_comments_to_statement(), instruction_sequence_p, instruction_undefined, LabeledStatements, make_block_statement(), MakeCLabel(), NIL, STATEMENT, statement_comments, statement_instruction, statement_undefined, string_undefined, and unlabelled_statement_p().

Referenced by MakeCaseStatement(), and MakeDefaultStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeParameterList()

list MakeParameterList	(	list	l1,
		list	l2,
		stack	FunctionStack
	)

l1 is a list of parameter names and it represents the exact order in the parameter list l2 is a list of entities with their type, storage,... and the order can be different from l1 In addition, l2 can be incomplete wrt l1, so other entities must be created from l1, with default type : scalar integer variable.

We create the list of parameters with the order of l1, and the parameter type and mode are retrieved from l2.

Since the offset of formal argument in l2 can be false, we have to update it here by using l1

s is not declared in l2, create the corresponding entity/ formal variable and add it to the declaration list, because it cannot be added with par_def in l2

Parameters

l1	1
l2	2
FunctionStack	unctionStack

Definition at line 3348 of file util.c.

{
  /* l1 is a list of parameter names and it represents the exact order in the parameter list
     l2 is a list of entities with their type, storage,... and the order can be different from l1
     In addition, l2 can be incomplete wrt l1, so other entities must be created from l1, with
     default type : scalar integer variable.
 
     We create the list of parameters with the order of l1, and the parameter type and mode 
     are retrieved from l2.
 
     Since the offset of formal argument in l2 can be false, we have to update it here by using l1 */
  list l = NIL;
  int offset = 1;
  entity function = stack_head(FunctionStack);
  FOREACH(STRING, s,l1)
  {
    parameter p = FindParameterEntity(s,offset,l2);
    if (parameter_undefined_p(p))
      {
        /* s is not declared in l2, create the corresponding entity/ formal variable
         and add it to the declaration list, because it cannot be added with par_def in l2*/
        entity ent = FindOrCreateEntity(entity_user_name(function),s);
        variable v = make_variable(make_basic_int(DEFAULT_INTEGER_TYPE_SIZE),NIL,NIL);
        entity_type(ent) = make_type_variable(v);
        entity_storage(ent) = make_storage_formal(make_formal(function,offset));
        AddToDeclarations(ent,function);
        p = make_parameter(entity_type(ent),
                           make_mode_value(),
                           make_dummy_identifier(ent)); // FI: could be unknown?
      }
    l = gen_nconc(l,CONS(PARAMETER,p,NIL));
    offset++;
  }
  return l;
}

References AddToDeclarations(), CONS, DEFAULT_INTEGER_TYPE_SIZE, entity_storage, entity_type, entity_user_name(), FindOrCreateEntity(), FindParameterEntity(), FOREACH, FunctionStack, gen_nconc(), make_basic_int(), make_dummy_identifier(), make_formal(), make_mode_value(), make_parameter(), make_storage_formal(), make_type_variable(), make_variable(), NIL, offset, PARAMETER, parameter_undefined_p, stack_head(), and STRING.

Here is the call graph for this function:

MakeStorageRam()

storage MakeStorageRam	(	entity	v,
		bool	is_external,
		bool	is_static
	)

The storage part should not be called twice when reparsing compilation unit.

We assume that double declarations are dealt with someone else

ComputeAreaOffset(StaticArea,e)

he offset must be recomputed lately, when we know for sure the size of the variables

This must be a variable, not a function/typedef/struct/union/enum. The variable is declared outside any function, and hence is global

ComputeAreaOffset(get_top_level_entity(),e)

the offset must be recomputed lately, when we know for sure the size of the variable

Global variable can be declared in many different file

ADD BLOCK SCOPE

ComputeAreaOffset(StaticArea,e)

he offset must be recomputed lately, when we know for sure the size of the variable

ComputeAreaOffset(DynamicArea,e)

the offset must be recomputed lately, when we know for sure the size of the variable

Parameters

is_external	s_external
is_static	s_static

Definition at line 3177 of file util.c.

{
  ram r = ram_undefined;
  area lsa = type_area(entity_type(StaticArea));
  area dsa = type_area(entity_type(DynamicArea));
  entity moduleStaticArea = FindOrCreateEntity(compilation_unit_name,  STATIC_AREA_LOCAL_NAME);
  area msa = type_area(entity_type(moduleStaticArea));
  entity globalStaticArea = FindOrCreateEntity(TOP_LEVEL_MODULE_NAME,  STATIC_AREA_LOCAL_NAME);
  area gsa = type_area(entity_type(globalStaticArea));
  area stack = type_area(entity_type(StackArea));
  //area heap = type_area (entity_type(HeapArea));
  //entity m = get_current_module_entity();
 
  pips_assert("RAM Storage is used only for variables", type_variable_p(entity_type(v)));
 
  if (is_external)
    {
      if (is_static)
        {
          r = make_ram(get_current_compilation_unit_entity(),
                       moduleStaticArea,
                       UNKNOWN_RAM_OFFSET /* ComputeAreaOffset(StaticArea,e) */,
                       NIL);
 
          /*the offset must be recomputed lately, when we know for
            sure the size of the variables */
          if(get_current_compilation_unit_entity() != get_current_module_entity()
             || !gen_in_list_p(v,area_layout(msa)))
            area_layout(msa) = gen_nconc(area_layout(msa), CONS(ENTITY, v, NIL));
        }
      else
        {
          /* This must be a variable, not a function/typedef/struct/union/enum.
             The variable is declared outside any function, and hence is global*/
 
          r = make_ram(get_top_level_entity(),
                       globalStaticArea,
                       UNKNOWN_RAM_OFFSET /* ComputeAreaOffset(get_top_level_entity(),e) */,
                       NIL);
          /* the offset must be recomputed lately, when we know for
             sure the size of the variable */
          /* Global variable can be declared in many different file */
          if(!gen_in_list_p(v,area_layout(gsa)))
            area_layout(gsa) = gen_nconc(area_layout(gsa), CONS(ENTITY, v, NIL));
        }
    }
  else
    {
      /* ADD BLOCK SCOPE */
      if (is_static)
        {
          r = make_ram(get_current_module_entity(),
                       StaticArea,
                       UNKNOWN_RAM_OFFSET /* ComputeAreaOffset(StaticArea,e) */,
                       NIL);
          /*the offset must be recomputed lately, when we know for
            sure the size of the variable */
          area_layout(lsa) = gen_nconc(area_layout(lsa), CONS(ENTITY, v, NIL));
        }
      else
        {
          int s = 0;
          if(!SizeOfArray(v, &s))
            {
              r = make_ram(get_current_module_entity(),
                           StackArea,
                           DYNAMIC_RAM_OFFSET,
                           NIL);
              area_layout(stack) = gen_nconc(area_layout(stack), CONS(ENTITY, v, NIL));
            }
          else {
            r = make_ram(get_current_module_entity(),
                         DynamicArea,
                         UNKNOWN_RAM_OFFSET /* ComputeAreaOffset(DynamicArea,e) */,
                         NIL);
            /* the offset must be recomputed lately, when we know for
               sure the size of the variable */
            area_layout(dsa) = gen_nconc(area_layout(dsa), CONS(ENTITY, v, NIL));
          }
        }
    }
  return make_storage_ram(r);
}

References area_layout, compilation_unit_name, CONS, DYNAMIC_RAM_OFFSET, DynamicArea, ENTITY, entity_type, FindOrCreateEntity(), gen_in_list_p(), gen_nconc(), get_current_compilation_unit_entity(), get_current_module_entity(), get_top_level_entity(), is_external, make_ram(), make_storage_ram(), NIL, pips_assert, ram_undefined, SizeOfArray(), StackArea, STATIC_AREA_LOCAL_NAME, StaticArea, TOP_LEVEL_MODULE_NAME, type_area, type_variable_p, and UNKNOWN_RAM_OFFSET.

Referenced by UpdateEntity().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeSwitchStatement()

statement MakeSwitchStatement

(

statement

s

)

Transform a switch statement to if - else - goto. Example:

switch (c) { case 1: s1; case 2: s2; default: sd; }

if (c==1) goto switch_xxx_case_1; if (c==2) goto switch_xxx_case_2; goto switch_xxx_default; switch_xxx_case_1: ; s1; switch_xxx_case_2: ; s2; switch_xxx_default: ; sd;

In si, we can have goto break_xxx; (which was a break)

and break_xxx: ; is inserted at the end of the switch statement

The statement s corresponds to the body

switch_xxx_case_1: ; s1; switch_xxx_case_2: ; s2; switch_xxx_default: ; sd;

we have to insert

if (c==1) goto switch_xxx_case_1; if (c==2) goto switch_xxx_case_2; goto switch_xxx_default;

before s and return the inserted statement.

For the time being, the switch comment is lost. It should already be included in the argument,s

pop_current_C_comment();

Make sure the default case is the last one in the test sequence

Keep the cases in the user order. Tobe checked at the pARSED_PRINTED_FILE level.

no default case, jump out of the switch control structure

trdup("")

This switch has a break statement which has been transformed to goto Add the labeled statement after the switch

ifdebug(5)

{

printf("Switch statement: \n");

print_statement(s);

}

Definition at line 586 of file statement.c.

{
  /* Transform a switch statement to if - else - goto. Example:
 
     switch (c) {
     case 1:
     s1;
     case 2:
     s2;
     default:
     sd;
     }
 
     if (c==1) goto switch_xxx_case_1;
     if (c==2) goto switch_xxx_case_2;
     goto switch_xxx_default;
     switch_xxx_case_1: ;
     s1;
     switch_xxx_case_2: ;
     s2;
     switch_xxx_default: ;
     sd;
 
     In si, we can have goto break_xxx; (which was a break)
 
     and break_xxx: ; is inserted at the end of the switch statement
 
     The statement s corresponds to the body
 
     switch_xxx_case_1: ;
     s1;
     switch_xxx_case_2: ;
     s2;
     switch_xxx_default: ;
     sd;
 
     we have to insert
 
     if (c==1) goto switch_xxx_case_1;
     if (c==2) goto switch_xxx_case_2;
     goto switch_xxx_default;
 
 
     before s and return the inserted statement.  */
  int i = basic_int((basic) stack_head(LoopStack));
  string lab ;
  asprintf(&lab, "%sbreak_%d", get_label_prefix(), i);
  statement smt = statement_undefined;
  statement seq = statement_undefined;
  sequence oseq = (sequence)stack_head(SwitchGotoStack);
  list tl = sequence_statements(oseq);
  list ct = list_undefined;
  list ntl = NIL;
  statement ds = statement_undefined;
 
  ifdebug(8) {
    pips_debug(8, "tl=%p\n", tl);
  }
 
  /* For the time being, the switch comment is lost. It should already
     be included in the argument,s  */
  /* pop_current_C_comment(); */
 
  /* Make sure the default case is the last one in the test sequence */
  for(ct=tl;!ENDP(ct); POP(ct)) {
    statement s = STATEMENT(CAR(ct));
 
    if(instruction_goto_p(statement_instruction(s))) {
      ds = s;
    }
    else {
      /* Keep the cases in the user order. Tobe checked at the
         pARSED_PRINTED_FILE level. */
      ntl = gen_nconc(ntl, CONS(STATEMENT,s,NIL));
      //ntl = CONS(STATEMENT,s,ntl);
    }
  }
  if(statement_undefined_p(ds)) {
    /* no default case, jump out of the switch control structure */
    ds = MakeBreakStatement(string_undefined /*strdup("")*/);
  }
  ntl = gen_nconc(ntl, CONS(STATEMENT,ds,NIL));
  gen_free_list(tl);
  sequence_statements(oseq)=NIL;
  free_sequence(oseq);
  seq = instruction_to_statement(make_instruction_sequence(make_sequence(ntl)));
  //seq = instruction_to_statement(make_instruction_sequence(make_sequence(tl)));
 
  insert_statement(s,seq,true);
 
  smt = FindStatementFromLabel(MakeCLabel(lab));
  free(lab);
  if (!statement_undefined_p(smt))
    {
      /* This switch has a break statement which has been transformed to goto
         Add the labeled statement after the switch */
      insert_statement(s,smt,false);
    }
  pips_assert("Switch is consistent",statement_consistent_p(s));
  /* ifdebug(5) */
  /*   { */
  /*     printf("Switch statement: \n"); */
  /*     print_statement(s); */
  /*   } */
  return s;
}

References asprintf, basic_int, CAR, CONS, ENDP, FindStatementFromLabel(), free(), free_sequence(), gen_free_list(), gen_nconc(), get_label_prefix, ifdebug, insert_statement(), instruction_goto_p, instruction_to_statement(), list_undefined, LoopStack, make_instruction_sequence(), make_sequence(), MakeBreakStatement(), MakeCLabel(), NIL, pips_assert, pips_debug, POP, sequence_statements, stack_head(), STATEMENT, statement_consistent_p(), statement_instruction, statement_undefined, statement_undefined_p, string_undefined, and SwitchGotoStack.

Here is the call graph for this function:

MakeTopLevelEntity()

void MakeTopLevelEntity

(

void

)

To be economic, group this top-level entity to it areas

FI: this is not convenient if top-level:top-level is a module. All global variables should be declared there. I need also to generate stubs for global variables... Do I? Yes, because the points-to information is computed bottom-up.

Definition at line 157 of file util.c.

{
  /* To be economic, group this top-level entity to it areas*/
  /* FI: this is not convenient if top-level:top-level is a
     module. All global variables should be declared there. I need
     also to generate stubs for global variables... Do I? Yes, because
     the points-to information is computed bottom-up. */
  entity e = FindOrCreateEntity(TOP_LEVEL_MODULE_NAME,TOP_LEVEL_MODULE_NAME);
  entity_storage(e) = make_storage_rom();
  //entity_type(e) = make_type(is_type_area, make_area(0, NIL));
  entity_type(e) =
    make_type_functional(make_functional(NIL, make_type_void(NIL)));
  //entity_initial(e) = make_value_unknown();
  code c = make_code(NIL, strdup(""), make_sequence(NIL),
                     NIL, make_language_c());
  entity_initial(e) = make_value_code(c);
}

References entity_initial, entity_storage, entity_type, FindOrCreateEntity(), make_code(), make_functional(), make_language_c(), make_sequence(), make_storage_rom(), make_type_functional(), make_type_void(), make_value_code(), NIL, strdup(), and TOP_LEVEL_MODULE_NAME.

Referenced by actual_c_parser().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeWhileLoop()

statement MakeWhileLoop	(	list	lexp,
		statement	s,
		bool	before
	)

This loop has a continue statement which has been transformed to goto Add the labeled statement at the end of loop body

This loop has a break statement which has been transformed to goto Add the labeled statement after the loop

ifdebug(5)

{

printf("While loop statement: \n");

print_statement(smt);

}

Parameters

lexp	exp
before	efore

Definition at line 297 of file statement.c.

{
  statement smt;
  int i = basic_int((basic) stack_head(LoopStack));
  string lab1;
  asprintf(&lab1,"%s%s%d", get_label_prefix(), "loop_end_", i);
  statement s1 = FindStatementFromLabel(MakeCLabel(lab1));
  free(lab1);
  string lab2;
  asprintf(&lab2,"%s%s%d", get_label_prefix(), "break_", i);
  statement s2 = FindStatementFromLabel(MakeCLabel(lab2));
  free(lab2);
 
  if (!statement_undefined_p(s1))
    {
      /* This loop has a continue statement which has been transformed to goto
         Add the labeled statement at the end of loop body*/
      insert_statement(s,s1,false);
    }
 
  smt = make_whileloop_statement(MakeCommaExpression(lexp),
                                 s,
                                 get_current_C_line_number(),
                                 before);
  if (!statement_undefined_p(s2))
    {
      /* This loop has a break statement which has been transformed to goto
         Add the labeled statement after the loop */
      insert_statement(smt,s2,false);
    }
 
  pips_assert("While loop is consistent",statement_consistent_p(smt));
  /* ifdebug(5) */
  /*   { */
  /*     printf("While loop statement: \n"); */
  /*     print_statement(smt); */
  /*   } */
  return smt;
}

References asprintf, basic_int, FindStatementFromLabel(), free(), get_current_C_line_number(), get_label_prefix, insert_statement(), lexp, LoopStack, make_whileloop_statement(), MakeCLabel(), MakeCommaExpression(), pips_assert, s1, stack_head(), statement_consistent_p(), and statement_undefined_p.

Here is the call graph for this function:

MemberDerivedIdentifierToExpression()

expression MemberDerivedIdentifierToExpression	(	type	t,
		string	m
	)

Definition at line 463 of file util.c.

{
  if (type_variable_p(t))
    {
      basic b = variable_basic(type_variable(t));
      pips_debug(6,"Basic tag is %d\n",basic_tag(b));
      switch (basic_tag(b)) {
      case is_basic_pointer:
        {
          type tp = basic_pointer(b);
          return MemberDerivedIdentifierToExpression(tp,m);
        }
      case is_basic_typedef:
        {
          entity te = basic_typedef(b);
          type tp = entity_type(te);
          return MemberDerivedIdentifierToExpression(tp,m);
        }
      case is_basic_derived:
        {
          entity de = basic_derived(b);
          const char * name = entity_user_name(de);
      string id = strdup(concatenate(name,MEMBER_SEP_STRING,m,NULL));
          expression exp = IdentifierToExpression(id);
      free(id);
      return exp;
        }
      default:
        break;
      }
    }
  CParserError("Cannot find the field identifier from current type\n");
  return expression_undefined;
}

References basic_derived, basic_pointer, basic_tag, basic_typedef, concatenate(), CParserError(), entity_type, entity_user_name(), exp, expression_undefined, free(), IdentifierToExpression(), is_basic_derived, is_basic_pointer, is_basic_typedef, MEMBER_SEP_STRING, MemberDerivedIdentifierToExpression(), pips_debug, strdup(), type_variable, type_variable_p, and variable_basic.

Referenced by MemberDerivedIdentifierToExpression(), and MemberIdentifierToExpression().

Here is the call graph for this function:

Here is the caller graph for this function:

MemberIdentifierToExpression()

expression MemberIdentifierToExpression	(	expression	e,
		string	m
	)

Find the name of struct/union of m from the type of expression e

The first expression must be a pointer

standard integer arithmetic: why bother? why take the CDR?

FI: seems too simple. No need to remember if you sarted with "." or "->"?

Let use the second argument

More types of call must be taken into account: typedef and pointer to functions

User defined call and intrinsics not processed above

A call must have occured somewhere...

An apply must have occured somewhere...

expression exp = subscript_array(syntax_subscript(s));

pips_debug(6,"Subscripting array expression\n");

return MemberIdentifierToExpression(exp, m);

Definition at line 498 of file util.c.

{
  /* Find the name of struct/union of m from the type of expression e*/
 
  syntax s = expression_syntax(e);
  ifdebug(6)
    {
      pips_debug(6,"Find the struct/union of \"%s\" from expression:\n",m);
      print_expression(e);
    }
  switch (syntax_tag(s))
    {
    case is_syntax_call:
      {
        call c = syntax_call(s);
        entity f = call_function(c);
        pips_debug(6,"Called operator is \"%s\"\n",entity_name(f));
        if(ENTITY_PLUS_C_P(f))
          {
            expression e1 = EXPRESSION(CAR(call_arguments(c)));
            expression e2 = EXPRESSION(CAR(CDR(call_arguments(c))));
            expression exp = expression_undefined;
            basic b1 = basic_of_expression(e1);
            basic b2 = basic_of_expression(e2);
 
            if(basic_pointer_p(b1) && (basic_int_p(b2)||basic_bit_p(b2)))
              exp = e1;
            else if(basic_pointer_p(b2) && (basic_int_p(b1)||basic_bit_p(b1)))
              exp = e2;
            else
              CParserError("Pointer arithmetic error, incompatible types");
            free_basic(b1);
            free_basic(b2);
 
            return MemberIdentifierToExpression(exp,m);
          }
        else if(ENTITY_POST_INCREMENT_P(f) || ENTITY_POST_DECREMENT_P(f)
           || ENTITY_PRE_INCREMENT_P(f) || ENTITY_PRE_DECREMENT_P(f))
          {
            expression exp = EXPRESSION(CAR(call_arguments(c)));
            return MemberIdentifierToExpression(exp,m);
          }
        else if(ENTITY_MINUS_C_P(f))
          {
            /* The first expression must be a pointer */
            expression exp = EXPRESSION(CAR(call_arguments(c)));
            return MemberIdentifierToExpression(exp,m);
          }
        else if(ENTITY_PLUS_P(f))
          {
            /* standard integer arithmetic: why bother? why take the CDR? */
            expression exp = EXPRESSION(CAR(CDR(call_arguments(c))));
            return MemberIdentifierToExpression(exp,m);
          }
        else if (ENTITY_FIELD_P(f) || ENTITY_POINT_TO_P(f))
          {
            expression exp = EXPRESSION(CAR(CDR(call_arguments(c))));
            return MemberIdentifierToExpression(exp,m);
          }
        else if (ENTITY_DEREFERENCING_P(f))
          {
            expression exp = EXPRESSION(CAR(call_arguments(c)));
            return MemberIdentifierToExpression(exp,m);
          }
        /* FI: seems too simple. No need to remember if you sarted with "." or "->"? */
        else if (ENTITY_ADDRESS_OF_P(f))
          {
            expression exp = EXPRESSION(CAR(call_arguments(c)));
            return MemberIdentifierToExpression(exp,m);
          }
        else if (ENTITY_ASSIGN_P(f))
          {
            expression exp = EXPRESSION(CAR(call_arguments(c)));
            return MemberIdentifierToExpression(exp,m);
          }
        else if (ENTITY_CONDITIONAL_P(f))
          {
            /* Let use the second argument */
            expression exp = EXPRESSION(CAR(CDR(call_arguments(c))));
            return MemberIdentifierToExpression(exp,m);
          }
        /* More types of call must be taken into account: typedef and
           pointer to functions */
        else if (true || type_functional_p(entity_type(f)))
          {
            /* User defined call and intrinsics not processed above */
            type ft = call_to_functional_type(c, true);
            type t = functional_result(type_functional(ft));
            if(overloaded_type_p(t))
              pips_internal_error("Unresolved expression type\n");
            return MemberDerivedIdentifierToExpression(t,m);
          }
        break;
      }
    case is_syntax_reference:
      {
        entity ent = reference_variable(syntax_reference(s));
        type t = ultimate_type(entity_type(ent));
        pips_debug(6,"Reference expression\n");
 
        if(type_functional_p(t)) {
          /* A call must have occured somewhere... */
          type rt = ultimate_type(functional_result(type_functional(t)));
          return MemberDerivedIdentifierToExpression(rt,m);
        }
        else if(type_variable_p(t) && basic_pointer_p(variable_basic(type_variable(t)))) {
          type pt = ultimate_type(basic_pointer(variable_basic(type_variable(t))));
 
          if(type_functional_p(pt)) {
            /* An apply must have occured somewhere... */
            type rt = ultimate_type(functional_result(type_functional(pt)));
            return MemberDerivedIdentifierToExpression(rt,m);
          }
          else
            return MemberDerivedIdentifierToExpression(t,m);
        }
        else
          return MemberDerivedIdentifierToExpression(t,m);
      }
    case is_syntax_cast:
      {
        type t = cast_type(syntax_cast(s));
        pips_debug(6,"Cast expression\n");
        return MemberDerivedIdentifierToExpression(t,m);
      }
    case is_syntax_range:
      break;
    case is_syntax_sizeofexpression:
      break;
    case is_syntax_subscript:
      {
        /* expression exp = subscript_array(syntax_subscript(s)); */
        /* pips_debug(6,"Subscripting array expression\n"); */
        /* return MemberIdentifierToExpression(exp, m); */
        type t = expression_to_type(e);
        return MemberDerivedIdentifierToExpression(t,m);
      }
    case is_syntax_application:
      {
        expression fe = application_function(syntax_application(s));
        return MemberIdentifierToExpression(fe, m);
        break;
      }
    default:
      {
        pips_internal_error("unexpected syntax tag: %d", syntax_tag(s));
      }
    }
  CParserError("Cannot find the field identifier from current expression\n");
  return expression_undefined;
}

References application_function, b1, b2, basic_bit_p, basic_int_p, basic_of_expression(), basic_pointer, basic_pointer_p, call_arguments, call_function, call_to_functional_type(), CAR, cast_type, CDR, CParserError(), ENTITY_ADDRESS_OF_P, ENTITY_ASSIGN_P, ENTITY_CONDITIONAL_P, ENTITY_DEREFERENCING_P, ENTITY_FIELD_P, ENTITY_MINUS_C_P, entity_name, ENTITY_PLUS_C_P, ENTITY_PLUS_P, ENTITY_POINT_TO_P, ENTITY_POST_DECREMENT_P, ENTITY_POST_INCREMENT_P, ENTITY_PRE_DECREMENT_P, ENTITY_PRE_INCREMENT_P, entity_type, exp, EXPRESSION, expression_syntax, expression_to_type(), expression_undefined, f(), free_basic(), functional_result, ifdebug, is_syntax_application, is_syntax_call, is_syntax_cast, is_syntax_range, is_syntax_reference, is_syntax_sizeofexpression, is_syntax_subscript, MemberDerivedIdentifierToExpression(), MemberIdentifierToExpression(), overloaded_type_p(), pips_debug, pips_internal_error, print_expression(), reference_variable, syntax_application, syntax_call, syntax_cast, syntax_reference, syntax_tag, type_functional, type_functional_p, type_variable, type_variable_p, ultimate_type(), and variable_basic.

Referenced by MemberIdentifierToExpression().

Here is the call graph for this function:

Here is the caller graph for this function:

NStackPop()

void NStackPop	(	stack	s,
		int	n
	)

Pop n times the stack s.

Definition at line 3442 of file util.c.

{
  while (n-->0)
    gen_free(stack_pop(s));
}

References gen_free(), and stack_pop().

Referenced by StackPop().

Here is the call graph for this function:

Here is the caller graph for this function:

parser_init_keyword_typedef_table()

void parser_init_keyword_typedef_table

(

void

)

FI: keyword_typedef_table is also a global variable. I am trying to move towards some kind of functional wrapping around the global variable, which I would like to declare static in ri-util/static.c.

GNU predefined type(s), expecting no conflict with user named type

AM: en attendant mieux...

typedef names are added later when encoutered.

Definition at line 193 of file c_parser.c.

{
  /* FI: keyword_typedef_table is also a global variable.  I am trying
   * to move towards some kind of functional wrapping around the
   * global variable, which I would like to declare static in
   * ri-util/static.c.
   */
  hash_table keyword_typedef_table = make_keyword_typedef_table(TK_NAMED_TYPE);
  hash_put(keyword_typedef_table,"auto", (char *) TK_AUTO);
  hash_put(keyword_typedef_table,"break", (char *) TK_BREAK);
  hash_put(keyword_typedef_table,"case", (char *) TK_CASE);
  hash_put(keyword_typedef_table,"char", (char *) TK_CHAR);
  hash_put(keyword_typedef_table,"const", (char *) TK_CONST);
  hash_put(keyword_typedef_table,"__const", (char *) TK_CONST);
  hash_put(keyword_typedef_table,"continue", (char *) TK_CONTINUE);
  hash_put(keyword_typedef_table,"default", (char *) TK_DEFAULT);
  hash_put(keyword_typedef_table,"do", (char *) TK_DO);
  hash_put(keyword_typedef_table,"double", (char *) TK_DOUBLE);
  hash_put(keyword_typedef_table,"else", (char *) TK_ELSE);
  hash_put(keyword_typedef_table,"enum", (char *) TK_ENUM);
  hash_put(keyword_typedef_table,"extern", (char *) TK_EXTERN);
  hash_put(keyword_typedef_table,"float", (char *) TK_FLOAT);
  hash_put(keyword_typedef_table,"for", (char *) TK_FOR);
  hash_put(keyword_typedef_table,"goto", (char *) TK_GOTO);
  hash_put(keyword_typedef_table,"if", (char *) TK_IF);
  hash_put(keyword_typedef_table,"inline", (char *) TK_INLINE);
  hash_put(keyword_typedef_table,"int", (char *) TK_INT);
  hash_put(keyword_typedef_table,"__int128_t", (char *) TK_INT128);
  hash_put(keyword_typedef_table,"__uint128_t", (char *) TK_UINT128);
  hash_put(keyword_typedef_table,"_Complex", (char *) TK_COMPLEX);
  hash_put(keyword_typedef_table,"long", (char *) TK_LONG);
  hash_put(keyword_typedef_table,"register", (char *) TK_REGISTER);
  hash_put(keyword_typedef_table,"restrict", (char *) TK_RESTRICT);
  hash_put(keyword_typedef_table,"__restrict", (char *) TK_RESTRICT);
  hash_put(keyword_typedef_table,"__restrict__", (char *) TK_RESTRICT);
  hash_put(keyword_typedef_table,"return", (char *) TK_RETURN);
  hash_put(keyword_typedef_table,"short", (char *) TK_SHORT);
  hash_put(keyword_typedef_table,"signed", (char *) TK_SIGNED);
  hash_put(keyword_typedef_table,"sizeof", (char *) TK_SIZEOF);
  hash_put(keyword_typedef_table,"static", (char *) TK_STATIC);
  hash_put(keyword_typedef_table,"struct", (char *) TK_STRUCT);
  hash_put(keyword_typedef_table,"switch", (char *) TK_SWITCH);
  hash_put(keyword_typedef_table,"__thread", (char *) TK_THREAD);
  hash_put(keyword_typedef_table,"typedef", (char *) TK_TYPEDEF);
  hash_put(keyword_typedef_table,"union", (char *) TK_UNION);
  hash_put(keyword_typedef_table,"unsigned", (char *) TK_UNSIGNED);
  hash_put(keyword_typedef_table,"void", (char *) TK_VOID);
  hash_put(keyword_typedef_table,"volatile", (char *) TK_VOLATILE);
  hash_put(keyword_typedef_table,"while", (char *) TK_WHILE);
  hash_put(keyword_typedef_table,"__builtin_va_arg", (char *) TK_BUILTIN_VA_ARG);
  hash_put(keyword_typedef_table,"asm", (char *) TK_ASM);
  hash_put(keyword_typedef_table,"__asm__", (char *) TK_ASM);
  hash_put(keyword_typedef_table,"__volatile__", (char *) TK_VOLATILE);
 
  /* GNU predefined type(s), expecting no conflict with user named type */
 
  hash_put(keyword_typedef_table,"__builtin_va_list", (char *) TK_NAMED_TYPE);
  hash_put(keyword_typedef_table,"_Bool", (char *) TK_NAMED_TYPE);
 
  /* AM: en attendant mieux... */
  hash_put(keyword_typedef_table,"STEP_ARG", (char *) TK_NAMED_TYPE);
 
  /* typedef names are added later when encoutered. */
}

References hash_put(), keyword_typedef_table, make_keyword_typedef_table(), TK_ASM, TK_AUTO, TK_BREAK, TK_BUILTIN_VA_ARG, TK_CASE, TK_CHAR, TK_COMPLEX, TK_CONST, TK_CONTINUE, TK_DEFAULT, TK_DO, TK_DOUBLE, TK_ELSE, TK_ENUM, TK_EXTERN, TK_FLOAT, TK_FOR, TK_GOTO, TK_IF, TK_INLINE, TK_INT, TK_INT128, TK_LONG, TK_NAMED_TYPE, TK_REGISTER, TK_RESTRICT, TK_RETURN, TK_SHORT, TK_SIGNED, TK_SIZEOF, TK_STATIC, TK_STRUCT, TK_SWITCH, TK_THREAD, TK_TYPEDEF, TK_UINT128, TK_UNION, TK_UNSIGNED, TK_VOID, TK_VOLATILE, and TK_WHILE.

Referenced by actual_c_parser().

Here is the call graph for this function:

Here is the caller graph for this function:

pop_block_scope()

string pop_block_scope

(

string

old_scope

)

The scope is moved up the scope tree and a NULL is return when there are no more scope to explore.

get rid of last block separator

Parameters

old_scope

ld_scope

Definition at line 235 of file cyacc.tab.c.

{
  string new_scope = old_scope;
  string last_scope = string_undefined;
 
  pips_debug(8, "old_scope = \"%s\"\n", old_scope);
  pips_assert("old_scope is a scope", string_block_scope_p(old_scope));
 
  if(strlen(old_scope)>0) {
    /* get rid of last block separator */
    new_scope[strlen(new_scope)-1] = '\0';
    last_scope = strrchr(new_scope, BLOCK_SEP_CHAR);
 
    if(last_scope==NULL)
      *new_scope = '\0';
    else
      *(last_scope+1) = '\0';
  }
  else
    new_scope = NULL;
 
  if(new_scope!=NULL) {
    pips_debug(8, "new_scope = \"%s\"\n", new_scope);
    pips_assert("new_scope is a scope", string_block_scope_p(new_scope));
  }
  else {
    pips_debug(8, "new_scope = NULL\n");
  }
 
  return new_scope;
}

pop_c_parser_scope_stack()

void pop_c_parser_scope_stack

(

void

)

Definition at line 558 of file cyacc.tab.c.

 {
   stack_pop(c_parser_scope_stack);
   return;
 }

Referenced by ExitScope().

Here is the caller graph for this function:

pop_current_C_comment()

string pop_current_C_comment

(

void

)

Pop the current comment.

Returns

the previous current comment.

This is typically used at the end of a statement to be built.

Note this do not set the current comment. Strange API...

Definition at line 1352 of file clexer.c.

{
  string cc = comments_pop();
  if (string_undefined_p(cc))
    pips_debug(3, "empty comment popped at line %d\n",
               get_current_C_line_number());
  else
    pips_debug(3, "comment \"%s\" popped at line %d\n", cc,
               get_current_C_line_number());
  return cc;
}

pop_current_C_line_number()

int pop_current_C_line_number

(

void

)

Definition at line 1202 of file clexer.c.

{
  int ln = line_number_pop();
  c_lineno = absolute_line_number_pop();
 
  return ln;
}

PopContext()

void PopContext

(

void

)

Definition at line 441 of file cyacc.tab.c.

{
  c_parser_context fc = (c_parser_context) stack_head(ContextStack);
 
  pips_debug(8, "Context %p with scope \"%s\" is popped from stack position %d\n",
             fc, c_parser_context_scope(fc), stack_size(ContextStack));
  (void)stack_pop(ContextStack);
  if(stack_empty_p(ContextStack)) {
    pips_debug(8, "context stack is now empty\n");
  }
  else {
    c_parser_context h = (c_parser_context) stack_head(ContextStack);
    pips_debug(8, "Context %p with scope \"%s\" is top of stack at position %d\n",
               h, c_parser_context_scope(h), stack_size(ContextStack));
  }
}

push_current_C_comment()

void push_current_C_comment

(

void

)

Push the current C comment so that we can get it back when building the statement later.

This reset the current comment through get_current_C_comment()

Definition at line 1331 of file clexer.c.

{
  string cc = get_current_C_comment();
 
  if (string_undefined_p(cc))
    pips_debug(3, "empty comment pushed at line %d\n",
               get_current_C_line_number());
  else
    pips_debug(3, "comment \"%s\" pushed at line %d\n", cc,
               get_current_C_line_number());
   comments_push(cc);
}

push_current_C_line_number()

void push_current_C_line_number

(

void

)

The line number stack, designed for structured control structure, is not used yet.

Definition at line 1194 of file clexer.c.

{
  int ln = get_current_C_line_number();
 
  line_number_push(ln);
  absolute_line_number_push(c_lineno);
}

push_new_c_parser_scope()

void push_new_c_parser_scope

(

void

)

Definition at line 549 of file cyacc.tab.c.

 {
   c_parser_scope_number++;
   string sn = string_undefined;
   (void) asprintf(&sn, "%d", c_parser_scope_number);
   stack_push((void *) sn, c_parser_scope_stack);
   return;
 }

Referenced by EnterScope().

Here is the caller graph for this function:

PushContext()

void PushContext

(

c_parser_context

c

)

Definition at line 434 of file cyacc.tab.c.

{
  stack_push((char *) c, ContextStack);
  pips_debug(8, "Context %p with scope \"%s\" is put in stack position %d\n",
             c, c_parser_context_scope(c), stack_size(ContextStack));
}

put_new_typedef()

void put_new_typedef

(

const char *

name

)

This function is used by libraries "step"* and "task_parallelization".

FI: I have no idea why it works although the keyword_typedef_table should not be initialized... It could not be made static, because it might be used by any file in the c_syntax library.

Parameters

name

ame

Definition at line 1078 of file util.c.

{
  hash_put(keyword_typedef_table,strdup(name),(void *) TK_NAMED_TYPE);
  pips_debug(5,"Add typedef name %s to hash table\n",name);
}

References hash_put(), keyword_typedef_table, pips_debug, strdup(), and TK_NAMED_TYPE.

Referenced by cast_STEP_ARG(), mpi_initialize(), mpi_type_mpi_comm(), mpi_type_mpi_request(), and mpi_type_mpi_status().

Here is the call graph for this function:

Here is the caller graph for this function:

put_to_entity_type_stack_table()

void put_to_entity_type_stack_table	(	entity	key,
		stack	value
	)

Parameters

key

ey

Definition at line 139 of file c_parser.c.

{
  if(stack_undefined_p(value))
    pips_internal_error("The stack must be defined");
  hash_put(entity_to_type_stack_table, entity_name(key),(void *) value);
}

References entity_name, entity_to_type_stack_table, hash_put(), pips_internal_error, and stack_undefined_p.

Referenced by RenameFunctionEntity(), and SubstituteDummyParameters().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_entity_type_stack()

void remove_entity_type_stack

(

entity

e

)

Definition at line 156 of file c_parser.c.

{
  //entity te = entity_undefined;
  void * p = hash_get(entity_to_type_stack_table, (void *) entity_name(e));
  //void * p = hash_delget(entity_to_type_stack_table, (void *) e, (void **) &te);
 
  pips_debug(8, "Remove type stack for \"%s\":", entity_name(e));
  //fprintf(stderr, "Remove type stack for \"%s\"\n", entity_name(e));
  //pips_debug(8, "get=%p, delget=%p\n", p1, p);
  if(p==HASH_UNDEFINED_VALUE) {
    ifdebug(8) {fprintf(stderr, "no associated stack\n");
    }
  }
  else {
    stack es = (stack) p;
 
    (void) hash_del(entity_to_type_stack_table, (void *) entity_name(e));
    if(!stack_undefined_p(es))
      stack_free(&es);
    ifdebug(8) fprintf(stderr, "done\n");
  }
}

References entity_name, entity_to_type_stack_table, fprintf(), hash_del(), hash_get(), HASH_UNDEFINED_VALUE, ifdebug, pips_debug, stack_free(), and stack_undefined_p.

Referenced by remove_entity_type_stacks(), and SubstituteDummyParameters().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_entity_type_stacks()

void remove_entity_type_stacks

(

list

el

)

Parameters

el

l

Definition at line 179 of file c_parser.c.

{
  FOREACH(ENTITY, e, el) {
    remove_entity_type_stack(e);
  }
}

References ENTITY, FOREACH, and remove_entity_type_stack().

Referenced by RemoveDummyArguments(), and UseFormalArguments().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_LFs_from_C_comment()

void remove_LFs_from_C_comment

(

int

extra_LF

)

Remove "extra_LF" trailing LF from C_current_comment if they can be found at the end of the comment string.

Parameters

extra_LF

xtra_LF

Definition at line 1398 of file clexer.c.

{
  if(!token_has_been_seen_p && C_current_comment != string_undefined) {
    int l = strlen(C_current_comment);
    int c = 0;
    char * p = C_current_comment+l-1;
    pips_debug(3,"begin: %s\n", C_current_comment);
    // pips_assert("The comment string is longer than the number of LF to remove\n",
    //        extra_LF<=l);
    if(extra_LF<=l) {
      while(c<extra_LF && *p=='\n') {
         c++;
         *p = '\000';
         p--;
      }
      if(c==extra_LF) { // We are fine
        ;
      }
      else {
        // Should be a pips_internal_warning()
        pips_user_warning("%d extraneous LF left in comment\n", extra_LF-c);
      }
    }
    pips_debug(3,"end: %s\n", C_current_comment);
  }
}

RemoveDummyArguments()

void RemoveDummyArguments	(	entity	f,
		list	refs
	)

To chase formals in type declarations.

If f has dummy formal parameters, replace them by standard formal parameters

make a list of formal dummy parameters

Since the compilation order is not known, the standard formal parameters may already exist and they should not be removed.

Update the "dummy" field of the "parameter" data structure

This special case could be ignored and handled like the next one to avoid cut-and-past and/or the definition of a new function.

no dummy naming information available as in foo(int);

FI: just in case?

Remore the dummy formals from f's declaration list (and from the symbol table?) but keep all pointers towards them in the declarations as in "void foo(n,a[n])"

FI: The storage might point to another dummy argument (although it should not)

Let's hope there are no other pointers towards dummy formal parameters

No, there may be occurences due to dependent types.

Parameters

refs

efs

Definition at line 2224 of file util.c.

{
  value fv = entity_initial(f);
 
  pips_assert("The function value is defined", !value_undefined_p(fv));
  pips_assert("The entity has a functional type", type_functional_p(entity_type(f)));
  pips_assert("The entity is not a typedef", !typedef_entity_p(f));
 
  if(!value_undefined_p(fv) && !value_intrinsic_p(fv)) {
    code fc = value_code(fv);
    list dl = code_declarations(fc);
    list cd = list_undefined;
    list formals = NIL;
    type ft = entity_type(f);
    list fp = functional_parameters(type_functional(ft));
    list cformals = list_undefined;
    list cfp = list_undefined;
    int nformals=-1;
    int nfp = gen_length(fp);
 
    pips_assert("the value is code", value_code_p(fv));
 
    /* make a list of formal dummy parameters */
    for(cd = dl; !ENDP(cd); POP(cd)) {
      entity v = ENTITY(CAR(cd));
      if(entity_formal_p(v)) {
        pips_debug(8, "Formal dummy parameter: \"%s\"\n", entity_name(v));
        /* Since the compilation order is not known, the standard
           formal parameters may already exist and they should not be
           removed. */
        if(dummy_parameter_entity_p(v))
          formals = gen_nconc(formals, CONS(ENTITY, v, NIL));
      }
    }
    nformals = gen_length(formals);
 
    /* Update the "dummy" field of the "parameter" data structure */
 
    if(nformals==nfp) {
      /* This special case could be ignored and handled like the next
         one to avoid cut-and-past and/or the definition of a new
         function. */
      for(cformals=formals, cfp = fp; !ENDP(cfp); POP(cformals), POP(cfp)) {
        parameter p = PARAMETER(CAR(cfp));
        entity ep = ENTITY(CAR(cformals));
          dummy d = parameter_dummy(p);
 
          if(dummy_identifier_p(d)) {
            entity oep = dummy_identifier(d);
 
            MAP(REFERENCE, r, {
              entity v = reference_variable(r);
 
              if(v==oep) {
                pips_debug(8, "Reference to \"\%s\" now refers \"\%s\"\n",
                           entity_name(oep), entity_name(ep));
                reference_variable(r) = ep;
              }
            }, refs);
          }
 
        update_dummy_parameter(p, ep);
      }
    }
    else if(nformals>0) {
      int i = -1;
      for(cfp=fp, i= 1;!ENDP(cfp); POP(cfp), i++) {
        entity ep = find_ith_parameter(f,i);
        if(!entity_undefined_p(ep)) {
          parameter p = PARAMETER(CAR(cfp));
          dummy d = parameter_dummy(p);
 
          if(dummy_identifier_p(d)) {
            entity oep = dummy_identifier(d);
 
            MAP(REFERENCE, r, {
              entity v = reference_variable(r);
 
              if(v==oep) {
                pips_debug(8, "Reference to \"\%s\" now refers \"\%s\"\n",
                           entity_name(oep), entity_name(ep));
                reference_variable(r) = ep;
              }
            }, refs);
          }
 
          update_dummy_parameter(p, ep);
        }
      }
    }
    else {
      /* no dummy naming information available as in foo(int); */
      ;
    }
 
    if(true) {
 
      /* FI: just in case? */
      remove_entity_type_stacks(formals);
 
      /* Remore the dummy formals from f's declaration list (and from
         the symbol table?) but keep all pointers towards them in the
         declarations as in "void foo(n,a[n])" */
      for(cd = formals; !ENDP(cd); POP(cd)) {
        entity p = ENTITY(CAR(cd));
        //type pt = entity_type(p);
        //storage ps = entity_storage(p);
        //formal pfs = storage_formal(ps);
 
        pips_debug(8, "Formal dummy parameter \"%s\" is removed from declarations\n",
                   entity_name(p));
 
        //clean_up_dummy_parameter_type(pt, formals);
        gen_remove(&code_declarations(fc), (void *) p);
 
        /* FI: The storage might point to another dummy argument
           (although it should not) */
        //formal_function(pfs) = entity_undefined;
        /* Let's hope there are no other pointers towards dummy formal parameters */
        /* No, there may be occurences due to dependent types. */
        //free_entity(p);
      }
    }
    gen_free_list(formals);
  }
}

References CAR, code_declarations, CONS, dummy_identifier, dummy_identifier_p, dummy_parameter_entity_p(), ENDP, ENTITY, entity_formal_p(), entity_initial, entity_name, entity_type, entity_undefined_p, f(), find_ith_parameter(), functional_parameters, gen_free_list(), gen_length(), gen_nconc(), gen_remove(), list_undefined, MAP, NIL, PARAMETER, parameter_dummy, pips_assert, pips_debug, POP, REFERENCE, reference_variable, remove_entity_type_stacks(), type_functional, type_functional_p, typedef_entity_p(), update_dummy_parameter(), value_code, value_code_p, value_intrinsic_p, and value_undefined_p.

Referenced by UpdateEntity().

Here is the call graph for this function:

Here is the caller graph for this function:

RemoveFromExterns()

void RemoveFromExterns

(

entity

e

)

This may happen when functional arguments are dealt with

Definition at line 2884 of file util.c.

{
  entity f = get_current_module_entity();
  if(!entity_undefined_p(f)) {
    code fc = value_code(entity_initial(f));
 
    gen_remove(&code_externs(fc), (void *) e);
  }
  else {
    /* This may happen when functional arguments are dealt with */
    c_parser_user_warning("The C parser should not execute this call.\n");
  }
}

References c_parser_user_warning, code_externs, entity_initial, entity_undefined_p, f(), gen_remove(), get_current_module_entity(), and value_code.

Referenced by actual_c_parser(), and FindOrCreateCurrentEntity().

Here is the call graph for this function:

Here is the caller graph for this function:

RenameFunctionEntity()

entity RenameFunctionEntity

(

entity

oe

)

Rename function oe if necessary.

The function name may be wrong because not enough information was available when it was created by FindOrCreateCurrentEntity().

oe must be a function and not a pointer to a function

oe should be added to the declarations of the current block

A C function or intrinsics name should include no scope information. But a functional typedef should.

In fact, we'd like to know if it is found before we create it...

FI I do not understand how formal parameters could be declared before

We assume oe is not already part of a declaration list since its formal parameters have been taken care of

Parameters

oe

e

Definition at line 1556 of file util.c.

{
  entity ne = oe;
  string oen = entity_name(oe);
  const char* oeln = entity_local_name(oe);
  string sn = local_name_to_scope(oeln);
  //type oet = entity_type(oe);
 
  /* A C function or intrinsics name should include no scope
     information. But a functional typedef should. */
  if(!typedef_entity_p(oe) && !empty_string_p(sn)) {
    if(strchr(oen, MODULE_SEP)!=NULL) {
      //string mn = entity_module_name(ne);
      const char * ln = entity_user_name(ne);
      value voe = entity_initial(oe);
      stack s = get_from_entity_type_stack_table(oe);
      stack ns = stack_copy(s);
 
      /* In fact, we'd like to know if it is found before we create it... */
      ne = FindEntity(TOP_LEVEL_MODULE_NAME, ln);
      if(entity_undefined_p(ne)) {
        ne = FindOrCreateEntity(TOP_LEVEL_MODULE_NAME, ln );
        entity_type(ne) = copy_type(entity_type(oe));
        entity_storage(ne) = copy_storage(entity_storage(oe));
        /* FI I do not understand how formal parameters could be declared before */
        if(value_undefined_p(voe) || value_unknown_p(voe))
          entity_initial(ne) = make_value(is_value_code,
                                          make_code(NIL,strdup(""), make_sequence(NIL),NIL, make_language_c()));
        else {
          list dl = list_undefined;
          entity_initial(ne) = copy_value(entity_initial(oe));
 
          dl = code_declarations(value_code(entity_initial(ne)));
          FOREACH(ENTITY, v, dl) {
            storage s = entity_storage(v);
            if(storage_formal_p(s)) {
              formal fs = storage_formal(s);
              formal_function(fs) = ne;
            }
          }
        }
        put_to_entity_type_stack_table(ne, ns);
      }
 
      pips_debug(1, "entity %s renamed %s\n", entity_name(oe), entity_name(ne));
 
      /* We assume oe is not already part of a declaration list since
         its formal parameters have been taken care of */
      gen_clear_tabulated_element((gen_chunkp)oe);
    }
  }
  free(sn);
  return ne;
}

References code_declarations, copy_storage(), copy_type(), copy_value(), empty_string_p(), ENTITY, entity_initial, entity_local_name(), entity_name, entity_storage, entity_type, entity_undefined_p, entity_user_name(), FindEntity(), FindOrCreateEntity(), FOREACH, formal_function, free(), gen_clear_tabulated_element(), get_from_entity_type_stack_table(), is_value_code, list_undefined, local_name_to_scope(), make_code(), make_language_c(), make_sequence(), make_value(), MODULE_SEP, NIL, pips_debug, put_to_entity_type_stack_table(), stack_copy(), storage_formal, storage_formal_p, strdup(), TOP_LEVEL_MODULE_NAME, typedef_entity_p(), value_code, value_undefined_p, and value_unknown_p.

Here is the call graph for this function:

reset_C_comment()

void reset_C_comment

(

bool

is_compilation_unit_p

)

reset and reset_error should be handled differently

Comments in the compilation unit are lost because they are related only to declarations and because comments on declarations are lost. Also, comments located at the end of a block are lost, as we do not generate an extra NOP to carry them.

pips_internal_error("Comments stack is not empty\n");

Parameters

is_compilation_unit_p

s_compilation_unit_p

Definition at line 1450 of file clexer.c.

{
  if(!string_undefined_p(C_current_comment)) {
    free(C_current_comment);
    C_current_comment = string_undefined;
  }
  /* Comments in the compilation unit are lost because they are related only to
     declarations and because comments on declarations are lost. Also, comments
     located at the end of a block are lost, as we do not generate an extra NOP to carry them. */
  if(!is_compilation_unit_p && !comments_empty_p()) {
    int count = 0;
    pips_user_warning("Comments stack is not empty (only meaningful comments are shown):\n");
    while(!comments_empty_p()) {
      string c = comments_pop();
      count++;
      if(strcmp(c, "\n")!=0)
        fprintf(stderr, "Element %d: \"%s\"\n", count, c);
      free(c);
    }
    /* pips_internal_error("Comments stack is not empty\n"); */
  }
  clear_C_comment();
  free_comments_stack();
  bracket_depth = -1;
  token_has_been_seen_p = false;
}

reset_c_parser_current_input_file_name()

void reset_c_parser_current_input_file_name

(

void

)

Definition at line 73 of file c_parser.c.

{
  // Could check that it is defined on entry
  if(string_undefined_p(c_parser_current_file_name))
    pips_internal_error("c_parser_current_file_name no initialized.\n");
  c_parser_current_file_name = string_undefined;
}

References c_parser_current_file_name, pips_internal_error, string_undefined, and string_undefined_p.

Referenced by actual_c_parser().

Here is the caller graph for this function:

reset_c_parser_current_user_input_file_name()

void reset_c_parser_current_user_input_file_name

(

void

)

Definition at line 104 of file c_parser.c.

{
  // Could check that it is defined on entry
  if(string_undefined_p(c_parser_current_user_input_file_name))
    pips_internal_error("c_parser_current_user_input_file_name no initialized.\n");
  c_parser_current_user_input_file_name = string_undefined;
}

References c_parser_current_user_input_file_name, pips_internal_error, string_undefined, and string_undefined_p.

Referenced by actual_c_parser().

Here is the caller graph for this function:

reset_c_parser_scope_stack()

void reset_c_parser_scope_stack

(

void

)

Definition at line 522 of file cyacc.tab.c.

 {
   if(c_parser_scope_stack != stack_undefined) {
     if(stack_empty_p(c_parser_scope_stack)) {
       stack_free(&c_parser_scope_stack);
       c_parser_scope_stack = stack_undefined;
     }
     else {
       // pips_internal_error? Could be a bad input C file...
       pips_user_warning("Parser scope stack is not empty.\n");
     }
   }
   c_parser_scope_number = SCOPE_UNDEFINED;
   return;
 }

Reset_C_ReturnStatement()

void Reset_C_ReturnStatement

(

void

)

The return statement must be reset when it is used by the parser to add the return statement to the function body or when a parser error is encountered.

Definition at line 115 of file return.c.

{
  C_return_statement = statement_undefined;
  number_of_return_statements = -1;
  last_returned_value = list_undefined;
  last_return_value_assignment = statement_undefined;
  return_value_entity = entity_undefined;
  return_current_module = entity_undefined;
  //c_end_label = entity_undefined;
}

References C_return_statement, entity_undefined, last_return_value_assignment, last_returned_value, list_undefined, number_of_return_statements, return_current_module, return_value_entity, and statement_undefined.

Referenced by c_parser_error(), and FixCReturnStatements().

Here is the caller graph for this function:

reset_current_C_line_number()

void reset_current_C_line_number

(

void

)

Definition at line 1210 of file clexer.c.

{
  C_line_number = UNDEFINED_C_LINE_NUMBER;
  previous_C_line_number = UNDEFINED_C_LINE_NUMBER;
  c_lineno = FIRST_C_LINE_NUMBER;
  previous_c_lineno = UNDEFINED_C_LINE_NUMBER;
 
  if(!line_number_empty_p()) {
    pips_internal_error("Line number stack is not empty\n");
  }
  free_line_number_stack();
  free_absolute_line_number_stack();
}

reset_current_dummy_parameter_number()

void reset_current_dummy_parameter_number

(

void

)

Definition at line 144 of file util.c.

{current_dummy_parameter_number=0;}

References current_dummy_parameter_number.

Referenced by actual_c_parser(), and c_parser_error().

Here is the caller graph for this function:

reset_declaration_counter()

void reset_declaration_counter

(

void

)

Definition at line 492 of file cyacc.tab.c.

 {
   declaration_counter = 0;
 }

reset_entity_type_stack_table()

void reset_entity_type_stack_table

(

void

)

Definition at line 186 of file c_parser.c.

{
    HASH_MAP(k,v,stack_free((stack*)&v),entity_to_type_stack_table);
  hash_table_free(entity_to_type_stack_table);
  entity_to_type_stack_table = hash_table_undefined;
}

References entity_to_type_stack_table, HASH_MAP, hash_table_free(), hash_table_undefined, and stack_free().

Referenced by actual_c_parser(), c_parser_error(), and init_entity_type_storage_table().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_expression_comment()

void reset_expression_comment

(

void

)

we don't want an expression comment with new lines, it is disgracefull

Too bad. This should not happen, but it happens with comma expressions in header files

Definition at line 169 of file cyacc.tab.c.

{
  if(!string_undefined_p(expression_comment)) {
    /* Too bad. This should not happen, but it happens with comma
       expressions in header files */
    free(expression_comment);
    expression_comment = string_undefined;
  }
 
  expression_line_number = STATEMENT_NUMBER_UNDEFINED;
}

reset_preprocessor_line_analysis()

void reset_preprocessor_line_analysis

(

void

)

Definition at line 3592 of file util.c.

{
  buffer_initialized_p = false;
}

References buffer_initialized_p.

Referenced by actual_c_parser().

Here is the caller graph for this function:

reset_token_has_been_seen_p()

void reset_token_has_been_seen_p

(

void

)

Definition at line 1270 of file clexer.c.

{token_has_been_seen_p = false;}

ResetCurrentCompilationUnitEntity()

void ResetCurrentCompilationUnitEntity

(

bool

is_compilation_unit_parser

)

Let's redo the memory allocation for variables whose name has changed:-(

reset_entity_type_stack_table();

Parameters

is_compilation_unit_parser

s_compilation_unit_parser

Definition at line 349 of file util.c.

{
  /* Let's redo the memory allocation for variables whose name has changed:-(*/
  if(is_compilation_unit_parser)
    CCompilationUnitMemoryAllocation(get_current_module_entity());
  else
    CCompilationUnitMemoryReallocation(get_current_module_entity());
 
  /* reset_entity_type_stack_table(); */
  if (get_bool_property("PARSER_DUMP_SYMBOL_TABLE"))
    fprint_C_environment(stderr, get_current_module_entity());
  pips_debug(4,"Reset current module entity for compilation unit \"%s\"\n",
             get_current_module_name());
  reset_current_module_entity();
}

References CCompilationUnitMemoryAllocation(), CCompilationUnitMemoryReallocation(), fprint_C_environment(), get_bool_property(), get_current_module_entity(), get_current_module_name(), pips_debug, and reset_current_module_entity().

Referenced by actual_c_parser().

Here is the call graph for this function:

Here is the caller graph for this function:

ResetCurrentModule()

void ResetCurrentModule

(

void

)

Reset them to stack_undefined_p instead of STACK_NULL

Definition at line 125 of file statement.c.

{
  CModuleMemoryAllocation(get_current_module_entity());
  if (get_bool_property("PARSER_DUMP_SYMBOL_TABLE"))
    fprint_C_environment(stderr, get_current_module_entity());
  pips_debug(4,"Reset current module entity %s\n",get_current_module_name());
  reset_current_module_entity();
  stack_free(&SwitchGotoStack);
  stack_free(&SwitchControllerStack);
  stack_free(&LoopStack);
  stack_free(&BlockStack);
  /* Reset them to stack_undefined_p instead of STACK_NULL */
  SwitchGotoStack = stack_undefined;
  SwitchControllerStack = stack_undefined;
  LoopStack = stack_undefined;
  BlockStack = stack_undefined;
}

References BlockStack, CModuleMemoryAllocation(), fprint_C_environment(), get_bool_property(), get_current_module_entity(), get_current_module_name(), LoopStack, pips_debug, reset_current_module_entity(), stack_free(), stack_undefined, SwitchControllerStack, and SwitchGotoStack.

Here is the call graph for this function:

scope_to_block_scope()

string scope_to_block_scope

(

string

full_scope

)

Allocate a new string containing only block scope information.

Parameters

full_scope

ull_scope

Definition at line 268 of file cyacc.tab.c.

{
  string l_scope = strrchr(full_scope, BLOCK_SEP_CHAR);
  string f_scope = strchr(full_scope, MODULE_SEP);
  string block_scope = string_undefined;
 
  pips_debug(8, "full_scope = \"%s\"\n", full_scope);
 
  if(f_scope==NULL)
    f_scope = full_scope;
  else
    f_scope++;
 
  if(l_scope==NULL)
    block_scope = strdup("");
  else
    block_scope = gen_strndup0(f_scope, (unsigned) (l_scope-f_scope+1));
 
  pips_debug(8, "f_scope = \"%s\", l_scope = \"%s\"\n", f_scope, l_scope);
  pips_assert("block_scope is a scope", string_block_scope_p(block_scope));
 
  return block_scope;
}

ScopeStackSize()

int ScopeStackSize

(

void

)

Definition at line 366 of file cyacc.tab.c.

{
  return stack_size(ContextStack);
}

set_c_parser_current_input_file_name()

void set_c_parser_current_input_file_name

(

string

file_name

)

Parameters

file_name

ile_name

Definition at line 65 of file c_parser.c.

{
  // Could check that it is undefined on entry
  if(!string_undefined_p(c_parser_current_file_name))
    pips_internal_error("c_parser_current_file_name no initialized.\n");
  c_parser_current_file_name = file_name;
}

References c_parser_current_file_name, file_name, pips_internal_error, and string_undefined_p.

Referenced by actual_c_parser().

Here is the caller graph for this function:

set_c_parser_current_user_input_file_name()

void set_c_parser_current_user_input_file_name

(

string

file_name

)

Parameters

file_name

ile_name

Definition at line 96 of file c_parser.c.

{
  // Could check that it is undefined on entry
  if(!string_undefined_p(c_parser_current_user_input_file_name))
    pips_internal_error("c_parser_current_user_input_file_name no initialized.\n");
  c_parser_current_user_input_file_name = file_name;
}

References c_parser_current_user_input_file_name, file_name, pips_internal_error, and string_undefined_p.

Referenced by actual_c_parser().

Here is the caller graph for this function:

set_current_C_line_number()

void set_current_C_line_number

(

void

)

Initialize the user line number...

... and the absolute line number in the current file

The first line is used to indicate the line number in the user source file

Some check on it first? It should have been disallocated by reset_current_C_line_number()

Definition at line 1166 of file clexer.c.

{
  if (C_line_number == UNDEFINED_C_LINE_NUMBER) {
    /* Initialize the user line number... */
    C_line_number = FIRST_C_LINE_NUMBER;
    // Rely on preprocessor pragma lines, which are not always present
    // especially for code synthesized by PIPS...
    // C_line_number = UNDEFINED_C_LINE_NUMBER;
    previous_C_line_number = FIRST_C_LINE_NUMBER;
    /* ... and the absolute line number in the current file */
    c_lineno = FIRST_C_LINE_NUMBER;
    /* The first line is used to indicate the line number in the user 
     * source file
     */
    previous_c_lineno = FIRST_C_LINE_NUMBER + 1;
  }
  else
   pips_internal_error("C_line_number not resetted\n");
 
   C_line_increment = 1;
 
  /* Some check on it first? It should have been disallocated by reset_current_C_line_number() */
  make_line_number_stack();
  make_absolute_line_number_stack();
}

set_entity_initial()

void set_entity_initial	(	entity	v,
		expression	nie
	)

Be careful if the initial value has already been set.

Detect double definitions when possible

Take care of the special case of pointers to functions.

The compilation unit has already been scanned once for declarations. Double definitions are no surprise...

Generate initializations for pointers to functions and arrays of pointers to functions

A pointer to a function already has value code as initial value. We may not even know yet it's a pointer...

Parameters

nie

ie

Definition at line 3469 of file util.c.

{
  value oiv = entity_initial(v);
 
  if(!value_undefined_p(oiv) && value_unknown_p(oiv)) {
    free_value(oiv);
    entity_initial(v) = value_undefined;
    oiv = value_undefined;
  }
 
  if(!value_undefined_p(oiv)) {
    if(compilation_unit_p(get_current_module_name())) {
      /* The compilation unit has already
         been scanned once for
         declarations. Double definitions
         are no surprise...*/
      if(value_code_p(oiv)) {
      /* Generate initializations for pointers to functions and arrays
         of pointers to functions */
        code c = value_code(oiv);
        statement s = make_expression_statement(nie);
 
        code_initializations(c) = make_sequence(CONS(STATEMENT, s, NIL));
      }
    }
    else {
      type vt = entity_type(v);
      type uvt = type_undefined_p(vt)? type_undefined
        : ultimate_type(entity_type(v));
      if(!type_undefined_p(uvt) &&
         ((pointer_type_p(uvt) &&
           type_functional_p(basic_pointer(variable_basic(type_variable(uvt)))))
          || type_functional_p(uvt)) ) {
        /* A pointer to a function already has value code as initial
           value. We may not even know yet it's a pointer... */
        code c = value_code(oiv);
        statement s = make_expression_statement(nie);
 
        code_initializations(c) = make_sequence(CONS(STATEMENT, s, NIL));
        //c_parser_user_warning("The initialization of a function pointer is lost\n");
      }
      else {
        c_parser_user_warning(
          "double definition of initial"
          " value for variable \"%s\"", entity_name(v));
 
        // FI: I am not sure it so good to put any junk in any format in the
        // Warning file.  FC: Indeed:-)
 
        string initv = expression_to_string(nie);
        string currv;
        if(value_expression_p(oiv))
          currv = expression_to_string(value_expression(oiv));
        else
          asprintf(&currv, "value tag: %d", value_tag(entity_initial(v)));
 
        pips_user_warning("New initial value expression:\n%s"
                          "Current initial value:\n%s",
                          initv, currv);
        free(initv);
        free(currv);
        pips_internal_error("Scoping might be the reason.");
      }
    }
  }
 
  if(value_undefined_p(entity_initial(v)))
    entity_initial(v) = make_value_expression(nie);
}

References asprintf, basic_pointer, c_parser_user_warning, code_initializations, compilation_unit_p(), CONS, entity_initial, entity_name, entity_type, expression_to_string(), free(), free_value(), get_current_module_name(), make_expression_statement(), make_sequence(), make_value_expression(), NIL, pips_internal_error, pips_user_warning, pointer_type_p(), STATEMENT, type_functional_p, type_undefined, type_undefined_p, type_variable, ultimate_type(), value_code, value_code_p, value_expression, value_expression_p, value_tag, value_undefined, value_undefined_p, value_unknown_p, and variable_basic.

Referenced by freia_is_transpose_call().

Here is the call graph for this function:

Here is the caller graph for this function:

set_prettyprint_control_list_to_dummy()

void set_prettyprint_control_list_to_dummy

(

void

)

Definition at line 1084 of file statement.c.

{
  dummy_declaration_p = true;
}

References dummy_declaration_p.

set_prettyprint_control_list_to_extern()

void set_prettyprint_control_list_to_extern

(

void

)

Definition at line 1042 of file statement.c.

{
  extern_declaration_p = true;
}

References extern_declaration_p.

StackPop()

void StackPop

(

stack

OffsetStack

)

The OffsetStack is poped n times, where n is the number of formal arguments of the actual function.

Parameters

OffsetStack

ffsetStack

Definition at line 3450 of file util.c.

{
  int n = basic_int((basic) stack_head(OffsetStack));
  NStackPop(OffsetStack,n);
}

References basic_int, NStackPop(), OffsetStack, and stack_head().

Here is the call graph for this function:

StackPush()

void StackPush

(

stack

OffsetStack

)

The OffsetStack is pushed incrementally.

Parameters

OffsetStack

ffsetStack

Definition at line 3457 of file util.c.

{
  int i = basic_int((basic) stack_head(OffsetStack));
  stack_push((char *) make_basic_int(i+1),OffsetStack);
}

References basic_int, make_basic_int(), OffsetStack, stack_head(), and stack_push().

Here is the call graph for this function:

SubstituteDummyParameters()

void SubstituteDummyParameters	(	entity	f,
		list	el
	)

The copy could be avoided by substituting v->s with nv->s

Store type information. Might be useless.

Inherit any attribute you can

Parameters

el

l

Definition at line 2351 of file util.c.

{
  for(list cel=el; !ENDP(cel); POP(cel)) {
    entity v = ENTITY(CAR(cel));
    if(dummy_parameter_entity_p(v)) {
      const char* mn = entity_local_name(f);
      const char * ln = entity_user_name(v);
      entity nv = FindOrCreateEntity(mn, ln);
      stack s = get_from_entity_type_stack_table(v);
      /* The copy could be avoided by substituting v->s with nv->s */
      stack ns = stack_copy(s);
      ENTITY_(CAR(cel)) = nv;
 
      /* Store type information. Might be useless. */
      put_to_entity_type_stack_table(nv, ns);
      remove_entity_type_stack(v);
 
      /* Inherit any attribute you can */
      if(!type_undefined_p(entity_type(v)))
        entity_type(nv) = copy_type(entity_type(v));
      if(!value_undefined_p(entity_initial(v)))
        entity_initial(nv) = copy_value(entity_initial(v));
      if(!storage_undefined_p(entity_storage(v)))
        entity_storage(nv) = copy_storage(entity_storage(v));
    }
  }
}

References CAR, copy_storage(), copy_type(), copy_value(), dummy_parameter_entity_p(), ENDP, ENTITY, ENTITY_, entity_initial, entity_local_name(), entity_storage, entity_type, entity_user_name(), f(), FindOrCreateEntity(), get_from_entity_type_stack_table(), POP, put_to_entity_type_stack_table(), remove_entity_type_stack(), stack_copy(), storage_undefined_p, type_undefined_p, and value_undefined_p.

Here is the call graph for this function:

TakeDerivedEntities()

list TakeDerivedEntities

(

list

le

)

To simplify debugging

The list is stored there at line 2087 of cyacc.y (5 August 2009)

e->type==entity_domain

lres = gen_nconc(lres,ltmp);

The ltmp lists seem to be somehow shared as shown in ngspice/main.tpips. The previous implementation of the current function generated cyclic lists. The new implementation is incompatible with a proper memory management.

I do not understand what's done in c_syntax/cyacc.y. The trace obtained from C_syntax/ngspice01.c shows that the same derived entities appear several times when dummy structs and unions are embedded as in ngspice01.c

Parameters

le

e

Definition at line 3020 of file util.c.

{
  list lres = NIL;
 
  if(!ENDP(le)) { /* To simplify debugging */
 
    pips_debug(8, "Begin\n");
 
    ifdebug(8) {
      pips_debug(8, "Input entity list: ");
      print_entities(le);
      fprintf(stderr, "\n");
    }
 
    FOREACH (ENTITY, e, le) {
      /* The list is stored there at line 2087 of cyacc.y (5 August
         2009) */
      //list ltmp = (list) entity_initial(e);
      list sltmp = (list) entity_initial(e);
      if(!ENDP(sltmp)) {
        // pips_assert("sltmp has only one element", gen_length(sltmp)==1);
        // statement stmp = STATEMENT(CAR(sltmp));
        // list ltmp = statement_declarations(stmp);
        list ltmp = sltmp;
 
        //pips_assert("sltmp is a continue statement list",
        // continue_statements_p(sltmp));
        pips_assert("e is an entity",
                    check_entity(e) /* e->_type_==entity_domain*/ );
        pips_debug(8, "entity e: %s (%p)\n", entity_name(e), e);
 
        if (ltmp != NIL) {
          /* lres = gen_nconc(lres,ltmp);*/
          FOREACH(ENTITY, de, ltmp) {
 
            pips_assert("de is an entity", de->_type_==entity_domain);
            pips_debug(8, "entity de: %s (%p)\n", entity_name(de), de);
 
            if(!gen_in_list_p(de, lres)) {
              lres = gen_nconc(lres, CONS(ENTITY, de, NIL));
            }
          }
        }
      }
      /* The ltmp lists seem to be somehow shared as shown in
       * ngspice/main.tpips. The previous implementation of the
       * current function generated cyclic lists. The new
       * implementation is incompatible with a proper memory
       * management.
       *
       * I do not understand what's done in c_syntax/cyacc.y. The
       * trace obtained from C_syntax/ngspice01.c shows that the same
       * derived entities appear several times when dummy structs and
       * unions are embedded as in ngspice01.c
       */
      //gen_free_list(ltmp);
      entity_initial(e) = value_undefined;
    }
    pips_assert ("an acyclic list is generated", !gen_list_cyclic_p (lres));
 
    ifdebug(8) {
      pips_debug(8, "Output entity list: ");
      if(ENDP(lres)) {
        fprintf(stderr, "NIL\n");
      }
      else {
        print_entities(lres);
        fprintf(stderr, "\n");
      }
    }
 
    pips_debug(8, "End\n");
  }
 
  return lres;
}

References check_entity(), CONS, ENDP, ENTITY, entity_domain, entity_initial, entity_name, FOREACH, fprintf(), gen_in_list_p(), gen_list_cyclic_p(), gen_nconc(), ifdebug, NIL, pips_assert, pips_debug, print_entities(), and value_undefined.

Here is the call graph for this function:

update_C_comment()

void update_C_comment

(

string

a_comment

)

Add a comment to the current one.

Do not add LFs that appear within a statement

Do not concatenate two comments without a LF

Parameters

a_comment

_comment

Definition at line 1365 of file clexer.c.

{
  /* Do not add LFs that appear within a statement */
  bool is_LF_p = *a_comment=='\n' && *(a_comment+1)=='\000';
  if(!(token_has_been_seen_p && a_comment!=NULL
     && is_LF_p)) {
    string new_comment = string_undefined;
    // FI: seems to imply that concatenate accepts string_undefined as an argument...
    int l = string_undefined_p(C_current_comment)? 0 : strlen(C_current_comment);
    /* Do not concatenate two comments without a LF */
    if(l>0 && *(C_current_comment+l-1)!='\n' && !is_LF_p)
      new_comment = strdup(concatenate(C_current_comment, "\n", a_comment, NULL));
    else
      new_comment = strdup(concatenate(C_current_comment, a_comment, NULL));
 
    if (!string_undefined_p(C_current_comment))
      free(C_current_comment);
    C_current_comment = new_comment;
  }
  else {
    static int c = 0;
    c++;
    pips_debug(8, "LF ignored: %d\n", c++);
  }
 
  pips_debug(3,"update_C_comment %s\n",
              C_current_comment==string_undefined?
              "still undefined" : C_current_comment);
}

UpdateAbstractEntity()

void UpdateAbstractEntity	(	entity	e,
		stack	ContextStack
	)

Update the entity with final type, storage

tc must have variable type, add lq to its qualifiers

lse const void, void is not of type variable, store const where ????????? CParserError("Entity has qualifier but no type or is not variable type in the context?\n");

Use the type stack in entity_storage to create the final type for the entity

Parameters

ContextStack

ontextStack

Definition at line 2842 of file util.c.

{
  /* Update the entity with final type, storage */
 
  //stack s = (stack) entity_storage(e);
  stack s = get_from_entity_type_stack_table(e);
  type t = entity_type(e);
  c_parser_context context = stack_head(ContextStack);
  type tc = c_parser_context_type(context);
  type t1,t2;
  list lq = c_parser_context_qualifiers(context);
 
  pips_debug(3,"Update abstract entity %s\n",entity_name(e));
 
  if (lq != NIL)
    {
      /* tc must have variable type, add lq to its qualifiers */
      if (!type_undefined_p(tc) && type_variable_p(tc))
        variable_qualifiers(type_variable(tc)) = lq;
      /*else
        const void, void is not of type variable, store const where ?????????
        CParserError("Entity has qualifier but no type or is not variable type in the context?\n");*/
    }
 
  /************************* TYPE PART *******************************************/
 
  /* Use the type stack in entity_storage to create the final type for the entity*/
  t2 = UpdateType(t,tc);
 
  while (stack_size(s) > 1)
    {
      t1 = stack_pop(s);
      t2 = UpdateType(t1,t2);
    }
  entity_type(e) = t2;
 
  /************************* STORAGE PART *******************************************/
 
  entity_storage(e) = storage_undefined;
}

References c_parser_context_qualifiers, c_parser_context_type, ContextStack, entity_name, entity_storage, entity_type, get_from_entity_type_stack_table(), NIL, pips_debug, stack_head(), stack_pop(), stack_size(), storage_undefined, tc, type_undefined_p, type_variable, type_variable_p, UpdateType(), and variable_qualifiers.

Here is the call graph for this function:

UpdateArrayEntity()

void UpdateArrayEntity	(	entity	e,
		list	lq,
		list	le
	)

lq is for what ? e or le ????: lq should be for le

Parameters

lq	q
le	e

Definition at line 1514 of file util.c.

{
  type t = entity_type(e);
  pips_debug(3,"Update array entity %s\n",entity_name(e));
 
  /* lq is for what ? e or le ????: lq should be for le*/
  if (type_undefined_p(t))
    {
      pips_debug(3,"First array dimension\n");
      entity_type(e) =
        make_type_variable(make_variable(basic_undefined,
                                         CONS(DIMENSION,MakeDimension(le, lq),NIL),
                                         NIL));
    }
  else
    {
      pips_debug(3,"Next array dimension\n");
      if (type_variable_p(t))
        {
          variable v = type_variable(t);
          variable_qualifiers(v) = gen_nconc(variable_qualifiers(v),lq);
          variable_dimensions(v) =
            gen_nconc(variable_dimensions(v),
                      CONS(DIMENSION, MakeDimension(le, lq), NIL));
        }
      else
        {
          CParserError("Dimension for not variable type\n");
        }
    }
}

References basic_undefined, CONS, CParserError(), DIMENSION, entity_name, entity_type, gen_nconc(), make_type_variable(), make_variable(), MakeDimension(), NIL, pips_debug, type_undefined_p, type_variable, type_variable_p, variable_dimensions, and variable_qualifiers.

Here is the call graph for this function:

UpdateDerivedEntities()

void UpdateDerivedEntities	(	list	ld,
		list	le,
		stack	ContextStack
	)

Parameters

ld	d
le	e
ContextStack	ontextStack

Definition at line 3097 of file util.c.

{
  FOREACH (ENTITY, e, le) {
    UpdateDerivedEntity(ld,e,ContextStack);
  }
}

References ContextStack, ENTITY, FOREACH, and UpdateDerivedEntity().

Here is the call graph for this function:

UpdateDerivedEntity()

void UpdateDerivedEntity	(	list	ld,
		entity	e,
		stack	ContextStack
	)

Update the derived entity with final type and rom storage. If the entity has bit type, do not need to update its type

what about context qualifiers ?

What do we do for functional types for instance?

FI: I assume the qualifiers are carried by the result

What do we do for functional types for instance?

Although it should be popped from the stack, the current context seems to be used later in case of typedef, such as seen in decl24.c

Temporally put the list of struct/union entities defined in decl_psec_list to initial value of ent

Parameters

ld	d
ContextStack	ontextStack

Definition at line 2942 of file util.c.

{
  /* Update the derived entity with final type and rom storage.
     If the entity has bit type, do not need to update its type*/
  type t = entity_type(e);
  pips_debug(3,"Update derived entity %s\n",entity_name(e));
  if (!bit_type_p(t))
    {
      //stack s = (stack) entity_storage(e);
      stack s = get_from_entity_type_stack_table(e);
      c_parser_context context = stack_head(ContextStack);
      type tc = c_parser_context_type(context);
      type t1,t2;
      list ql = c_parser_context_qualifiers(context);
 
      /* what about context qualifiers ? */
      t2 = UpdateType(t,tc);
 
      while (stack_size(s) > 1)
        {
          t1 = stack_pop(s);
          t2 = UpdateType(t1,t2);
        }
      entity_type(e) = t2;
 
      if(!ENDP(ql)) {
        if(type_void_p(t2)) {
          type_void(t2) = ql;
        }
        else if(type_variable_p(t2)) {
          if(pointer_type_p(t2)) {
            // The qualifiers must be stored on the effective pointed type
            // type pt = type_to_final_pointed_type(t2);
            // type pt = type_to_pointed_type(t2);
            type pt = basic_pointer(variable_basic(type_variable(t2)));
            if(type_void_p(pt))
              type_void(pt) = ql;
            else if(type_variable_p(pt)) {
              // If pt is a typedef, the typedef is altered...
              variable_qualifiers(type_variable(pt)) = ql;
              //variable_qualifiers(type_variable(t2)) = ql;
            }
            else if(type_functional_p(pt)) {
              /* What do we do for functional types for instance? */
              /* FI: I assume the qualifiers are carried by the
                 result */
              functional f = type_functional(pt);
              type rt = functional_result(f);
              if(type_variable_p(rt))
          variable_qualifiers(type_variable(rt)) = ql;
              else
          pips_internal_error("???");
            }
            else {/* What do we do for functional types for instance? */
              // FI: I assume the qualifiers are carried by the result
              pips_internal_error("???");
            }
          }
          else {
            variable_qualifiers(type_variable(t2)) = ql;
          }
        }
        else
          pips_internal_error("unexpected type");
        /* Although it should be popped from the stack, the current
           context seems to be used later in case of typedef, such as
           seen in decl24.c */
        c_parser_context_qualifiers(context) = NIL;
      }
    }
  entity_storage(e) = make_storage_rom();
 
  /* Temporally put the list of struct/union entities defined in
     decl_psec_list to initial value of ent */
  entity_initial(e) = (value) ld;
 
}

References basic_pointer, bit_type_p(), c_parser_context_qualifiers, c_parser_context_type, ContextStack, ENDP, entity_initial, entity_name, entity_storage, entity_type, f(), functional_result, get_from_entity_type_stack_table(), make_storage_rom(), NIL, pips_debug, pips_internal_error, pointer_type_p(), stack_head(), stack_pop(), stack_size(), tc, type_functional, type_functional_p, type_variable, type_variable_p, type_void, type_void_p, UpdateType(), variable_basic, and variable_qualifiers.

Referenced by UpdateDerivedEntities().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateEntities()

void UpdateEntities	(	list	le,
		stack	ContextStack,
		stack	FormalStack,
		stack	FunctionStack,
		stack	OffsetStack,
		bool	is_external,
		bool	is_declaration
	)

Parameters

le	e
ContextStack	ontextStack
FormalStack	ormalStack
FunctionStack	unctionStack
OffsetStack	ffsetStack
is_external	s_external
is_declaration	s_declaration

Definition at line 2733 of file util.c.

{
  FOREACH(ENTITY, e, le) {
    if(!derived_entity_p(e))
      UpdateEntity(e,ContextStack,FormalStack,FunctionStack,OffsetStack,
                   is_external,is_declaration);
  }
}

References ContextStack, derived_entity_p(), ENTITY, FOREACH, FormalStack, FunctionStack, is_external, OffsetStack, and UpdateEntity().

Here is the call graph for this function:

UpdateEntity()

void UpdateEntity	(	entity	e,
		stack	ContextStack,
		stack	FormalStack,
		stack	FunctionStack,
		stack	OffsetStack,
		bool	is_external,
		bool	is_declaration
	)

Update the entity with final type, storage and initial value; and also (sometimes?) declare it at the module level.

Replace dummy arguments by formal arguments for functions

Generate the return variables for functions returning a result

And probably much more...

If e is an intrinsics, nothing should be done, unless you are in the compilation unit: but the intrinsic type has already been put aside in the type stack linked to the entity and destroyed

tc must have variable type, add lq to its qualifiers

lse const void, void is not of type variable, store const where ????????? CParserError("Entity has qualifier but no type or is not variable type in the context?\n");

Use the type stack in entity_storage to create the final type for the entity

The default type is int, or a function returning an int

FI: it might be a good idea to use the type "unknown" or a future type "default" to improve the prettyprinting by not adding implicit "int" declarations.

The default type is int

FI: This elseif branch is apparently useless because the probleme must be dealt with later in the parser

The default return type is int

FI: no longer true, I believe "this field is always pre-defined. It is temporarilly used to store a type. See cyacc.y rule direct-decl:"

FI: Intrinsic do not have formal named parameters in PIPS RI, however such parameters can be named in intrinsic declarations. Problem with Validation/C_syntax/memcof.c

|| type_variable_p(entity_type(function))

Storage does also matter for typedef (and function pointer)

How to access the information about the function type?

FI: This branch should never be executed

The entities for the type_variable is added to the current module and the declarations

It is too early to use extern_entity_p()

Keyword EXTERN has just been encountered

Yes, but this may have been already recognized in FindOrCreateCurrentEntity() and this may not imply the declaration as extern is another declaration of e has already been encountered.

To avoid multiple declarations

Too late to check that the first declaration did not include an initialization

The function should also added to the declarations

We are defining the current module entity

Test case C_syntax/function_name_conflict01.c

Unfortunately, an intrinsics cannot be redefined, just like a user function or subroutine after editing because intrinsics are not handled like user functions or subroutines. They are not added to the called_modules list of other modules, unless the redefining module is parsed FIRST. There is not mechanism in PIPS to control the parsing order.

Be careful if standard arguments are needed: replace the dummy parameters

FI: intrinsic may need to be processed here if they use dynamic typing, a.k.a. dependent types but they do not have a code value!

They cannot be removed in general because they may appear in declarations as in foo(int n, double a[n])

FI: I do not know if refs contains copies of references or just pointer to them

If e is a function pointer, check the storage of its formal parameters

Parameters

ContextStack	ontextStack
FormalStack	ormalStack
FunctionStack	unctionStack
OffsetStack	ffsetStack
is_external	s_external
is_declaration	s_declaration

Definition at line 2473 of file util.c.

{
  //stack s = (stack) entity_storage(e);
  stack s = get_from_entity_type_stack_table(e);
  type t = entity_type(e);
  c_parser_context context = stack_head(ContextStack);
  type tc = c_parser_context_type(context);
  type t1,t2;
  list lq = c_parser_context_qualifiers(context);
 
  pips_debug(3,"Update entity begins for \"%s\" with context %p\n", entity_name(e), context);
 
  /* If e is an intrinsics, nothing should be done, unless you are in
     the compilation unit: but the intrinsic type has already been
     put aside in the type stack linked to the entity and destroyed */
  if(false && intrinsic_entity_p(e) && !compilation_unit_p(get_current_module_name()))
    return;
 
  if (lq != NIL)
    {
      /* tc must have variable type, add lq to its qualifiers */
      if (!type_undefined_p(tc) && type_variable_p(tc))
        variable_qualifiers(type_variable(tc)) = lq;
      else if(type_void_p(tc))
        type_void(tc) = lq;
      /*else
        const void, void is not of type variable, store const where ?????????
        CParserError("Entity has qualifier but no type or is not variable type in the context?\n");*/
      c_parser_context_qualifiers(context) = NIL;
    }
 
  /************************* TYPE PART *******************************************/
 
  /* Use the type stack in entity_storage to create the final type for the entity*/
  //pips_assert("context type tc is defined", !type_undefined_p(tc));
  t2 = UpdateType(t,tc);
 
  if(t2!=t) {
    if(!stack_undefined_p(s)) {
      while (stack_size(s) > 1)
        {
          t1 = stack_pop(s);
          t2 = UpdateType(t1,t2);
        }
      if(type_undefined_p(t2)) {
        /* The default type is int, or a function returning an int */
        t2 = make_scalar_integer_type(DEFAULT_INTEGER_TYPE_SIZE);
      }
    }
    entity_type(e) = t2;
  }
 
  /* FI: it might be a good idea to use the type "unknown" or a
     future type "default" to improve the prettyprinting by not
     adding implicit "int" declarations. */
  if(type_undefined_p(entity_type(e))) {
    /* The default type is int */
    entity_type(e) =
      make_type_variable(make_variable(make_basic_int(DEFAULT_INTEGER_TYPE_SIZE),NIL,NIL));
  }
  /* FI: This elseif  branch is apparently useless because the
     probleme must be dealt with later in the parser */
  else if(type_functional_p(entity_type(e))) {
    functional f = type_functional(entity_type(e));
    type rt = functional_result(f);
    if(type_undefined_p(rt)) {
      /* The default return type is int */
      functional_result(f) =
        make_type_variable(make_variable(make_basic_int(DEFAULT_INTEGER_TYPE_SIZE),NIL,NIL));
    }
  }
  pips_assert("the entity type is defined", !type_undefined_p(entity_type(e)));
 
  /************************* STORAGE PART *******************************************/
 
  /* FI: no longer true, I believe "this field is always
     pre-defined. It is temporarilly used to store a type. See cyacc.y
     rule direct-decl:" */
 
 
  if (!storage_undefined_p(c_parser_context_storage(context))) {
    pips_debug(3,"Current storage context is %d\n",
               storage_tag(c_parser_context_storage(context)));
    entity_storage(e) = c_parser_context_storage(context);
    if(typedef_entity_p(e)) {
      AddToDeclarations(e,get_current_module_entity());
    }
  }
  else if (!stack_undefined_p(FormalStack) && (FormalStack != NULL)
           && !stack_empty_p(FormalStack)) {
    entity function = stack_head(FunctionStack);
    int offset = basic_int((basic) stack_head(OffsetStack));
    pips_debug(3,"Create formal variable %s for function %s with offset %d\n",
               entity_name(e),entity_name(function),offset);
    if(!value_intrinsic_p(entity_initial(function))) {
      /* FI: Intrinsic do not have formal named parameters in PIPS
         RI, however such parameters can be named in intrinsic
         declarations. Problem with Validation/C_syntax/memcof.c */
      AddToDeclarations(e,function);
    }
    if(dummy_parameter_entity_p(e)) {
      if(typedef_entity_p(function) /* || type_variable_p(entity_type(function)) */)
        /* Storage does also matter for typedef (and function pointer) */
        /* How to access the information about the function type? */
        entity_storage(e) = make_storage_rom();
      else
        entity_storage(e) = make_storage_formal(make_formal(function,offset));
    }
    else
      /* FI: This branch should never be executed */
      entity_storage(e) = make_storage_formal(make_formal(function,offset));
  }
  else if(type_variable_p(ultimate_type(entity_type(e)))) {
    /* The entities for the type_variable is added to the
       current module and the declarations*/
    entity function = get_current_module_entity();
 
    /* It is too early to use extern_entity_p() */
    //if(extern_entity_p(function, e))
    if(strstr(entity_name(e),TOP_LEVEL_MODULE_NAME) != NULL)
      if(!empty_scope_p(c_parser_context_scope(context))) {
        /* Keyword EXTERN has just been encountered */
        /* Yes,  but this may have been already recognized in
           FindOrCreateCurrentEntity() and this may not imply the
           declaration as extern is another declaration of e has
           already been encountered. */
        type et = ultimate_type(entity_type(e));
        if(type_functional_p(et))
          AddToExterns(e,function);
      }
 
    /* To avoid multiple declarations */
    list el = code_externs(value_code(entity_initial(function)));
    list dl = code_declarations(value_code(entity_initial(function)));
    if(!gen_in_list_p(e, el) && gen_in_list_p(e, dl)) {
      if(compilation_unit_entity_p(function)) {
        /* Too late to check that the first declaration did not
           include an initialization */
        c_parser_user_warning("Multiple declarations of variable \"%s\".\n",
                              entity_local_name(e));
      }
      else {
        user_log("Multiple declarations of variable \"%s\" in file\"%s\".\n",
                 entity_local_name(e), get_c_parser_current_input_file_name());
        CParserError("Illegal Input");
      }
    }
 
    AddToDeclarations(e,function);
 
    // Check here if already stored the value
    if(storage_undefined_p(entity_storage(e)))
      entity_storage(e) =
        MakeStorageRam(e,is_external,c_parser_context_static(context));
  }
  else if (type_functional_p(ultimate_type(entity_type(e)))){
    /* The function should also added to the declarations */
    if(!entity_undefined_p(get_current_module_entity()))
      AddToDeclarations(e, get_current_module_entity());
    else if(!intrinsic_entity_p(e)) {
      /* We are defining the current module entity */
      CreateReturnEntity(e);
    }
    else {
      /* Test case C_syntax/function_name_conflict01.c */
      c_parser_user_warning("Intrinsic %s redefined.\n"
                        "This is not supported by PIPS. Please rename \"%s\"\n",
                        entity_local_name(e), entity_local_name(e));
      /* Unfortunately, an intrinsics cannot be redefined, just like a user function
       * or subroutine after editing because intrinsics are not handled like
       * user functions or subroutines. They are not added to the called_modules
       * list of other modules, unless the redefining module is parsed FIRST.
       * There is not mechanism in PIPS to control the parsing order.
       */
      CParserError("Name conflict between a "
                   "function and an intrinsic\n");
    }
    entity_storage(e) = make_storage_rom();
  }
  else
    pips_assert("not implemented yet", false);
 
 
  /************************* INITIAL VALUE PART ****************************************/
  if(value_undefined_p(entity_initial(e))) {
    entity_initial(e) = make_value_unknown();
    //type t = entity_type(e);
    //type ut = ultimate_type(t);
    //if(type_functional(ut) && !typedef_entity_p(e))
    //  entity_initial(e) = make_value_code(make_code(NIL, strdup(""),make_sequence(NIL),NIL, make_language_c()));
    //else
    //  entity_initial(e) = make_value_unknown();
  }
 
  /* Be careful if standard arguments are needed: replace the dummy parameters */
  if(true || !is_declaration) {
    type t = entity_type(e);
    /* FI: intrinsic may need to be processed here if they use dynamic
       typing, a.k.a. dependent types but they do not have a code
       value!*/
    if(type_functional_p(t) && !typedef_entity_p(e) && !intrinsic_entity_p(e)) {
      if(is_declaration) {
        /* They cannot be removed in general because they may appear
           in declarations as in foo(int n, double a[n]) */
        value ev = entity_initial(e);
        code ec = value_code(ev);
        list cmdl = code_declarations(ec);
        list refs =  extract_references_from_declarations(cmdl);
 
        RemoveDummyArguments(e, refs);
 
          /* FI: I do not know if refs contains copies of references or just pointer to them */
        gen_free_list(refs);
      }
      else
        UseFormalArguments(e);
    }
  }
 
  /* If e is a function pointer, check the storage of its formal parameters */
  if(pointer_type_p(entity_type(e))) {
    type pt = basic_pointer(variable_basic(type_variable(entity_type(e))));
    if(type_functional_p(pt)) {
      code c = value_code(entity_initial(e));
 
      pips_assert("Although it's a pointer to a function, it has code...",
                  value_code_p(entity_initial(e)));
 
      if(code_undefined_p(c))
        pips_internal_error("Well, the code field is not defined yet...");
      else {
        list dl = code_declarations(c);
        list cl = list_undefined;
 
        for(cl=dl; !ENDP(cl); POP(cl)) {
          entity pe = ENTITY(CAR(cl));
 
          if(formal_parameter_p(pe)) {
            storage ps = entity_storage(pe);
 
            pips_debug(8, "Change storage from \"formal\" to \"rom\" for entity \"%s\"\n",
                       entity_name(pe));
            free_storage(ps);
            entity_storage(pe) = make_storage_rom();
          }
        }
      }
    }
  }
 
  pips_debug(3,"Update entity ends for \"%s\" with type \"%s\" and storage \"%s\"\n",
             entity_name(e),
             list_to_string(safe_c_words_entity(entity_type(e), NIL)),
             storage_to_string(entity_storage(e)));
 
  pips_assert("Current entity is consistent",entity_consistent_p(e));
}

References AddToDeclarations(), AddToExterns(), basic_int, basic_pointer, c_parser_context_qualifiers, c_parser_context_scope, c_parser_context_static, c_parser_context_storage, c_parser_context_type, c_parser_user_warning, CAR, code_declarations, code_externs, code_undefined_p, compilation_unit_entity_p(), compilation_unit_p(), ContextStack, CParserError(), CreateReturnEntity(), DEFAULT_INTEGER_TYPE_SIZE, dummy_parameter_entity_p(), empty_scope_p(), ENDP, ENTITY, entity_consistent_p(), entity_initial, entity_local_name(), entity_name, entity_storage, entity_type, entity_undefined_p, extract_references_from_declarations(), f(), formal_parameter_p(), FormalStack, free_storage(), functional_result, FunctionStack, gen_free_list(), gen_in_list_p(), get_c_parser_current_input_file_name(), get_current_module_entity(), get_current_module_name(), get_from_entity_type_stack_table(), intrinsic_entity_p(), is_external, list_to_string(), list_undefined, make_basic_int(), make_formal(), make_scalar_integer_type(), make_storage_formal(), make_storage_rom(), make_type_variable(), make_value_unknown(), make_variable(), MakeStorageRam(), NIL, offset, OffsetStack, pips_assert, pips_debug, pips_internal_error, pointer_type_p(), POP, RemoveDummyArguments(), safe_c_words_entity(), stack_empty_p(), stack_head(), stack_pop(), stack_size(), stack_undefined_p, storage_tag, storage_to_string(), storage_undefined_p, tc, TOP_LEVEL_MODULE_NAME, type_functional, type_functional_p, type_undefined_p, type_variable, type_variable_p, type_void, type_void_p, typedef_entity_p(), ultimate_type(), UpdateType(), UseFormalArguments(), user_log(), value_code, value_code_p, value_intrinsic_p, value_undefined_p, variable_basic, and variable_qualifiers.

Referenced by UpdateEntities().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateEntity2()

void UpdateEntity2	(	entity	,
		stack	,
		stack
	)

UpdateFinalPointer()

type UpdateFinalPointer	(	type	pt,
		type	t
	)

This function replaces the type pointed by the pointer pt (this can be a pointer of pointer,... so we have to go until the last one) by the type t

Parameters

pt

t

Definition at line 1427 of file util.c.

{
  /* This function replaces the type pointed by the pointer pt
     (this can be a pointer of pointer,... so we have to go until the last one)
     by the type t*/
  pips_debug(3,"Update final pointer type %d and %d\n", type_tag(pt), type_tag(t));
  if (type_variable_p(pt) && basic_pointer_p(variable_basic(type_variable(pt))))
    {
      type ppt = basic_pointer(variable_basic(type_variable(pt)));
      if (type_undefined_p(ppt))
        return make_type_variable(make_variable(make_basic_pointer(t),NIL,variable_qualifiers(type_variable(pt))));
      return UpdateFinalPointer(ppt,t);
    }
  CParserError("pt is not a pointer\n");
  return type_undefined;
}

References basic_pointer, basic_pointer_p, CParserError(), make_basic_pointer(), make_type_variable(), make_variable(), NIL, pips_debug, type_tag, type_undefined, type_undefined_p, type_variable, type_variable_p, UpdateFinalPointer(), variable_basic, and variable_qualifiers.

Referenced by UpdateFinalPointer().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateFunctionEntity()

void UpdateFunctionEntity	(	entity	oe,
		list	la
	)

The parser has found out that an entity is a function and partially sets its type.

The function may also be an intrinsics and be already fully defined.

If oe is an intrinsics, nothing should be done if we are compiling a function that redeclares intrinsics, because they are usually badly or at least only partly redeclared.

However, il should be updated if it's declared in a compilation unit as the header files may contain more up-to-date information than bootstrap. Or if its type has already been placed in the type stack and been undefined in the entity.

Note that a user function might have the same name as a C intrinsic. Then we are in trouble.

Is oe's name compatible with a function name? Well oe might be a pointer...

FI: We used never to bump into this case...

Parameters

oe	e
la	a

Definition at line 1614 of file util.c.

{
  type t = entity_type(oe);
  //string oeln = entity_local_name(oe);
  //string sn = local_name_to_scope(oeln);
  //entity ne = oe;
 
  pips_debug(3,"Update function entity \"%s\"\n",entity_name(oe));
 
  ifdebug(8) {
    pips_debug(8, "with type list la: ");
    if(ENDP(la)) {
      (void) fprintf(stderr, "empty list");
    }
    MAP(PARAMETER, at, {
      (void) fprintf(stderr, "%s, ", list_to_string(safe_c_words_entity(parameter_type(at), NIL)));
    }, la);
      (void) fprintf(stderr, "\n");
  }
 
  /* If oe is an intrinsics, nothing should be done if we are
     compiling a function that redeclares intrinsics, because they are
     usually badly or at least only partly redeclared.
 
     However, il should be updated if it's declared in a compilation unit
     as the header files may contain more up-to-date information than
     bootstrap. Or if its type has already been placed in the type
     stack and been undefined in the entity.
 
     Note that a user function might have the same name as a C
     intrinsic. Then we are in trouble.
  */
  if(intrinsic_entity_p(oe)
     && (!entity_undefined_p(get_current_module_entity())
         && !compilation_unit_p(get_current_module_name()))
     && !type_undefined_p(entity_type(oe)))
    return;
 
  /* Is oe's name compatible with a function name? Well oe might be a
     pointer... */
  // pips_assert("A function name does not include a scope", empty_string_p(sn));
 
  if (type_undefined_p(t))
    entity_type(oe) = make_type_functional(make_functional(la,type_undefined));
  else if(type_functional_p(t)) {
    /* FI: We used never to bump into this case... */
    functional f = type_functional(t);
    functional_parameters(f) = la;
  }
  else {
    pips_internal_error("What should be done here?");
    CParserError("This entity must have undefined type\n");
  }
 
  pips_debug(3,"Update function entity \"%s\" with type \"\%s\"\n",
             entity_name(oe),
             list_to_string(safe_c_words_entity(entity_type(oe), NIL)));
}

References compilation_unit_p(), CParserError(), ENDP, entity_name, entity_type, entity_undefined_p, f(), fprintf(), functional_parameters, get_current_module_entity(), get_current_module_name(), ifdebug, intrinsic_entity_p(), list_to_string(), make_functional(), make_type_functional(), MAP, NIL, PARAMETER, parameter_type, pips_debug, pips_internal_error, safe_c_words_entity(), type_functional, type_functional_p, type_undefined, and type_undefined_p.

Here is the call graph for this function:

UpdateParenEntity()

void UpdateParenEntity	(	entity	e,
		list	lq
	)

Parameters

lq

q

Definition at line 1368 of file util.c.

{
  type t = entity_type(e);
  pips_debug(3,"Update entity in parentheses \"%s\" with type \"%s\"\n",
             entity_name(e), safe_type_to_string(entity_type(e)));
  if (lq != NIL) {
    if (type_undefined_p(t))
      t = make_type_variable(make_variable(basic_undefined,list_undefined,lq));
    else {
      if (type_variable_p(t)) {
        variable v = type_variable(t);
        variable_qualifiers(v) = gen_nconc(variable_qualifiers(v),lq);
      }
      else {
        CParserError("Attributes for not variable type\n");
      }
    }
  }
}

References basic_undefined, CParserError(), entity_name, entity_type, gen_nconc(), list_undefined, make_type_variable(), make_variable(), NIL, pips_debug, safe_type_to_string(), type_undefined_p, type_variable, type_variable_p, and variable_qualifiers.

Here is the call graph for this function:

UpdatePointerEntity()

void UpdatePointerEntity	(	entity	e,
		type	pt,
		list	lq
	)

Make e an array of pointers whose type is this of pt

Make e a function returns a pointer

Parameters

pt	t
lq	q

Definition at line 1444 of file util.c.

{
  type t = entity_type(e);
  ifdebug(3) {
    list pdl = NIL;
    pips_debug(3,"Update pointer entity %s with type pt=\"%s\"\n",
               entity_name(e), list_to_string(c_words_entity(pt, NIL, &pdl)));
    gen_free_list(pdl);
  }
  if (type_undefined_p(t))
    {
      pips_debug(3,"Undefined entity type\n");
      entity_type(e) = pt;
      /*
      if(type_undefined_p(pt)) {
        type npt = make_type(is_type_variable,
                             make_variable(make_basic(is_basic_pointer, type_undefined),
                                           NIL, NIL));
        entity_type(e) = npt;
      }
      else if(type_variable_p(pt) && basic_pointer_p(variable_basic(type_variable(pt))))
        entity_type(e) = pt;
      else {
        type npt = make_type(is_type_variable,
                             make_variable(make_basic(is_basic_pointer, pt),
                                           NIL, NIL));
        entity_type(e) = npt;
      }
      */
 
      variable_qualifiers(type_variable(entity_type(e))) = gen_nconc(variable_qualifiers(type_variable(entity_type(e))),lq);
    }
  else
    {
      switch (type_tag(t)) {
      case is_type_variable:
        {
          /* Make e an array of pointers whose type is this of pt */
          variable v = type_variable(t);
          pips_debug(3,"Array of pointers\n");
          entity_type(e) = make_type_variable(make_variable(variable_basic(type_variable(pt)),
                                                            variable_dimensions(v),
                                                            gen_nconc(variable_qualifiers(v),lq)));
          break;
        }
      case is_type_functional:
        {
          /* Make e a function returns a pointer */
          functional f = type_functional(t);
          pips_debug(3,"Function returns a pointer \n");
          entity_type(e) =
            make_type_functional(make_functional(functional_parameters(f),pt));
          break;
        }
      default:
        {
          CParserError("Entity is neither an array of pointers nor a pointer to a function?\n");
        }
      }
    }
  ifdebug(3) {
    list pdl = NIL;
    pips_debug(3,"Ends with type \"%s\" for entity %s\n",
               list_to_string(c_words_entity(entity_type(e), NIL, &pdl)),
               entity_name(e));
    gen_free_list(pdl);
  }
 
}

References c_words_entity(), CParserError(), entity_name, entity_type, f(), functional_parameters, gen_free_list(), gen_nconc(), ifdebug, is_type_functional, is_type_variable, list_to_string(), make_functional(), make_type_functional(), make_type_variable(), make_variable(), NIL, pips_debug, type_functional, type_tag, type_undefined_p, type_variable, variable_basic, variable_dimensions, and variable_qualifiers.

Here is the call graph for this function:

UpdateType()

type UpdateType	(	type	t1,
		type	t2
	)

This function replaces the undefined field in t1 by t2.

If t1 is an array type and the basic of t1 is undefined, it is replaced by the basic of t2.

If t1 is a pointer type, if the pointed type is undefined it is replaced by t2.

If t1 is a functional type, if the result type of t1 is undefined, it is replaced by t2.

If t1 is a void type, then either t2 also is a void type or an error is raised.

The function is recursive.

FI: This function used to create sharing between t1 and t2, which creates problems when t2 is later freed. t1 may be updated and returned or a new type may be created.

This may happen when a type is implicitly declared as in "extern m[3];"

We used to use type_unknown when the type was implicit, but type_unknown does not let us store dimension information. We need here a new kind of basic, basic unknown or basic implicit. This would let us be more respectful of the source code, but requires a modification of the internal representation. It is mostly a prettyprint issue. See ticket

Basic pointer

t1 is already fully defined

Redundant update

Could be a pips internal error...

Parameters

t1	1
t2	2

Definition at line 1693 of file util.c.

{
  if (type_undefined_p(t1)) {
    if(!type_undefined_p(t2))
      return copy_type(t2);
    else
      return t2;
  }
 
  if(type_undefined_p(t2)) {
    /* This may happen when a type is implicitly declared as in
       "extern m[3];" */
    /* We used to use type_unknown when the type was implicit, but
       type_unknown does not let us store dimension information. We
       need here a new kind of basic, basic unknown or basic
       implicit. This would let us be more respectful of the source
       code, but requires a modification of the internal
       representation. It is mostly a prettyprint issue. See ticket
       225. */
    t2 = make_scalar_integer_type(DEFAULT_INTEGER_TYPE_SIZE);
  }
 
  switch (type_tag(t1))
    {
    case is_type_variable:
      {
        variable v = type_variable(t1);
        if (basic_undefined_p(variable_basic(v)))
          {
            pips_assert("type t2 is defined", !type_undefined_p(t2));
            if (type_variable_p(t2))
              return make_type_variable(make_variable(copy_basic(variable_basic(type_variable(t2))),
                                                      variable_dimensions(v),
                                                      gen_nconc(variable_qualifiers(v),
                                                                gen_full_copy_list(variable_qualifiers(type_variable(t2))))));
            CParserError("t1 is a variable type but not t2\n");
          }
        else
          {
            /* Basic pointer */
            if (basic_pointer_p(variable_basic(v)))
              {
                type pt = basic_pointer(variable_basic(v));
                return make_type_variable(make_variable(make_basic_pointer(UpdateType(pt,t2)),
                                                        variable_dimensions(v),
                                                        variable_qualifiers(v)));
              }
            else {
              /* t1 is already fully defined */
              if(type_equal_p(t1,t2))
                return t2;
              else if(overloaded_type_p(t1))
                return t2;
              else
                CParserError("This basic has an undefined field?\n");
            }
          }
        break;
      }
    case is_type_functional:
      {
        functional f = type_functional(t1);
        if (type_undefined_p(functional_result(f)))
          {
              type nt = type_undefined;
            if (type_undefined_p(t2))
              nt = make_type_unknown();
            else
              nt = copy_type(t2);
            return make_type_functional(make_functional(functional_parameters(f),nt));
          }
        return make_type_functional(make_functional(functional_parameters(f),UpdateType(functional_result(f),t2)));
      }
    case is_type_void:
      {
        if(type_void_p(t2)) {
          /* Redundant update */
          ;
        }
        else {
          /* Could be a pips internal error... */
          CParserError("void type to be updated by a non void type...\n");
        }
        return t1;
      }
    default:
      {
        CParserError("t1 has which kind of type?\n");
      }
    }
  return type_undefined;
}

References basic_pointer, basic_pointer_p, basic_undefined_p, copy_basic(), copy_type(), CParserError(), DEFAULT_INTEGER_TYPE_SIZE, f(), functional_parameters, functional_result, gen_full_copy_list(), gen_nconc(), is_type_functional, is_type_variable, is_type_void, make_basic_pointer(), make_functional(), make_scalar_integer_type(), make_type_functional(), make_type_unknown(), make_type_variable(), make_variable(), overloaded_type_p(), pips_assert, type_equal_p(), type_functional, type_tag, type_undefined, type_undefined_p, type_variable, type_variable_p, type_void_p, UpdateType(), variable_basic, variable_dimensions, and variable_qualifiers.

Referenced by UpdateAbstractEntity(), UpdateDerivedEntity(), UpdateEntity(), and UpdateType().

Here is the call graph for this function:

Here is the caller graph for this function:

UseDummyArguments()

void UseDummyArguments

(

entity

f

)

If f has regular formal parameters, destroy them.

make a list of formal parameters

Remove the formals from f's declaration list and from the symbol table

FI: The storage might point to another dummy argument (although it should not)

Let's hope there are no other pointers towards dummy formal parameters

Definition at line 2019 of file util.c.

{
  value fv = entity_initial(f);
 
  pips_assert("The function value is defined", !value_undefined_p(fv));
  pips_assert("The entity has a functional type", type_functional_p(entity_type(f)));
  pips_assert("The entity is not a typedef", !typedef_entity_p(f));
 
  if(!value_undefined_p(fv)) {
    code fc = value_code(fv);
    list dl = code_declarations(fc);
    list cd = list_undefined;
    list formals = NIL;
 
    pips_assert("the value is code", value_code_p(fv));
 
    /* make a list of formal parameters */
    for(cd = dl; !ENDP(cd); POP(cd)) {
      entity v = ENTITY(CAR(cd));
      if(entity_formal_p(v)) {
        pips_debug(8, "Formal parameter: \"%s\"\n", entity_name(v));
        formals = gen_nconc(formals, CONS(ENTITY, v, NIL));
      }
    }
 
    /* Remove the formals from f's declaration list and from the
       symbol table */
    for(cd = formals; !ENDP(cd); POP(cd)) {
      entity p = ENTITY(CAR(cd));
      storage ps = entity_storage(p);
      formal pfs = storage_formal(ps);
 
      gen_remove(&code_declarations(fc), (void *) p);
      /* FI: The storage might point to another dummy argument
         (although it should not) */
      formal_function(pfs) = entity_undefined;
      /* Let's hope there are no other pointers towards dummy formal parameters */
      //free_entity(p);
    }
    gen_free_list(formals);
  }
}

References CAR, code_declarations, CONS, ENDP, ENTITY, entity_formal_p(), entity_initial, entity_name, entity_storage, entity_type, entity_undefined, f(), formal_function, gen_free_list(), gen_nconc(), gen_remove(), list_undefined, NIL, pips_assert, pips_debug, POP, storage_formal, type_functional_p, typedef_entity_p(), value_code, value_code_p, and value_undefined_p.

Here is the call graph for this function:

UseFormalArguments()

void UseFormalArguments

(

entity

f

)

If f has dummy formal parameters, replace them by standard formal parameters.

make a list of formal dumy parameters; depending on the kind of function declaration, dummy formal parameters are used (new C function declaration style), or not (old C function declaration style).

FI: Maybe, it would be better to unify the use of summy formal parameter in the parser?

Is it a local function or global function?

mn = strdup(concatenate(entity_module_name(f),entity_local_name(f), NULL));

Remore the dummy formals from f's declaration list (and from the symbol table?) and replace them by equivalent regular formal parameters

Substitute p by new_p in the declaration references for cases such as "foo(n, double a[n])"

This only works if the refs list points to the actual references and not to copies...

sg: this test used to be if e == p, but it missed some cases because reference_variable may have been generated incorectly before using a TOP_LEVEL variable instead of the dummy

A substitution could be performed instead...

FI: The storage might point to another dummy argument (although it should not)

Let's hope there are no other pointers towards dummy formal parameters

Check substitution in formal parameter declarations

FI: just in case?

Do not free the dummy formal parameter variable as they are preserved in the dummy field for accurate prettyprinting

Definition at line 2063 of file util.c.

{
  value fv = entity_initial(f);
 
  pips_assert("The function value is defined", !value_undefined_p(fv));
  pips_assert("The entity has a functional type", type_functional_p(entity_type(f)));
  pips_assert("The entity is not a typedef", !typedef_entity_p(f));
 
  if(!value_undefined_p(fv)) {
    code fc = value_code(fv);
    list dl = module_all_declarations(f);
    list cd = list_undefined;
    list formals = NIL;
    string mn = string_undefined;
    // This is a minimal list of references. We need all references.
    //list refs1 =  extract_references_from_declarations(dl);
    list refs =  declaration_supporting_references(dl);
 
    ifdebug(8) {
      int l2 = gen_length(refs);
 
      pips_debug(8, "refs (%d elements):\n", l2);
      print_references(refs);
    }
 
    pips_assert("the value is code", value_code_p(fv));
 
    /* make a list of formal dumy parameters; depending on the kind of
       function declaration, dummy formal parameters are used (new C
       function declaration style), or not (old C function declaration
       style).
 
       FI: Maybe, it would be better to unify the use of summy formal
       parameter in the parser?
    */
    for(cd = dl; !ENDP(cd); POP(cd)) {
      entity v = ENTITY(CAR(cd));
      if(entity_formal_p(v)) {
        pips_debug(8, "Formal parameter: \"%s\"\n", entity_name(v));
        if(dummy_parameter_entity_p(v))
          formals = gen_nconc(formals, CONS(ENTITY, v, NIL));
        //pips_assert("v is a dummy parameter", dummy_parameter_entity_p(v));
      }
    }
 
    /* Is it a local function or global function? */
    if(top_level_entity_p(f))
      mn = strdup(entity_user_name(f));
    else
      /* mn = strdup(concatenate(entity_module_name(f),entity_local_name(f), NULL)); */
      mn = strdup(entity_local_name(f));
 
    /* Remore the dummy formals from f's declaration list (and from the
       symbol table?) and replace them by equivalent regular formal parameters */
    for(cd = formals; !ENDP(cd); POP(cd)) {
      entity p = ENTITY(CAR(cd));
      const char * pn = entity_user_name(p);
      entity new_p = entity_undefined;
      //storage ps = entity_storage(p);
      //formal pfs = storage_formal(ps);
 
      if(!stack_undefined_p(get_from_entity_type_stack_table(p))) {
        new_p = FindOrCreateEntity(mn, pn );
        entity_storage(new_p) = copy_storage(entity_storage(p));
        entity_type(new_p) = copy_type(entity_type(p));
        entity_initial(new_p) = copy_value(entity_initial(p));
        pips_debug(8, "Formal dummy parameter \"%s\" is replaced "
                   "by standard formal parameter \"%s\"\n",
                   entity_name(p), entity_name(new_p));
 
        /* Substitute p by new_p in the declaration references for cases
           such as "foo(n, double a[n])" */
        /* This only works if the refs list points to the actual
           references and not to copies... */
        FOREACH(REFERENCE, r, refs){
            entity e = reference_variable(r);
 
        /* sg: this test used to be if e == p, but it missed some cases
         * because reference_variable may have been generated incorectly before
         * using a TOP_LEVEL variable instead of the dummy */
            if(same_entity_lname_p(e,p)) { 
              reference_variable(r) = new_p;
              pips_debug(8, "reference %p to \"%s\" changed into reference to \"\%s\"\n",
                         r, entity_name(p), entity_name(new_p));
            }
        }
 
        /* A substitution could be performed instead...*/
        gen_remove(&code_declarations(fc), (void *) p);
        code_declarations(fc) = gen_nconc(code_declarations(fc), CONS(ENTITY, new_p,NIL));
 
        /* FI: The storage might point to another dummy argument
           (although it should not) */
        //formal_function(pfs) = entity_undefined;
        /* Let's hope there are no other pointers towards dummy formal parameters */
        //free_entity(p); // FI: we may use them in the type data structures in spite of the MAP on refs?
      }
    }
    gen_free_list(dl);
 
    ifdebug(1) {
      dl = module_all_declarations(f);
      /* Check substitution in formal parameter declarations */
      ifdebug(8) {
          pips_debug(8, "list of declared variables:\n");
          print_entities(dl);
          (void) fprintf(stderr, "\n");
      }
      refs =  declaration_supporting_references(dl);
      MAP(REFERENCE, r, {
          entity v = reference_variable(r);
          if(dummy_parameter_entity_p(v)) {
            pips_debug(8, "Substitution failed for reference %p and variable \"%s\"\n",
                       r, entity_name(v));
            pips_internal_error("Failed substitution");
          }
        }, refs);
      gen_free_list(dl);
    }
 
    /* FI: just in case? */
    remove_entity_type_stacks(formals);
 
    /* Do not free the dummy formal parameter variable as they are
       preserved in the dummy field for accurate prettyprinting */
    /*
    MAP(ENTITY, df, {
      free_entity(df);
    }, formals);
    */
 
    free(mn);
    gen_free_list(formals);
  }
}

References CAR, code_declarations, CONS, copy_storage(), copy_type(), copy_value(), declaration_supporting_references(), dummy_parameter_entity_p(), ENDP, ENTITY, entity_formal_p(), entity_initial, entity_local_name(), entity_name, entity_storage, entity_type, entity_undefined, entity_user_name(), f(), FindOrCreateEntity(), FOREACH, fprintf(), free(), gen_free_list(), gen_length(), gen_nconc(), gen_remove(), get_from_entity_type_stack_table(), ifdebug, list_undefined, MAP, module_all_declarations(), NIL, pips_assert, pips_debug, pips_internal_error, POP, print_entities(), print_references(), REFERENCE, reference_variable, remove_entity_type_stacks(), same_entity_lname_p(), stack_undefined_p, strdup(), string_undefined, top_level_entity_p(), type_functional_p, typedef_entity_p(), value_code, value_code_p, and value_undefined_p.

Referenced by UpdateEntity().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

AllocatableArea

entity AllocatableArea

extern

Definition at line 61 of file area.c.

BlockStack

stack BlockStack

extern

statement.c

statement.c

Definition at line 58 of file statement.c.

Referenced by c_parser_error(), InitializeBlock(), LinkInstToCurrentBlock(), MakeBlockIfInst(), MakeElseInst(), MakeEnddoInst(), MakeEndifInst(), PopBlock(), PushBlock(), and ResetCurrentModule().

c__flex_debug

int c__flex_debug

extern

c_char

int c_char

extern

c_debug

int c_debug

extern

c_in

FILE* c_in

extern

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

Modify src/Libs/c_syntax/c_syntax-local.h instead, to add your own modifications. header file built by cproto c_syntax-local.h

Definition at line 291 of file c_syntax.h.

c_leng

int c_leng

extern

clexer.c

C_line_increment

int C_line_increment

extern

from "clex.l"

from "clex.l"

The goal is to reconstruct the line number in the user file and not the line number in the preprocessed file.

This is performed in analyze_preprocessor_line() (util.c)

Definition at line 296 of file c_syntax.h.

Referenced by set_current_C_line_number().

c_lineno

int c_lineno

extern

the file read in by the c_lexer

Definition at line 293 of file c_syntax.h.

c_nerrs

int c_nerrs

extern

c_out

FILE* c_out

extern

Referenced by contrainte_copy(), contrainte_dup(), contraintes_copy(), and contraintes_dup().

c_text

char* c_text

extern

CalledModules

list CalledModules

extern

Definition at line 51 of file c_parser.c.

Referenced by actual_c_parser(), and AddToCalledModules().

compilation_unit_name

string compilation_unit_name

extern

cproto-generated files

c_parser.c

Definition at line 49 of file c_parser.c.

Referenced by actual_c_parser(), add_new_compilation_unit(), add_new_module_from_text(), build_real_resources(), compilation_unit_of_module(), CreateEntityFromLocalNameAndPrefix(), CreateMemberScope(), FindEntityFromLocalName(), FindEntityFromLocalNameAndPrefix(), FindOrCreateCurrentEntity(), get_current_compilation_unit_entity(), init_c_areas(), make_predefined_C_entities(), and MakeStorageRam().

compilation_unit_parser_is_running_p

bool compilation_unit_parser_is_running_p

extern

To pass down the information to functions used by the syntactical analyzer.

Definition at line 541 of file c_parser.c.

Referenced by actual_c_parser(), and analyze_preprocessor_line().

ContextStack

stack ContextStack

extern

Definition at line 117 of file c_parser.c.

Referenced by actual_c_parser(), c_parser_error(), EnterScope(), ExitScope(), GetContext(), GetContextCopy(), GetParentScope(), GetScope(), PopContext(), PushContext(), ScopeStackSize(), UpdateAbstractEntity(), UpdateDerivedEntities(), UpdateDerivedEntity(), UpdateEntities(), and UpdateEntity().

derived_counter

int derived_counter

extern

Definition at line 125 of file c_parser.c.

Referenced by actual_c_parser().

DynamicArea

entity DynamicArea

extern

These global variables are declared in ri-util/util.c.

These global variables are declared in ri-util/util.c.

functions for areas Four areas used to allocate variables which are not stored in a Fortran common. These areas are just like Fortran commons, but the dynamic area is the only non-static area according to Fortran standard. The heap and the stack area are used to deal with Fortran ANSI extensions and C, pointers and allocatable arrays, and adjustable arrays (VLA in C). The dynamic area is stack allocated by most compilers but could be statically allocated since the array sizes are known.

Areas are declared for each module. These four global variables are managed by the Fortran and C parsers and used to allocate variables in the current module. Note that the C parser uses more areas at the same time to cope with global variables.

Definition at line 57 of file area.c.

FormalStack

stack FormalStack

extern

Definition at line 119 of file c_parser.c.

Referenced by actual_c_parser(), c_parser_error(), FindOrCreateCurrentEntity(), UpdateEntities(), and UpdateEntity().

FunctionStack

stack FunctionStack

extern

Definition at line 118 of file c_parser.c.

Referenced by actual_c_parser(), c_parser_error(), FindOrCreateCurrentEntity(), GetFunction(), MakeParameterList(), PopFunction(), PushFunction(), UpdateEntities(), and UpdateEntity().

HeapArea

entity HeapArea

extern

Definition at line 59 of file area.c.

LabeledStatements

list LabeledStatements

extern

BlockStack is used to handle block scope.

Definition at line 60 of file statement.c.

Referenced by FindStatementFromLabel(), MakeCurrentModule(), MakeGotoStatement(), and MakeLabeledStatement().

loop_counter

int loop_counter

extern

Global counter.

Definition at line 124 of file c_parser.c.

Referenced by actual_c_parser().

LoopStack

stack LoopStack

extern

Definition at line 64 of file statement.c.

Referenced by c_parser_error(), MakeBreakStatement(), MakeCaseStatement(), MakeContinueStatement(), MakeCurrentModule(), MakeDefaultStatement(), MakeForloop(), MakeSwitchStatement(), MakeWhileLoop(), and ResetCurrentModule().

ModuleStatement

statement ModuleStatement

extern

Definition at line 53 of file c_parser.c.

Referenced by actual_c_parser(), CCompilationUnitMemoryAllocations(), and CModuleMemoryAllocation().

OffsetStack

stack OffsetStack

extern

Definition at line 120 of file c_parser.c.

Referenced by actual_c_parser(), c_parser_error(), StackPop(), StackPush(), UpdateEntities(), and UpdateEntity().

removable_extern_entities

list removable_extern_entities

extern

Definition at line 542 of file c_parser.c.

Referenced by actual_c_parser(), and CleanUpEntities().

StackArea

entity StackArea

extern

Definition at line 60 of file area.c.

StaticArea

entity StaticArea

extern

Definition at line 58 of file area.c.

StructNameStack

stack StructNameStack

extern

Definition at line 121 of file c_parser.c.

Referenced by actual_c_parser(), and c_parser_error().

SwitchControllerStack

stack SwitchControllerStack

extern

Definition at line 63 of file statement.c.

Referenced by c_parser_error(), MakeCaseStatement(), MakeCurrentModule(), and ResetCurrentModule().

SwitchGotoStack

stack SwitchGotoStack

extern

list of labeled statements of the current module

Definition at line 62 of file statement.c.

Referenced by c_parser_error(), MakeCaseStatement(), MakeCurrentModule(), MakeDefaultStatement(), MakeSwitchStatement(), and ResetCurrentModule().