c_syntax-local.h File Reference

#include "c_parser_private.h"

Include dependency graph for c_syntax-local.h:

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)

Variables
FILE *	c_in
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...

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 55 of file c_syntax-local.h.

CParserError

#define CParserError

(

m

)

c_parser_error(CURRENT_FUNCTION, m)

Definition at line 54 of file c_syntax-local.h.

FIRST_C_LINE_NUMBER

#define FIRST_C_LINE_NUMBER   (1)

Error handling.

Definition at line 51 of file c_syntax-local.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 41 of file c_syntax-local.h.

UNDEFINED_C_LINE_NUMBER

#define UNDEFINED_C_LINE_NUMBER   (-1)

Definition at line 52 of file c_syntax-local.h.

Function Documentation

c_error()

void c_error

(

char *

)

c_lex()

int c_lex

(

)

c_parse()

int c_parse

(

)

Referenced by actual_c_parser().

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;
 }

References c_parser_scope_stack, and stack_size().

Referenced by is_c_parser_keyword_typedef().

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);
}

References c_parser_scope_stack, and stack_empty_p().

Here is the call graph for this function:

c_reset_lex()

void c_reset_lex

(

void

)

Referenced by c_parser_error().

Here is the caller graph for this function:

c_wrap()

int c_wrap

(

void

)

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;
}

References count, and string_undefined.

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());
}

References C_current_comment, count, free(), pips_assert, pips_debug, string_undefined, and string_undefined_p.

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;
}

References empty_scope(), make_c_parser_context(), NIL, pips_debug, storage_undefined, and type_undefined.

Here is the call 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;
  }
}

References C_current_comment, C_line_number, character_occurences_in_string(), free(), pips_debug, string_undefined, and string_undefined_p.

Referenced by MakeBlock().

Here is the call graph for this function:

Here is the caller graph for this function:

error_reset_C_comment()

void error_reset_C_comment

(

bool

)

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();
}

References C_line_number, c_lineno, FIRST_C_LINE_NUMBER, previous_C_line_number, previous_c_lineno, and UNDEFINED_C_LINE_NUMBER.

Referenced by c_parser_error().

Here is the caller graph for this function:

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");
  }
}

References c_parser_context_qualifiers, c_parser_context_scope, c_parser_context_storage, c_parser_context_undefined_p, ContextStack, ENDP, free_c_parser_context(), pips_assert, pips_debug, pop_c_parser_scope_stack(), stack_empty_p(), stack_head(), stack_pop(), storage_undefined_p, and string_undefined_p.

Here is the call 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;
 }

References c_parser_scope_number, c_parser_scope_stack, SCOPE_UNDEFINED, stack_free(), and stack_undefined.

Referenced by c_parser_error().

Here is the call graph for this function:

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;
 }

References c_parser_scope_stack, c_parser_scope_stack_empty_p(), stack_head(), and string_undefined.

Referenced by c_parser_put_new_typedef(), and is_c_parser_keyword_typedef().

Here is the call graph for this function:

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;
 }

References c_parser_scope_stack, and stack_nth().

Referenced by is_c_parser_keyword_typedef().

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;
}

References C_current_comment, strdup(), and string_undefined.

Referenced by ExpressionToStatement(), MakeCaseStatement(), MakeDefaultStatement(), and MakeGotoStatement().

Here is the call graph for this function:

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;
}

References C_line_number, c_lineno, previous_C_line_number, and previous_c_lineno.

Referenced by c_parser_error(), c_parser_user_warning_alist(), ExpressionToStatement(), FindEntityFromLocalNameAndPrefix(), MakeForloop(), MakeGotoStatement(), and MakeWhileLoop().

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;
 }

References declaration_counter.

Referenced by set_current_dummy_parameter_number().

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;
}

References previous_C_line_number.

Referenced by c_parser_user_warning_alist().

Here is the caller graph for this function:

get_previous_c_lineno()

int get_previous_c_lineno

(

void

)

Definition at line 1115 of file clexer.c.

{
  return previous_c_lineno;
}

References previous_c_lineno.

Referenced by c_parser_user_warning_alist().

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;
}

References c_parser_context_undefined, ContextStack, pips_debug, pips_internal_error, stack_empty_p(), stack_head(), and stack_size().

Referenced by FindOrCreateCurrentEntity().

Here is the call graph for this function:

Here is the caller graph for this function:

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;
}

References c_parser_context_scope, ContextStack, copy_c_parser_context(), pips_debug, stack_head(), and stack_size().

Here is the call graph for this function:

GetFunction()

entity GetFunction

(

void

)

cproto workaround

cyacc.tab.c

from "cyacc.y"

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

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

References f(), FunctionStack, and stack_head().

Here is the call graph for this function:

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;
}

References c_parser_context_scope, ContextStack, stack_empty_p(), stack_nth(), and stack_size().

Referenced by FindEntityFromLocalNameAndPrefix().

Here is the call graph for this function:

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;
}

References c_parser_context_scope, ContextStack, stack_empty_p(), and stack_head().

Referenced by CreateEntityFromLocalNameAndPrefix(), CreateMemberScope(), and FindEntityFromLocalNameAndPrefix().

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;
}

References bracket_depth, C_current_comment, pips_internal_error, STACK_NULL_P, stack_undefined_p, string_undefined_p, and token_has_been_seen_p.

Referenced by actual_c_parser().

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);
 }

References c_parser_scope_number, c_parser_scope_stack, pips_assert, stack_make(), stack_undefined_p, and string_domain.

Referenced by actual_c_parser().

Here is the call graph for this function:

Here is the caller graph for this function:

InitScope()

void InitScope

(

void

)

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

{
  C_scope_identifier = -1;
}

References C_scope_identifier.

Referenced by actual_c_parser().

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;
}

References BLOCK_SEP_CHAR, pips_assert, pips_debug, string_block_scope_p(), and string_undefined.

Referenced by FindEntityFromLocalNameAndPrefixAndScope(), and FindOrCreateEntityFromLocalNameAndPrefixAndScope().

Here is the call graph for this function:

Here is the caller graph for this function:

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;
 }

References c_parser_scope_stack, and stack_pop().

Here is the call 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;
}

References get_current_C_line_number(), pips_debug, and string_undefined_p.

Referenced by MakeForloop().

Here is the call graph for this function:

Here is the caller graph for this function:

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;
}

References c_lineno.

Referenced by MakeForloop().

Here is the caller graph for this function:

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));
  }
}

References c_parser_context_scope, ContextStack, pips_debug, stack_empty_p(), stack_head(), stack_pop(), and stack_size().

Here is the call graph for this function:

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);
}

References get_current_C_comment(), get_current_C_line_number(), pips_debug, and string_undefined_p.

Here is the call graph for this function:

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);
}

References c_lineno, and get_current_C_line_number().

Here is the call graph for this function:

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;
 }

References asprintf, c_parser_scope_number, c_parser_scope_stack, stack_push(), and string_undefined.

Here is the call 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));
}

References c_parser_context_scope, ContextStack, pips_debug, stack_push(), and stack_size().

Here is the call 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);
  }
}

References C_current_comment, pips_debug, pips_user_warning, string_undefined, and token_has_been_seen_p.

Referenced by analyze_preprocessor_line().

Here is the caller 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;
}

References bracket_depth, C_current_comment, clear_C_comment(), count, fprintf(), free(), pips_user_warning, string_undefined, string_undefined_p, and token_has_been_seen_p.

Referenced by actual_c_parser(), and c_parser_error().

Here is the call graph for this function:

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;
 }

References c_parser_scope_number, c_parser_scope_stack, pips_user_warning, SCOPE_UNDEFINED, stack_empty_p(), stack_free(), and stack_undefined.

Referenced by actual_c_parser().

Here is the call graph for this function:

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();
}

References C_line_number, c_lineno, FIRST_C_LINE_NUMBER, pips_internal_error, previous_C_line_number, previous_c_lineno, and UNDEFINED_C_LINE_NUMBER.

Referenced by actual_c_parser().

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;
 }

References declaration_counter.

Referenced by actual_c_parser(), and c_parser_error().

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;
}

References expression_comment, expression_line_number, free(), STATEMENT_NUMBER_UNDEFINED, string_undefined, and string_undefined_p.

Referenced by actual_c_parser(), and c_parser_error().

Here is the call graph for this function:

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;}

References token_has_been_seen_p.

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;
}

References BLOCK_SEP_CHAR, gen_strndup0(), MODULE_SEP, pips_assert, pips_debug, strdup(), string_block_scope_p(), and string_undefined.

Referenced by constant_memory_access_path_to_location_name(), CreateEntityFromLocalNameAndPrefix(), CreateMemberScope(), FindEntityFromLocalNameAndPrefix(), and FindOrCreateCurrentEntity().

Here is the call graph for this function:

Here is the caller graph for this function:

ScopeStackSize()

int ScopeStackSize

(

void

)

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

{
  return stack_size(ContextStack);
}

References ContextStack, and stack_size().

Referenced by FindEntityFromLocalNameAndPrefix().

Here is the call graph for this function:

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();
}

References C_line_increment, C_line_number, c_lineno, FIRST_C_LINE_NUMBER, pips_internal_error, previous_C_line_number, previous_c_lineno, and UNDEFINED_C_LINE_NUMBER.

Referenced by actual_c_parser().

Here is the caller 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);
}

References C_current_comment, concatenate(), free(), pips_debug, strdup(), string_undefined, string_undefined_p, and token_has_been_seen_p.

Here is the call graph for this function:

Variable Documentation

AllocatableArea

entity AllocatableArea

extern

Definition at line 61 of file area.c.

c_in

FILE * c_in

extern

Definition at line 291 of file c_syntax.h.

Referenced by __memchr(), actual_c_parser(), contrainte_copy(), contrainte_dup(), contraintes_copy(), contraintes_dup(), controlize_list_1(), rawmemchr(), statement_arrows(), strchrnul(), uns_rwt(), and unstructured_to_direct_declarations().

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 analyze_preprocessor_line().

c_lineno

int c_lineno

extern

the file read in by the c_lexer

Definition at line 293 of file c_syntax.h.

Referenced by c_parser_user_warning_alist(), error_reset_current_C_line_number(), get_current_C_line_number(), pop_current_C_line_number(), push_current_C_line_number(), reset_current_C_line_number(), and set_current_C_line_number().

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.

Referenced by ComputeAddresses(), EndOfProcedure(), gfc2pips_code2instruction__TOP(), gfc2pips_computeAdressesDynamic(), gfc2pips_computeAdressesOfArea(), gfc2pips_expr2entity(), gfc2pips_expr2expression(), gfc2pips_vars_(), init_c_areas(), init_c_implicit_variables(), InitAreas(), make_empty_module(), MakeStorageRam(), MakeVariableStatic(), ParserError(), save_all_entities(), and SaveEntity().

HeapArea

entity HeapArea

extern

Definition at line 59 of file area.c.

Referenced by ComputeAddresses(), DeclarePointer(), dump_common_layout(), gfc2pips_computeAdressesHeap(), gfc2pips_computeAdressesOfArea(), gfc2pips_vars_(), init_c_areas(), InitAreas(), make_empty_module(), and ParserError().

StackArea

entity StackArea

extern

Definition at line 60 of file area.c.

Referenced by CModuleMemoryAllocation(), ComputeAddresses(), dump_common_layout(), gfc2pips_computeAdressesOfArea(), gfc2pips_parameters(), gfc2pips_vars_(), init_c_areas(), InitAreas(), make_empty_module(), and MakeStorageRam().

StaticArea

entity StaticArea

extern

Definition at line 58 of file area.c.

Referenced by AnalyzeData(), ComputeAddresses(), EndOfProcedure(), fix_storage(), gfc2pips_code2instruction__TOP(), gfc2pips_computeAdressesOfArea(), gfc2pips_computeAdressesStatic(), gfc2pips_namespace(), init_c_areas(), InitAreas(), make_common_entity(), make_empty_module(), make_new_common(), MakeStorageRam(), MakeVariableStatic(), ParserError(), ProcessEntry(), save_all_entities(), and SaveEntity().