preprocessor.h File Reference

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

Go to the source code of this file.

Macros
#define	SRCPATH   "PIPS_SRCPATH"
	Warning! Do not modify this file that is automatically generated! More...
#define	CPP_PIPS_ENV   "PIPS_CPP"
	pre-processor and added options from environment More...
#define	CPP_PIPS_OPTIONS_ENV   "PIPS_CPP_FLAGS"
#define	FPP_PIPS_ENV   "PIPS_FPP"
#define	FPP_PIPS_OPTIONS_ENV   "PIPS_FPP_FLAGS"
#define	CPP_CPP   "cpp -C -std=c99"
	default preprocessor and basic options -C: do not discard comments... More...
#define	CPP_CPPFLAGS   " -D__PIPS__ -D__HPFC__ -U__GNUC__ "
	#define CPP_CPPFLAGS " -P -D__PIPS__ -D__HPFC__ " More...
#define	FPP_CPP   "gfortran -E"
	The preprocessor to use for Fortran files. More...
#define	FPP_CPPFLAGS   " -P -D__PIPS__ -D__HPFC__ "
	The default preprocessor flags to use with Fortran files. More...
#define	DEFAULT_PIPS_FLINT   "gfortran -Wall"
#define	DEFAULT_PIPS_CC   "gcc -std=c99 -D__PIPS__ -D__HPFC__ -U__GNUC__ "
	See necessary definitions in pipsmake-rc.tex. More...
#define	DEFAULT_PIPS_CC_FLAGS   " -Wall "
#define	csplit_parser_warning(...)

Typedefs
typedef size_t	yy_size_t
	symbols exported by lex / yacc More...

Functions
void	MakeTypedefStack ()
	Define some functions from the .l or .y since cproto cannot dig them out: More...
void	ResetTypedefStack ()
int	splitc_lex ()
int	splitc_lex_destroy ()
int	splitc_parse ()
void	splitc_error (const char *)
void	pips_get_workspace_list (gen_array_t)
	cproto-generated files More...
void	pips_get_fortran_list (gen_array_t)
	Select the true file with names ending in ".[fF]" and return a sorted arg list: More...
string	hpfc_generate_path_name_of_file_name (const char *)
	Return the path of an HPFC file name relative to the current PIPS directory. More...
int	hpfc_get_file_list (gen_array_t, char **)
string	pips_change_directory (const char *)
	Change to the given directory if it exists and return a canonical name. More...
void	pips_srcpath_set (string)
	Set the PIPS source path. More...
string	pips_srcpath_append (string)
	returns an allocated pointer to the old value More...
void	init_processed_include_cache (void)
void	close_processed_include_cache (void)
bool	filter_file (string)
string	preprocessed_to_user_file (string)
	Allocate a new string containing the user file name, before preprocessing. More...
bool	dot_F_file_p (string)
	Test if a name ends with .F. More...
bool	dot_f_file_p (string)
	Test if a name ends with .f. More...
bool	dot_f90_file_p (string)
	Test if a name ends with .f90. More...
bool	dot_f95_file_p (string)
	Test if a name ends with .f95. More...
bool	dot_c_file_p (string)
	Test if a name ends with .c. More...
language	workspace_language (gen_array_t)
	Choose a language if all filenames in "files" have the same C or Fortran extensions. More...
int	find_eol_coding (string)
	Returns the newly allocated name if preprocessing succeeds. More...
bool	process_user_file (string)
bool	flag_as_stub (const string)
bool	bootstrap_stubs (const string)
char *	fsplit (char *, char *, FILE *)
char *	process_bang_comments_and_hollerith (FILE *, FILE *)
	processing extracted for includes... More...
void	init_module_name_list (void)
void	reset_module_name_list (void)
void	error_reset_module_name_list (void)
	No checking, to be called from a (future) error handling module. More...
string	get_splitc_input_file_name (void)
void	reset_current_input_line (void)
	In file just above. More...
void	csplit_open_compilation_unit (string)
	Disambiguate the compilation unit base name (special character to avoid conflicts with function names and rank if same basename exists elsewhere in user files). More...
void	csplit_close_compilation_unit (void)
void	copy_between_2_fd_up_to_offset (FILE *, FILE *, unsigned long long, bool)
void	csplit_append_to_compilation_unit (int, unsigned long long)
	Copy the input file to the compilation unit between the function declarations up to the current function definition. More...
void	csplit_copy (const char *, string, int, int, size_t, size_t, int, bool)
	Create the module directory and file, copy the definition of the module and add the module name to the module name list. More...
void	keep_track_of_typedef (string)
void	csplit_error_handler (void)
	Close open files and reset variables. More...
void	csplit_reset (void)
void	csplit_close_files (string)
void	preprocessor_init_keyword_typedef_table (void)
string	csplit (char *, char *, FILE *)
char *	f95split (char *, char *, FILE **)
	f95split_file.c More...
void	csplit_parser_warning_func (const char *, const char *, const int, const string,...)
void	csplit_parser_error (const string)
	Redundant with splitc_error()? More...
void	ForceResetTypedefStack (void)
void	init_preprocessor_scope_stack (void)
void	reset_preprocessor_scope_stack (void)
void	force_reset_preprocessor_scope_stack (void)
	To be used by an error handler. More...
void	push_new_preprocessor_scope (void)
void	pop_preprocessor_scope (void)
bool	preprocessor_scope_stack_empty_p (void)
string	get_preprocessor_current_scope (void)
string	get_preprocessor_nth_scope (int)
int	preprocessor_scope_number (void)
int	check_signature_balance (void)
void	reset_csplit_line_number (void)
	Reinitialise global position numbers for a new file. More...
void	reset_csplit_current_beginning (void)
	This function is called at the end of any top-level C construct: More...
int	get_csplit_current_beginning (void)
int	get_user_current_beginning (void)
	Get the current line number in the file to split from the user point of view (before preprocessor expansion): More...
size_t	get_csplit_file_offset_beginning (void)
	Get the file position in the file to split where the current function begins: More...
size_t	get_current_csplit_file_offset (void)
	Get the current file position in the file to split: More...
void	update_csplit_file_offset_information (void)
	Function called each time a token is read to trac file position information: More...
void	splitc_restart (FILE *)
void	splitc_pop_buffer_state (void)
int	splitc_get_lineno (void)
FILE *	splitc_get_in (void)
FILE *	splitc_get_out (void)
int	splitc_get_leng (void)
char *	splitc_get_text (void)
void	splitc_set_lineno (int)
void	splitc_set_in (FILE *)
void	splitc_set_out (FILE *)
int	splitc_get_debug (void)
void	splitc_set_debug (int)
void *	splitc_alloc (yy_size_t)
void *	splitc_realloc (void *, yy_size_t)
void	splitc_free (void *)
int	splitc_wrap (void)

Variables
char *	splitc_text
FILE *	splitc_in
string	preprocessor_current_split_file_name
	Split a C or Fortran file into as many files as modules. More...
string	preprocessor_current_initial_file_name
	The digestion of a user file by PIPS begins here. More...
char	fsplit_copyright []
	split_file.c More...
char	fsplit_sccsid []
	not lint More...
char *	current_include_file_path
	csplit_file.c More...
char *	current_file_path
string	current_file_name
	Split a C file into one file per module (function or procedure) plus. More...
int	csplit_is_external
	splitc.c More...
int	csplit_is_function
	to know if the variable is declared inside or outside a function More...
string	csplit_current_function_name
	to know if this is the declaration of a function or not, to distinguish between a static variable and a static function More...
string	csplit_current_function_name2
string	csplit_definite_function_name
string	csplit_definite_function_signature
bool	csplit_is_static_p
	static int enum_counter = 0; More...
int	splitc_char
int	splitc_nerrs
int	splitc_leng
	lexer.c More...
FILE *	splitc_out
int	splitc_lineno
int	splitc__flex_debug
int	csplit_line_number
	To be exported to the parser for splitting the preprocessed file. More...
int	user_line_number
	To be exported to the parser for error messages related to the user file. More...
size_t	current_csplit_file_offset
size_t	csplit_file_offset_beginning
enum gather_comment_state_t	gather_comment_state_machine
	Indeed it does not work since csplit_copy() is called from splitc.y when a function definition is found and thus we cannot gather the comment in it... More...

Macro Definition Documentation

CPP_CPP

#define CPP_CPP   "cpp -C -std=c99"

default preprocessor and basic options -C: do not discard comments...

-P: inhibit linemakers (# 1 "file.c") -ffreestanding: ignore "stdc-predef.h"

Definition at line 52 of file preprocessor.h.

CPP_CPPFLAGS

#define CPP_CPPFLAGS   " -D__PIPS__ -D__HPFC__ -U__GNUC__ "

#define CPP_CPPFLAGS " -P -D__PIPS__ -D__HPFC__ "

-U__GNUC__ seems to be still useful to avoid spoiling the libC files with too many GCC extensions:

Definition at line 57 of file preprocessor.h.

CPP_PIPS_ENV

#define CPP_PIPS_ENV   "PIPS_CPP"

pre-processor and added options from environment

Definition at line 40 of file preprocessor.h.

CPP_PIPS_OPTIONS_ENV

#define CPP_PIPS_OPTIONS_ENV   "PIPS_CPP_FLAGS"

Definition at line 41 of file preprocessor.h.

csplit_parser_warning

#define csplit_parser_warning

(

...

)

Value:

  csplit_parser_warning_func(CURRENT_FUNCTION, __FILE__, __LINE__, \
                             __VA_ARGS__)

Definition at line 81 of file preprocessor.h.

DEFAULT_PIPS_CC

#define DEFAULT_PIPS_CC   "gcc -std=c99 -D__PIPS__ -D__HPFC__ -U__GNUC__ "

See necessary definitions in pipsmake-rc.tex.

Definition at line 74 of file preprocessor.h.

DEFAULT_PIPS_CC_FLAGS

#define DEFAULT_PIPS_CC_FLAGS   " -Wall "

Definition at line 75 of file preprocessor.h.

DEFAULT_PIPS_FLINT

#define DEFAULT_PIPS_FLINT   "gfortran -Wall"

Definition at line 70 of file preprocessor.h.

FPP_CPP

#define FPP_CPP   "gfortran -E"

The preprocessor to use for Fortran files.

Alternative values: "gcc -E -C" or "fpp". The issue with cpp or gcc -E is that they don't undestand Fortran and chokes on unbalanced strings in Fortran comments and so on.

Definition at line 65 of file preprocessor.h.

FPP_CPPFLAGS

#define FPP_CPPFLAGS   " -P -D__PIPS__ -D__HPFC__ "

The default preprocessor flags to use with Fortran files.

Definition at line 68 of file preprocessor.h.

FPP_PIPS_ENV

#define FPP_PIPS_ENV   "PIPS_FPP"

Definition at line 42 of file preprocessor.h.

FPP_PIPS_OPTIONS_ENV

#define FPP_PIPS_OPTIONS_ENV   "PIPS_FPP_FLAGS"

Definition at line 43 of file preprocessor.h.

SRCPATH

#define SRCPATH   "PIPS_SRCPATH"

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

Modify src/Libs/preprocessor/preprocessor-local.h instead, to add your own modifications. header file built by cproto preprocessor-local.h Preprocessing and splitting of Fortran and C files the name of the environment variable where source files are searched for.

Definition at line 36 of file preprocessor.h.

Typedef Documentation

yy_size_t

typedef size_t yy_size_t

symbols exported by lex / yacc

Definition at line 86 of file preprocessor.h.

Function Documentation

bootstrap_stubs()

bool bootstrap_stubs

(

const

string

)

Parameters

string

odule_name

Definition at line 1344 of file source_file.c.

{
  if (db_resource_p(DBR_STUBS, ""))
    pips_internal_error("kernels already initialized for %s", module_name);
  callees stubs=make_callees(NIL);
  DB_PUT_MEMORY_RESOURCE(DBR_STUBS,"",stubs);
  return true;
}

References DB_PUT_MEMORY_RESOURCE, db_resource_p(), make_callees(), module_name(), NIL, and pips_internal_error.

Referenced by generic_initializer().

Here is the call graph for this function:

Here is the caller graph for this function:

check_signature_balance()

int check_signature_balance

(

void

)

pips_internal_error("More signatures freed than allocated: %d\n", imbalance);

Definition at line 524 of file splitc.c.

   {
     int imbalance = number_of_signatures_built - number_of_signatures_freed;
     if(imbalance<0) {
       /* pips_internal_error("More signatures freed than allocated: %d\n", imbalance); */
       pips_debug(5, "More signatures freed than allocated: %d\n", imbalance);
     }
     return imbalance;
   }

References number_of_signatures_built, number_of_signatures_freed, and pips_debug.

Referenced by reset_csplit_current_beginning().

Here is the caller graph for this function:

close_processed_include_cache()

void close_processed_include_cache

(

void

)

pips may call this without a prior call to init_processed_include_cache under some error conditions, such as a file not found in the initializer, or a failed cpp.

Definition at line 283 of file source_file.c.

{
  //fprintf(stderr, "[close_processed_include_cache] Entering\n");
  if (hash_table_undefined_p(processed_cache))
  {
    /* pips may call this without a prior call to
     * init_processed_include_cache under some error conditions,
     * such as a file not found in the initializer, or a failed cpp.
     */
    /*
      Do not warn the user about PIPS internal architecture issues... :-/
      pips_user_warning("no 'processed include cache' to close, "
      "skipping...\n");
    */
    return;
  }
  pips_assert("defined cache", !hash_table_undefined_p(processed_cache));
  HASH_MAP(k, v, { unlink(v); free(v); }, processed_cache);
  hash_table_free(processed_cache);
  processed_cache = hash_table_undefined;
}

References free(), HASH_MAP, hash_table_free(), hash_table_undefined, hash_table_undefined_p, pips_assert, and processed_cache.

Referenced by check_delete_workspace(), and close_workspace().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_between_2_fd_up_to_offset()

void copy_between_2_fd_up_to_offset	(	FILE *	,
		FILE *	,
		unsigned long long	,
		bool
	)

csplit()

string csplit	(	char *	dir_name,
		char *	file_name,
		FILE *	out
	)

In case a error occurs

The same file is opened twice for parsing, for copying the compilation unit and for copying the modules.

splitc_in_copy = safe_fopen(file_name, "r");

Do not forget to catch what could remain after the last function up to the end of file:

Parameters

dir_name	ir_name
file_name	ile_name
out	ut

Definition at line 641 of file csplit_file.c.

{
  string error_message = string_undefined;
  current_file_name = file_name; /* In case a error occurs*/
 
  debug_on("CSPLIT_DEBUG_LEVEL");
 
  pips_debug(1, "Begin in directory %s for file %s\n", dir_name, file_name);
 
  /* The same file is opened twice for parsing, for copying the
     compilation unit and for copying the modules. */
 
  if ((splitc_in = fopen(file_name, "r")) == NULL) {
    fprintf(stderr, "csplit: cannot open %s\n", file_name);
    return "cannot open file";
  }
  splitc_input_file_name = file_name;
 
  current_workspace_name = dir_name;
 
  splitc_in_append = safe_fopen(file_name, "r");
  /* splitc_in_copy = safe_fopen(file_name, "r"); */
 
  preprocessor_init_keyword_typedef_table();
 
  module_list_file = out;
  csplit_open_compilation_unit(file_name);
  MakeTypedefStack();
  init_preprocessor_scope_stack();
  current_include_file_path = NULL;
  current_file_path = NULL;
 
  CATCH(any_exception_error) {
    error_message = "PIPS preprocessor parser error";
  }
  TRY {
    splitc_parse();
    error_message = NULL;
    UNCATCH(any_exception_error);
  }
 
  if(error_message==NULL) {
    /* Do not forget to catch what could remain after the last function up
       to the end of file: */
    csplit_append_to_compilation_unit(INT_MAX, ULLONG_MAX);
    csplit_close_files(file_name);
 
    csplit_reset();
  }
  debug_off();
 
  return error_message;
}

References any_exception_error, CATCH, csplit_append_to_compilation_unit(), csplit_close_files(), csplit_open_compilation_unit(), csplit_reset(), current_file_name, current_file_path, current_include_file_path, current_workspace_name, debug_off, debug_on, file_name, fprintf(), init_preprocessor_scope_stack(), MakeTypedefStack(), module_list_file, out, pips_debug, preprocessor_init_keyword_typedef_table(), safe_fopen(), splitc_in, splitc_in_append, splitc_input_file_name, splitc_parse(), string_undefined, TRY, and UNCATCH.

Referenced by pips_split_file().

Here is the call graph for this function:

Here is the caller graph for this function:

csplit_append_to_compilation_unit()

void csplit_append_to_compilation_unit	(	int	last_line,
		unsigned long long	last_offset
	)

Copy the input file to the compilation unit between the function declarations up to the current function definition.

We are in the offset mode instead of line mode

Copy up to function begin

We are in the line-oreiented mode:

In some cases, e.g. two module definitions are contiguous, nothing has to be copied.

Parameters

last_line	ast_line
last_offset	ast_offset

Definition at line 262 of file csplit_file.c.

                                                                       {
  pips_debug(2, "append to compilation unit up-to line %d (from %d) or offset %llu\n",
             last_line, current_input_line, last_offset);
 
  if (last_offset != 0) {
    /* We are in the offset mode instead of line mode */
    pips_debug(2, "copying to compilation unit file up to offset %llu, we are at currently at offset %lu\n",
               last_offset, ftell(splitc_in_append));
    copy_between_2_fd_up_to_offset(splitc_in_append,
                                   compilation_unit_file,
                                   last_offset,
                                   true /* Copy up to function begin */);
  }
  else {
    /* We are in the line-oreiented mode: */
    pips_assert("last_line is positive", last_line >= 0);
    pips_assert("if last_line is strictly less than current_input_line, then last_line is 0",
                last_line >= current_input_line || last_line == 0);
 
    pips_assert("The compilation unit file is open", compilation_unit_file != NULL);
 
    if(last_line == 0)
      current_input_line = 0;
    else {
      /* In some cases, e.g. two module definitions are contiguous, nothing
         has to be copied. */
      while(current_input_line < last_line) {
        char c = fgetc(splitc_in_append);
 
        ifdebug(5)
          putc(c, stderr);
        fputc(c, compilation_unit_file);
        if(c == '\n')
          current_input_line++;
      }
    }
  }
}

References compilation_unit_file, copy_between_2_fd_up_to_offset(), current_input_line, ifdebug, pips_assert, pips_debug, and splitc_in_append.

Referenced by csplit(), and csplit_copy().

Here is the call graph for this function:

Here is the caller graph for this function:

csplit_close_compilation_unit()

void csplit_close_compilation_unit

(

void

)

Definition at line 183 of file csplit_file.c.

{
  safe_fclose(compilation_unit_file, current_compilation_unit_file_name);
  free(current_compilation_unit_name);
  free(current_compilation_unit_file_name);
  current_compilation_unit_name = string_undefined;
  current_compilation_unit_file_name = string_undefined;
  reset_preprocessor_scope_stack();
}

References compilation_unit_file, current_compilation_unit_file_name, current_compilation_unit_name, free(), reset_preprocessor_scope_stack(), safe_fclose(), and string_undefined.

Referenced by csplit_close_files().

Here is the call graph for this function:

Here is the caller graph for this function:

csplit_close_files()

void csplit_close_files

(

string

file_name

)

No close, because this file descriptor is managed by the caller.

Parameters

file_name

ile_name

Definition at line 547 of file csplit_file.c.

{
    csplit_close_compilation_unit();
    current_include_file_path = NULL;
    free(current_file_path);
    current_file_path=NULL;
    ForceResetTypedefStack();
    safe_fclose(splitc_in, file_name);
    splitc_in = NULL;
    splitc_input_file_name = string_undefined;
    safe_fclose(splitc_in_append, file_name);
    splitc_in_append = NULL;
    /*
      safe_fclose(splitc_in_copy, file_name);
      splitc_in_copy = NULL;
     */
    /* No close, because this file descriptor is managed by the caller. */
    module_list_file = NULL;
}

References csplit_close_compilation_unit(), current_file_path, current_include_file_path, file_name, ForceResetTypedefStack(), free(), module_list_file, safe_fclose(), splitc_in, splitc_in_append, splitc_input_file_name, and string_undefined.

Referenced by csplit(), and csplit_parser_error().

Here is the call graph for this function:

Here is the caller graph for this function:

csplit_copy()

void csplit_copy	(	const char *	module_name,
		string	signature,
		int	first_line,
		int	last_line,
		size_t	first_offset,
		size_t	last_offset,
		int	user_first_line,
		bool	is_static_p
	)

Create the module directory and file, copy the definition of the module and add the module name to the module name list.

The compilation unit name used for static functions is retrieved from a global variable set by csplit_open_compilation_unit(), current_compilation_unit_name.

If first_offset and last_offset are not both 0, the module is found in the source file between these file offset instead of between lines first_line and int last_line.

Unambiguous, unless the user has given the same name to two functions.

MODULE_SEP_STRING,

string unambiguous_module_name = module_name;

Keep track of the existence of a C main function in the workspace

pips_assert("First line is strictly positive and lesser than last_line", first_line>0 && first_line<last_line);

Step 1: Define an unambiguous name and open the file if possible

Concatenate the unambigous compilation unit name and the module name

Note: the same static function may be declared twice in the compilation unit because the user is mistaken.

pips_internal_error("Not implemented yet.");

FILE_SEP_STRING,

The name should be unique in the workspace, but the user may have provided several module with the same name

Open the module code file for writing as the mfd FILE descriptor:

Such a module already exists

Possible access right problem?

Step 2: Copy the file source from the end of the last function definition up to the begin of the current one into the compilation unit to get variable and type declarations, etc.

Only bother in line-oriented mode

Step 3: Copy the function declaration in its module file, starting with its line number in the original file.

skip is up to the C preprocessor choice for local files: foo.c or ./foo.c.

It does not really matter because the ambiguity is taken care of by the PIPS C parser.

Begin and end are specified as line numbers:

Begin and end are specified as file offsets. First seek at the begin of the function:

Copy up to the function end:

Do not include trailing spaces

Step 4: Copy the function definition

Fabien: you could add here anything you might want to unsplit the file later. SG: what about inline static ? why add an extern qualifier ?

check for the static qualifier

or the extern qualifier

default to extern qualifier? Not mandatory, but expected by the C parser

Step 5: Keep track of the new module

SG hook: do not keep track of module declared inside a header not very reliable in the presence of used inline function in user header, so left apart as of now

Do not free unambiguous_module_name since it is already done in reset_csplit_current_beginning()

Parameters

module_name	odule_name
signature	ignature
first_line	irst_line
last_line	ast_line
first_offset	irst_offset
last_offset	ast_offset
user_first_line	ser_first_line
is_static_p	s_static_p

Definition at line 334 of file csplit_file.c.

{
  FILE * mfd = NULL;
  /* Unambiguous, unless the user has given the same name to two functions. */
  string unambiguous_module_file_name;
  const char* unambiguous_module_name = is_static_p?
    strdup(concatenate(current_compilation_unit_name, /* MODULE_SEP_STRING,*/ module_name, NULL)) :
    module_name;
  /* string unambiguous_module_name = module_name; */
 
  if(same_string_p(module_name, "main")) {
    /* Keep track of the existence of a C main function in the workspace*/
    // full_name() in split_file.c... but declared static
    char * main_list = strdup(concatenate(current_workspace_name, "/", MAIN_FILE_NAMES, NULL));
    FILE * fm = fopen(main_list, "a");
    if (fm==NULL) {
      fprintf(stderr, "fopen(\"%s\", ...) failed\n", main_list);
      // FI: not user friendly...
      abort();
    }
    fputs(module_name, fm);
    putc('\n', fm);
    fclose(fm);
    free(main_list);                  
  }
 
  /* pips_assert("First line is strictly positive and lesser than last_line",
     first_line>0 && first_line<last_line); */
  if(!(first_line > 0 && first_line <= last_line)) {
    pips_user_error("Definition of function %s starts at line %d and ends a t line %d\n"
                    "PIPS assumes the function definition to start on a new line "
                    "after the function signature\n", module_name, first_line, last_line);
  }
  pips_assert("current_compilation_unit_name is defined",
              !string_undefined_p(current_compilation_unit_name));
 
  /* Step 1: Define an unambiguous name and open the file if possible */
  if(is_static_p) {
    /* Concatenate the unambigous compilation unit name and the module name */
    /* Note: the same static function may be declared twice in the
       compilation unit because the user is mistaken. */
    /* pips_internal_error("Not implemented yet."); */
    unambiguous_module_file_name
      = strdup(concatenate(current_workspace_name, "/", current_compilation_unit_name,
                           /* FILE_SEP_STRING, */ module_name, C_FILE_SUFFIX, NULL));
  }
  else {
    /* The name should be unique in the workspace, but the user may have
       provided several module with the same name */
    unambiguous_module_file_name
      = strdup(concatenate(current_workspace_name, "/", module_name, C_FILE_SUFFIX, NULL));
  }
 
  /* Open the module code file for writing as the mfd FILE descriptor: */
  pips_debug(1, "Begin for %s module \"%s\" from line %d to line %d (offset [%zd-%zd]) in compilation unit %s towards %s\n",
             is_static_p? "static" : "global",
             module_name,
             first_line, last_line, first_offset, last_offset,
             splitc_input_file_name,
             unambiguous_module_file_name);
 
  if((mfd=fopen(unambiguous_module_file_name, "r"))!=NULL) {
    /* Such a module already exists */
    pips_user_error("Duplicate function \"%s\".\n"
                    "Copy in file %s from input file %s is ignored\n"
                    "Check source code with a compiler or set property %s\n",
                    module_name,
                    unambiguous_module_file_name,
                    splitc_input_file_name,
                    "PIPS_CHECK_FORTRAN");
  }
  else if((mfd=fopen(unambiguous_module_file_name, "w"))==NULL) {
    /* Possible access right problem? */
    pips_user_error("Access or creation right denied for %s\n",
                    unambiguous_module_file_name);
  }
 
  pips_assert("The module file descriptor is defined", mfd!=NULL);
 
  /* Step 2: Copy the file source from the end of the last function
     definition up to the begin of the current one into the compilation
     unit to get variable and type declarations, etc. */
  csplit_append_to_compilation_unit(first_line - 1, first_offset);
 
  pips_assert("Current position is OK", /* Only bother in line-oriented mode */
              (first_offset != 0 || last_offset != 0) || current_input_line == first_line-1);
 
  /* Step 3: Copy the function declaration in its module file, starting
     with its line number in the original file. */
 
  /* skip is up to the C preprocessor choice for local files: foo.c or
   * ./foo.c.
   *
   * It does not really matter because the ambiguity is taken care of
   * by the PIPS C parser.
   */
  int skip = 0;
  char * p = (char *) preprocessor_current_initial_file_name;
  if(*p=='.' && *(p+1)=='/')
    skip = 2;
  fprintf(mfd, "# %d \"%s\"\n", user_first_line,
          preprocessor_current_initial_file_name+skip);
  //preprocessor_current_split_file_name);
  if (first_offset == 0 && last_offset == 0) {
    pips_debug(2, "copying to module file lines [%d-%d]\n",
               current_input_line, last_line);
    /* Begin and end are specified as line numbers: */
    while(current_input_line<last_line) {
      char c = fgetc(splitc_in_append);
      ifdebug(5)
        putc(c, stderr);
      fputc(c, mfd);
      if(c=='\n')
        current_input_line++;
    }
  }
  else {
    pips_debug(2, "copying to module file offset [%zd-%zd]\n",
               first_offset, last_offset);
    /* Begin and end are specified as file offsets. First seek at the begin
       of the function: */
    //safe_fseek(splitc_in_append, first_offset, SEEK_SET, "splitc_in_append");
    /* Copy up to the function end: */
    copy_between_2_fd_up_to_offset(splitc_in_append,
                                   mfd,
                                   last_offset,
                                   false /* Do not include trailing spaces */);
  }
 
  /* Step 4: Copy the function definition */
  /* Fabien: you could add here anything you might want to unsplit the
     file later.
     SG: what about inline static ? why add an extern qualifier ?
     */
  /* check for the static qualifier */
  char * where;
  if( (where = strstr(signature,"static") ) &&
          isspace(where[sizeof("static")-1]) &&
              ( where == signature || isspace(where[-1]) )
    ) {
    fprintf(compilation_unit_file, "# %d \"%s\"\n", user_first_line,
            preprocessor_current_initial_file_name);
    fprintf(compilation_unit_file, "%s;\n", signature);
  }
  /* or the extern qualifier */
  else if ( (where = strstr(signature,"extern") ) &&
          isspace(where[sizeof("extern")-1]) &&
              ( where == signature || isspace(where[-1]) )
    ){
    fprintf(compilation_unit_file, "%s;\n", signature);
  }
  /* default to extern qualifier? Not mandatory, but expected by the C parser */
  else {
    fprintf(compilation_unit_file, "# %d \"%s\"\n", (int) user_first_line,
            preprocessor_current_initial_file_name);
    fprintf(compilation_unit_file, "extern %s;\n", signature);
    // fprintf(compilation_unit_file, "%s;\n", signature);
  }
 
  /* Step 5: Keep track of the new module */
  /* SG hook: do not keep track of module declared inside a header
   * not very reliable in the presence of used inline function in user header,
   * so left apart as of now
   */
  if(true || !get_bool_property("IGNORE_FUNCTION_IN_HEADER")
          || !path_header_p(current_include_file_path)) {
      fprintf(module_list_file, "%s %s\n", unambiguous_module_name, unambiguous_module_file_name);
  }
 
 
  safe_fclose(mfd, unambiguous_module_file_name);
  free(unambiguous_module_file_name);
  /* Do not free unambiguous_module_name since it is already done in
     reset_csplit_current_beginning() */
  //free(unambiguous_module_name);
}

References abort, compilation_unit_file, concatenate(), copy_between_2_fd_up_to_offset(), csplit_append_to_compilation_unit(), current_compilation_unit_name, current_include_file_path, current_input_line, current_workspace_name, fprintf(), free(), get_bool_property(), ifdebug, MAIN_FILE_NAMES, module_list_file, module_name(), path_header_p(), pips_assert, pips_debug, pips_user_error, preprocessor_current_initial_file_name, safe_fclose(), same_string_p, splitc_in_append, splitc_input_file_name, strdup(), and string_undefined_p.

Here is the call graph for this function:

csplit_error_handler()

void csplit_error_handler

(

void

)

Close open files and reset variables.

Reset keyword table

Definition at line 531 of file csplit_file.c.

{
  /* Reset keyword table */
  reset_current_input_line();
  reset_csplit_line_number();
  free_keyword_typedef_table();
}

References free_keyword_typedef_table(), reset_csplit_line_number(), and reset_current_input_line().

Referenced by csplit_parser_error().

Here is the call graph for this function:

Here is the caller graph for this function:

csplit_open_compilation_unit()

void csplit_open_compilation_unit

(

string

input_file_name

)

Disambiguate the compilation unit base name (special character to avoid conflicts with function names and rank if same basename exists elsewhere in user files).

Do not create the corresponding directory and within it the compilation unit file.

Initialize compilation_unit_file by opening this last file.

Set the current_compilation_unit_file_name.

string compilation_unit_name = string_undefined;

string compilation_unit_file_name = string_undefined;

Step 1: Define the compilation unit name from the input file name.

Loop with a counter until the open is OK. Two or more files with the same local names may be imported from different directories.

This does not work because this file is later moved in the proper directory.

Loop over counter not implemented.

Does this current compilation unit already exist?

Keep track of the new compilation unit as a "module" stored in a file

Parameters

input_file_name

nput_file_name

Definition at line 116 of file csplit_file.c.

{
  string unambiguous_file_name = string_undefined;
  string simpler_file_name = pips_basename(input_file_name, PP_C_ED);
  /* string compilation_unit_name = string_undefined; */
  /* string compilation_unit_file_name = string_undefined; */
 
  pips_debug(1, "Open compilation unit \"%s\"\n", input_file_name);
 
  pips_assert("No current compilation unit",
              string_undefined_p(current_compilation_unit_file_name));
 
  pips_assert("No current compilation unit",
              string_undefined_p(current_compilation_unit_name));
 
  /* Step 1: Define the compilation unit name from the input file name. */
  unambiguous_file_name = strdup(concatenate(current_workspace_name,
                                             "/",
                                             simpler_file_name,
                                             FILE_SEP_STRING,
                                             C_FILE_SUFFIX,
                                             NULL));
 
  /* Loop with a counter until the open is OK. Two or more files with the
     same local names may be imported from different directories. */
  /* This does not work because this file is later moved in the proper directory. */
  /*
  if(fopen(unambiguous_file_name, "r")!=NULL) {
    pips_internal_error("Two source files (at least) with same name: \"%s\"",
                        simpler_file_name);
  }
  */
  compilation_unit_file = safe_fopen(unambiguous_file_name, "w");
 
  /* Loop over counter not implemented. */
 
  pips_assert("compilation_unit_file is defined",
              compilation_unit_file != NULL);
 
  current_compilation_unit_file_name = unambiguous_file_name;
  current_compilation_unit_name
    = strdup(concatenate(simpler_file_name, FILE_SEP_STRING, NULL));
 
  /* Does this current compilation unit already exist? */
  if(fopen(concatenate(current_workspace_name,
                       "/",
                       simpler_file_name,
                       FILE_SEP_STRING,
                       "/",
                       simpler_file_name,
                       FILE_SEP_STRING,
                       C_FILE_SUFFIX, NULL)
           , "r")!=NULL) {
    pips_user_error("Two source files (at least) with same name: \"%s"
                    C_FILE_SUFFIX "\".\n"
                    "Not supported yet.\n",
                    simpler_file_name);
  }
 
  /* Keep track of the new compilation unit as a "module" stored in a file */
 
  fprintf(module_list_file, "%s %s\n",
          current_compilation_unit_name,
          current_compilation_unit_file_name);
  free(simpler_file_name);
}

References compilation_unit_file, concatenate(), current_compilation_unit_file_name, current_compilation_unit_name, current_workspace_name, FILE_SEP_STRING, fprintf(), free(), module_list_file, pips_assert, pips_basename(), pips_debug, pips_user_error, safe_fopen(), strdup(), string_undefined, and string_undefined_p.

Referenced by csplit().

Here is the call graph for this function:

Here is the caller graph for this function:

csplit_parser_error()

void csplit_parser_error

(

const

string

)

Redundant with splitc_error()?

Should add the current line number of the lexer

csplit_parser_warning("Corrupted or non-supported C constructs.\n"

"Make sure your code is compiled by gcc -stc=c99 first, "

"and/or set proper PIPS option, "

"CHECK_FORTRAN_SYNTAX_BEFORE_RUNNING_PIPS or "

"CHECK_C_SYNTAX_BEFORE_RUNNING_PIPS.\n");

Reset all static variables

Close all open files: at least three...

Parameters

string

sg

Definition at line 188 of file splitc.c.

{
  /* Should add the current line number of the lexer */
 
  /* csplit_parser_warning("Corrupted or non-supported C constructs.\n" */
  /*                   "Make sure your code is compiled by gcc -stc=c99 first, " */
  /*                   "and/or set proper PIPS option, " */
  /*                   "CHECK_FORTRAN_SYNTAX_BEFORE_RUNNING_PIPS or " */
  /*                   "CHECK_C_SYNTAX_BEFORE_RUNNING_PIPS.\n"); */
 
  csplit_parser_warning(msg);
 
  //pips_internal_error("Not implemented yet\n."
  //             " Should reset all static variables.\n");
  /* Reset all static variables */
  /* Close all open files: at least three... */
  extern string current_file_name;
  csplit_close_files(current_file_name);
  csplit_error_handler();
 
  // See syn_reset_lex() -> syn_restart(syn_in); as in ParserError,
  // the error routine for the Fortran parser, but its lexer is
  // made of two passes, a Fortran-specific first pass and a lex second pass
  // syn_restart(splitc_in);
  // yy_flush_buffer(); //YY_FLUSH_BUFFER;
  splitc_lex_destroy(); // trial and error
  // BEGIN(0); we might have to reset the state of lex
 
  //pips_user_error(s);
  pips_user_error("Corrupted or non-supported C constructs.\n"
                  "Make sure your code is compiled by gcc -stc=c99 first, "
                  "and/or set proper PIPS option, "
                  "CHECK_FORTRAN_SYNTAX_BEFORE_RUNNING_PIPS or "
                  "CHECK_C_SYNTAX_BEFORE_RUNNING_PIPS.\n");
}

References csplit_close_files(), csplit_error_handler(), csplit_parser_warning, current_file_name, pips_user_error, and splitc_lex_destroy().

Here is the call graph for this function:

csplit_parser_warning_func()

void csplit_parser_warning_func	(	const char *	pips_func,
		const char *	pips_file,
		const int	pips_line,
		const	string,
			...
	)

Parameters

pips_func	ips_func
pips_file	ips_file
pips_line	ips_line
string	ormat

Definition at line 174 of file splitc.c.

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

References csplit_parser_warning_alist().

Here is the call graph for this function:

csplit_reset()

void csplit_reset

(

void

)

Reset keyword table

Definition at line 539 of file csplit_file.c.

{
  /* Reset keyword table */
  reset_current_input_line();
  reset_csplit_line_number();
  free_keyword_typedef_table();
}

References free_keyword_typedef_table(), reset_csplit_line_number(), and reset_current_input_line().

Referenced by csplit().

Here is the call graph for this function:

Here is the caller graph for this function:

dot_c_file_p()

bool dot_c_file_p

(

string

name

)

Test if a name ends with .c.

Parameters

name

ame

Definition at line 661 of file source_file.c.

                               {
  return !!find_suffix(name, C_FILE_SUFFIX);
}

References find_suffix().

Referenced by get_new_user_file(), pips_split_file(), process_user_file(), and workspace_language().

Here is the call graph for this function:

Here is the caller graph for this function:

dot_f90_file_p()

bool dot_f90_file_p

(

string

name

)

Test if a name ends with .f90.

Parameters

name

ame

Definition at line 649 of file source_file.c.

                                   {
  return !!find_suffix( name, FORTRAN90_FILE_SUFFIX );
}

References find_suffix().

Referenced by create_workspace(), get_new_user_file(), pips_split_file(), process_user_file(), and workspace_language().

Here is the call graph for this function:

Here is the caller graph for this function:

dot_f95_file_p()

bool dot_f95_file_p

(

string

name

)

Test if a name ends with .f95.

Parameters

name

ame

Definition at line 655 of file source_file.c.

                                   {
  return !!find_suffix( name, FORTRAN95_FILE_SUFFIX );
}

References find_suffix().

Referenced by create_workspace(), get_new_user_file(), pips_split_file(), process_user_file(), and workspace_language().

Here is the call graph for this function:

Here is the caller graph for this function:

dot_F_file_p()

bool dot_F_file_p

(

string

name

)

Test if a name ends with .F.

Parameters

name

ame

Definition at line 637 of file source_file.c.

                               {
  return !!find_suffix(name, RATFOR_FILE_SUFFIX);
}

References find_suffix().

Referenced by pips_split_file(), process_thru_cpp(), process_user_file(), and workspace_language().

Here is the call graph for this function:

Here is the caller graph for this function:

dot_f_file_p()

bool dot_f_file_p

(

string

name

)

Test if a name ends with .f.

Parameters

name

ame

Definition at line 643 of file source_file.c.

                               {
  return !!find_suffix(name, FORTRAN_FILE_SUFFIX);
}

References find_suffix().

Referenced by get_new_user_file(), pips_split_file(), process_user_file(), and workspace_language().

Here is the call graph for this function:

Here is the caller graph for this function:

error_reset_module_name_list()

void error_reset_module_name_list

(

void

)

No checking, to be called from a (future) error handling module.

Definition at line 74 of file csplit_file.c.

{
  if(!list_undefined_p(module_name_list))
    reset_module_name_list();
}

References list_undefined_p, module_name_list, and reset_module_name_list().

Here is the call graph for this function:

f95split()

char* f95split	(	char *	dir_name,
		char *	file_name,
		FILE **	out
	)

f95split_file.c

printf(stderr, "\n-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n" "+ Starting gfc parser in PIPS. -\n" "-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n" );

string source_filename = strdup( concatenate( dir, "/", db_get_file_resource( DBR_SOURCE_FILE, module, true ), NULL ) );

dump_parse_tree is the gfc pass that have been hacked to call the gfc2pips stuff

we may have non-standard file extensions (e.g. .f_initial) and gfortran will not be able to know what it is so we force the language input

I don't know what the following stuff is ...

-fcray-pointer",

This debug_off() occurs too late since pipsdbm has been called before. Initially, the parser was designed to parse more than one subroutine/function/program at a time.

Parameters

dir_name	ir_name
file_name	ile_name
out	ut

Definition at line 56 of file f95split_file.c.

                                                                  {
 
  FILE *fd;
 
 
  debug_on( "SYNTAX_DEBUG_LEVEL" );
 
  /*fprintf(stderr,
   "\n-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n"
   "+ Starting gfc parser in PIPS.                 -\n"
   "-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n"
   );*/
 
  //  string callees_filename = get_resource_file_name( DBR_CALLEES, module );
  // Create if it doesn't exist
  //  close( open( callees_filename, O_CREAT, S_IRWXU ) );
 
 
  /*
   *
   */
 
  // Create xxx.database/Program if it doesn't exist Yet
  string program_dirname = get_resource_file_name( "", "" );
  mkdir( program_dirname, S_IRWXU );
  free( program_dirname );
 
  /*
   * Dump entities
   */
  string entities_filename = get_resource_file_name( DBR_ENTITIES, "" );
  fd = (FILE *) safe_fopen( (char *) entities_filename, "w" );
  gen_write_tabulated( fd, entity_domain );
  safe_fclose( fd, (char *) entities_filename );
 
  /*
   * directory where module are precompiled
   */
  char *compiled_dir_name = get_resource_file_name( "", "/Precompiled" );
 
  // Check if source file exist
  /*  string source_filename =
   strdup( concatenate( dir, "/", db_get_file_resource( DBR_SOURCE_FILE,
   module,
   true ), NULL ) );
   */
  // "char **argv" for gfc2pips :-)
  char* gfc2pips_args[] = { "gfc2pips", "-Wall",// "-Werror",
                            // We give it where to output...
                            "-pips-entities",
                            entities_filename,
                            "-o","/dev/null",
                            //parsedcode_filename,
                            file_name,
                            // ... and where to read inputs
                            "-auxbase",
                            //source_filename,
                            dir_name,
                            /* dump_parse_tree is the gfc pass that have been
                             * hacked to call the gfc2pips stuff
                             */
                            "-fdump-parse-tree",
                            "-quiet",
                            "-I",compiled_dir_name,
                            /* we may have non-standard file extensions
                             * (e.g. .f_initial) and gfortran will not be able
                             * to know what it is so we force the language input
                             */
                            // "-x",
                            // "f95",
                            "-cpp",
                            // "-quiet",// "-Werror",
                            /* I don't know what the following stuff is ... */
                            /*"-fcray-pointer",*/
                            "-ffree-form",
                            //"-fdefault-double-8",
                            //"-fdefault-integer-8",
                            //"-fdefault-real-8",
 
                            // Argv must be null terminated
                            NULL };
 
  // we will fork now in order to call GFC
  int statut;
  pid_t child_pid = fork( );
 
  // Now we have two process runing the same code
  // We differentiate them with fork() return value
 
  if ( child_pid == -1 ) {
    // Error
    perror( "Fork" );
    return false;
  } else if ( child_pid == 0 ) {
    // in the child
 
 
    pips_debug( 2, "build module %s\n", file_name );
 
    // MAIN CALL TO GFC
    char** arg = gfc2pips_args;
    ifdebug(1) {
      fprintf( stderr, "execvp : " );
      while ( *arg ) {
        fprintf( stderr, " %s", *arg );
        arg++;
      }
      fprintf( stderr, "\n" );
    }
    execvp( "gfc2pips", gfc2pips_args );
    // No return from exec
    pips_user_error("gfc2pips is not installed, did you compile PIPS with"
        " Fortran95 support ?\n");
    exit( -1 );
  } else {
    // in the Father
 
    // Wait that gfc has done the job
    if ( waitpid( child_pid, &statut, 0 ) == -1 ) {
      // Error in waitpid
      perror( "waitpid" );
      return "Erreur in wait pid";
    } else {
      // Child has correctly finished
 
      // Check the gfc2pips return code
      if ( statut != EXIT_SUCCESS ) {
        fprintf(stderr,"error code %d\n",statut);
        return "gfc2pips return an error";
      }
    }
  }
 
  // If we are, everything was done properly :-)
 
 
  // Reload entities
 
  // We have to close it and re-open since gfc2pips has written into it.
  fclose( *out );
 
  //out will be close in caller
  *out = safe_fopen( entities_filename, "r" );
 
  gen_read_tabulated( *out, 0 );
//  safe_fclose( fp, entities_filename );
 
 
 
  /* This debug_off() occurs too late since pipsdbm has been called
   * before. Initially, the parser was designed to parse more than
   * one subroutine/function/program at a time.  */
  debug_off( );
 
 
 
  return NULL;
 
}

References debug_off, debug_on, entity_domain, exit, EXIT_SUCCESS, file_name, fprintf(), free(), gen_read_tabulated(), gen_write_tabulated(), get_resource_file_name(), gfc2pips_args(), ifdebug, out, pips_debug, pips_user_error, safe_fclose(), and safe_fopen().

Referenced by pips_split_file().

Here is the call graph for this function:

Here is the caller graph for this function:

filter_file()

bool filter_file

(

string

mod_name

)

directory is set for finding includes.

Parameters

mod_name

od_name

Definition at line 501 of file source_file.c.

{
    string name, new_name, dir_name, abs_name, abs_new_name;
    name = db_get_memory_resource(DBR_INITIAL_FILE, mod_name, true);
 
    /* directory is set for finding includes. */
    user_file_directory =
        pips_dirname(db_get_memory_resource(DBR_USER_FILE, mod_name, true));
    new_name = db_build_file_resource_name
        (DBR_SOURCE_FILE, mod_name, FORTRAN_FILE_SUFFIX);
 
    dir_name = db_get_current_workspace_directory();
    abs_name = strdup(concatenate(dir_name, "/", name, NULL));
    abs_new_name = strdup(concatenate(dir_name, "/", new_name, NULL));
    free(dir_name);
 
    if (!pips_process_file(abs_name, abs_new_name))
    {
        pips_user_warning("initial file filtering of %s failed\n", mod_name);
        safe_unlink(abs_new_name);
        free(abs_new_name); free(abs_name);
        return false;
    }
    free(abs_new_name); free(abs_name);
    free(user_file_directory), user_file_directory = NULL;
 
    DB_PUT_NEW_FILE_RESOURCE(DBR_SOURCE_FILE, mod_name, new_name);
    return true;
}

References concatenate(), db_build_file_resource_name(), db_get_current_workspace_directory(), db_get_memory_resource(), DB_PUT_NEW_FILE_RESOURCE, free(), pips_dirname(), pips_process_file(), pips_user_warning, safe_unlink(), strdup(), and user_file_directory.

Here is the call graph for this function:

find_eol_coding()

int find_eol_coding

(

string

name

)

Returns the newly allocated name if preprocessing succeeds.

Returns NULL if preprocessing fails.

Parameters

name

ame

Definition at line 721 of file source_file.c.

{
  FILE * f = safe_fopen(name, "r");
  int state =0;
  int eol_code = -1;
  int c;
 
  while((c=getc(f))!=EOF) {
    if(c=='\n') {
      if(state==1)
        eol_code = 1; // DOS
      else
        eol_code = 0; // UNIX
      break;
    }
    else if(c=='\r')
      state = 1;
    else {
      if(state==1) {
        eol_code = 2; // ISO22
        break;
      }
    }
  }
 
  safe_fclose(f, name);
 
  return eol_code;
}

References f(), safe_fclose(), and safe_fopen().

Referenced by process_thru_C_pp().

Here is the call graph for this function:

Here is the caller graph for this function:

flag_as_stub()

bool flag_as_stub

(

const

string

)

Parameters

string

odule_name

Definition at line 1334 of file source_file.c.

                                            {
  if (!db_resource_p(DBR_STUBS, ""))
    pips_internal_error("stubs not initialized");
  callees stubs=(callees)db_get_memory_resource(DBR_STUBS,"",true);
  callees_callees(stubs)= CONS(STRING,strdup(module_name),callees_callees(stubs));
  DB_PUT_MEMORY_RESOURCE(DBR_STUBS,"",stubs);
  return true;
 
}

References callees_callees, CONS, db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, db_resource_p(), module_name(), pips_internal_error, strdup(), and STRING.

Referenced by generic_initializer().

Here is the call graph for this function:

Here is the caller graph for this function:

force_reset_preprocessor_scope_stack()

void force_reset_preprocessor_scope_stack

(

void

)

To be used by an error handler.

Definition at line 297 of file splitc.c.

 {
   if(c_preprocessor_scope_stack != stack_undefined) {
       stack_free(&c_preprocessor_scope_stack);
       c_preprocessor_scope_stack = stack_undefined;
   }
   c_preprocessor_scope_number = SCOPE_UNDEFINED;
   return;
 }

References c_preprocessor_scope_number, c_preprocessor_scope_stack, SCOPE_UNDEFINED, stack_free(), and stack_undefined.

Here is the call graph for this function:

ForceResetTypedefStack()

void ForceResetTypedefStack

(

void

)

Definition at line 259 of file splitc.c.

{
     stack_free(&TypedefStack);
     TypedefStack = stack_undefined;
}

References stack_free(), stack_undefined, and TypedefStack.

Referenced by csplit_close_files().

Here is the call graph for this function:

Here is the caller graph for this function:

fsplit()

char* fsplit	(	char *	dir_name,
		char *	file_name,
		FILE *	out
	)

output file

1 if got card in output file, 0 otherwise

1 if got name of subprog., 0 otherwise

??? 20 -> 80 because not checked... smaller than a line is ok ? FC

MALLOC STRINGS

look for a temp file that doesn't correspond to an existing file

FC

if no name yet, try and find one

FC: some hack to deal with entry...

FC again

now we gave it a name!

a new module name is appended to the current line...

look for an 'end' statement

while

no lines in file, forget the file

rename the file

out?

for(;;)

Parameters

dir_name	ir_name
file_name	ile_name
out	ut

Definition at line 474 of file split_file.c.

{
  FILE *ofp;    /* output file */
  int rv;       /* 1 if got card in output file, 0 otherwise */
  int nflag,            /* 1 if got name of subprog., 0 otherwise */
    someentry, newname;
  /* ??? 20 -> 80 because not checked... smaller than a line is ok ? FC */
  char name[80];
  char tmpname[80];
 
  /* MALLOC STRINGS
   */
  char * main_list = full_name(dir_name, MAIN_FILE_NAMES);
  x = full_name(dir_name, "###000.f");
  mainp = full_name(dir_name, "main000.f");
  blkp = full_name(dir_name, "data000.f");
 
  current_line_number = 0;
 
  if ((ifp = fopen(file_name, "r")) == NULL) {
    fprintf(stderr, "fsplit: cannot open %s\n", file_name);
    FREE_STRINGS;
    return "cannot open file";
  }
 
  for(;;) {
 
    /* look for a temp file that doesn't correspond to an existing file */
    get_name(x);
    ofp = fopen(x, "w");
    if (ofp==NULL) {
            fprintf(stderr, "%s %s -> %s\n", dir_name, file_name, x);
            fprintf(stderr, "fopen(\"%s\", ...) failed\n", x);
            abort();
    }
 
    nflag = 0;
    rv = 0;
    newname = 0;
    someentry = 0;
 
    while (GetLine() > 0)
    {
      char * error = hollerith_and_bangcomments(buf); /* FC */
      if (error) {
        fclose(ofp);
        fclose(ifp);
        FREE_STRINGS;
        return error;
      }
 
      if (nflag == 0) /* if no name yet, try and find one */
        nflag = lname(name, 0), newname=nflag;
      else { /* FC: some hack to deal with entry... */
        lname(tmpname, 1);
        newname = it_is_an_entry;
        someentry = it_is_an_entry;
        implicit_program = 0;
        it_is_a_main = 0;
        it_is_an_entry = 0;
      }
 
      if (it_is_a_main) {
        FILE * fm = fopen(main_list, "a");
        if (fm==NULL) {
          fprintf(stderr, "fopen(\"%s\", ...) failed\n", main_list);
          // FI: not user friendly...
          abort();
        }
        if (implicit_program_name==1 || implicit_program==1)
          print_name(fm, name, 7, 1);
        else
          put_upper_from_slash_till_dot_or_end(name, fm);
        putc('\n', fm);
        fclose(fm);
        it_is_a_main = 0;
      }
 
      if (implicit_program==1) /* FC again */
            {
        fprintf(ofp,
                "! next line added by fsplit() in pips\n"
                "      PROGRAM ");
        print_name(ofp, name, 7, 0);
        putc('\n', ofp);
        implicit_program = 0; /* now we gave it a name! */
            }
 
            if (implicit_blockdata_name==1 || implicit_program_name==1)
            {
        fprintf(ofp,
                "! next line modified by fsplit() in pips\n"
                "      %s ", 
                implicit_program_name==1? "PROGRAM": "BLOCK DATA");
        print_name(ofp, name, 7, 0);
        putc('\n', ofp);
        implicit_blockdata_name = 0;
        implicit_program_name = 0;
            }
            else
        fprintf(ofp, "%s", buf);
 
            /* a new module name is appended to the current line... */
            if (newname)
            {
        if ((someentry && tmpname[0]) || (!someentry && name[0]))
        {
          put_upper_from_slash_till_dot_or_end
            (someentry? tmpname: name, out);
          putc(' ', out);
        }
        newname = 0;
        someentry = 0;
        tmpname[0] = '\0';
            }
 
            rv = 1;
 
            if (lend())         /* look for an 'end' statement */
        break;
    } /* while */
 
    if (fclose(ofp)) {
            fprintf(stderr, "fclose(ofp) failed\n");
            exit(2);
    }
    if (rv == 0) {                      /* no lines in file, forget the file */
      safe_unlink(x);
      if (fclose(ifp)) {
        fprintf(stderr, "fclose(ifp) failed\n");
        exit(2);
      }
      FREE_STRINGS; return NULL;
    }
    if (nflag)                  /* rename the file */
    {
      if (strncmp(dir_name, name, strlen(dir_name))!=0)
      {
        char * full = full_name(dir_name, name);
        strcpy(name, full);
        free(full);
      }
      if (strcmp(name, x) == 0) {
        printf(/* out? */ "%s\n", x);
      }
      else if (stat(name, &sbuf) < 0 )
      {
        int ok = link(x, name);
        // FC: link() may fail but it is ok?
        if (ok != 0 && ok != -1) abort();
        safe_unlink(x);
        fprintf(out, "%s\n", name);
      }
      else
        printf("%s already exists, put in %s\n", name, x);
      continue;
    }
    fprintf(out, "%s\n", x);
  } /* for(;;) */
 
  if (fclose(ifp)) {
    fprintf(stderr, "fclose(ifp) failed\n");
    exit(2);
  }
  FREE_STRINGS;
  return "bad fsplit() terminaison.";
}

Referenced by pips_split_file().

Here is the caller graph for this function:

get_csplit_current_beginning()

int get_csplit_current_beginning

(

void

)

Definition at line 1190 of file lexer.c.

{
  return csplit_current_beginning;
}

References csplit_current_beginning.

get_csplit_file_offset_beginning()

size_t get_csplit_file_offset_beginning

(

void

)

Get the file position in the file to split where the current function begins:

Definition at line 1205 of file lexer.c.

                                          {
  return csplit_file_offset_beginning;
}

References csplit_file_offset_beginning.

get_current_csplit_file_offset()

size_t get_current_csplit_file_offset

(

void

)

Get the current file position in the file to split:

Definition at line 1211 of file lexer.c.

                                        {
  return current_csplit_file_offset;
}

References current_csplit_file_offset.

get_preprocessor_current_scope()

string get_preprocessor_current_scope

(

void

)

Definition at line 327 of file splitc.c.

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

References c_preprocessor_scope_stack, preprocessor_scope_stack_empty_p(), stack_head(), and string_undefined.

Referenced by is_c_preprocessor_keyword_typedef(), and keep_track_of_typedef().

Here is the call graph for this function:

Here is the caller graph for this function:

get_preprocessor_nth_scope()

string get_preprocessor_nth_scope

(

int

n

)

Definition at line 339 of file splitc.c.

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

References c_preprocessor_scope_stack, and stack_nth().

Referenced by is_c_preprocessor_keyword_typedef().

Here is the call graph for this function:

Here is the caller graph for this function:

get_splitc_input_file_name()

string get_splitc_input_file_name

(

void

)

Definition at line 84 of file csplit_file.c.

{
  return splitc_input_file_name;
}

References splitc_input_file_name.

get_user_current_beginning()

int get_user_current_beginning

(

void

)

Get the current line number in the file to split from the user point of view (before preprocessor expansion):

Definition at line 1198 of file lexer.c.

                                 {
  return user_current_beginning;
}

References user_current_beginning.

hpfc_generate_path_name_of_file_name()

string hpfc_generate_path_name_of_file_name

(

const char *

file_name

)

Return the path of an HPFC file name relative to the current PIPS directory.

Can be freed by the caller.

Parameters

file_name

ile_name

Definition at line 97 of file source_file.c.

{
  string dir_name = db_get_current_workspace_directory(),
    name = strdup(concatenate(
         dir_name, "/", HPFC_COMPILED_FILE_DIR, "/", file_name, NULL));
  free(dir_name);
  return name;
}

References concatenate(), db_get_current_workspace_directory(), file_name, free(), and strdup().

Referenced by notify_hpfc_file_view().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_get_file_list()

int hpfc_get_file_list	(	gen_array_t	file_names,
		char **	hpfc_directory_name
	)

Where is the output of HPFC:

generated files start with upercases

Plain files only:

Parameters

file_names	ile_names
hpfc_directory_name	pfc_directory_name

Definition at line 106 of file source_file.c.

{
  // some static but dynamic buffer.
  static int hpfc_bsz = 0;
  static char * hpfc_dir = NULL;
 
  int return_code, len;
  char * dir = build_pgmwd(db_get_current_workspace_name());
 
  len = strlen(dir) + strlen(HPFC_COMPILED_FILE_DIR) + 5;
 
  if (hpfc_bsz<len) {
    if (hpfc_dir) free(hpfc_dir), hpfc_dir=NULL;
    hpfc_bsz = len;
    hpfc_dir = (char*) malloc(hpfc_bsz);
    message_assert("malloc succeeded", hpfc_dir);
  }
 
  // Get the HPFC file name list:
  sprintf(hpfc_dir, "%s/%s", dir, HPFC_COMPILED_FILE_DIR);
 
  return_code = safe_list_files_in_directory(
    file_names,
    hpfc_dir, /* Where is the output of HPFC: */
    "^[A-Z].*\\.[fh]$", /* generated files start with upercases */
    file_exists_p /* Plain files only: */);
  *hpfc_directory_name = hpfc_dir;
 
  return return_code;
}

References build_pgmwd, db_get_current_workspace_name(), file_exists_p(), free(), malloc(), message_assert, and safe_list_files_in_directory().

Referenced by generate_a_menu_with_HPF_output_files().

Here is the call graph for this function:

Here is the caller graph for this function:

init_module_name_list()

void init_module_name_list

(

void

)

Definition at line 58 of file csplit_file.c.

{
  pips_assert("module_name_list is undefined",
              list_undefined_p(module_name_list));
  module_name_list = NIL;
}

References list_undefined_p, module_name_list, NIL, and pips_assert.

init_preprocessor_scope_stack()

void init_preprocessor_scope_stack

(

void

)

Definition at line 274 of file splitc.c.

 {
   c_preprocessor_scope_number = 0;
   c_preprocessor_scope_stack = stack_make(string_domain, 0, 0);
 }

References c_preprocessor_scope_number, c_preprocessor_scope_stack, stack_make(), and string_domain.

Referenced by csplit().

Here is the call graph for this function:

Here is the caller graph for this function:

init_processed_include_cache()

void init_processed_include_cache

(

void

)

Definition at line 272 of file source_file.c.

{
  // Since these functions are called in different context, the
  // conventional pips_debug() is not well suitable, so revert to plain
  // old fprintf for debug...
  //fprintf(stderr, "[init_processed_include_cache] Entering\n");
  pips_assert("undefined cache", hash_table_undefined_p(processed_cache));
  processed_cache = hash_table_make(hash_string, 100);
}

References hash_string, hash_table_make(), hash_table_undefined_p, pips_assert, and processed_cache.

Referenced by create_workspace(), and open_workspace().

Here is the call graph for this function:

Here is the caller graph for this function:

keep_track_of_typedef()

void keep_track_of_typedef

(

string

type_name

)

Parameters

type_name

ype_name

Definition at line 517 of file csplit_file.c.

{
  string sn = get_preprocessor_current_scope();
  string scoped_type_name = same_string_p(sn,"")? strdup(type_name)
    : strdup(concatenate(type_name, "%", sn, NULL));
  hash_put(keyword_typedef_table, scoped_type_name, (void *) TK_NAMED_TYPE);
  pips_debug(2,"Add typedef name \"%s\" to hash table\n", scoped_type_name);
  if(strcmp(type_name, "v1")==0) {
    pips_debug(1, "v1 added as typedef\n");
  }
  // FI: should we free "name"?
}

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

Here is the call graph for this function:

MakeTypedefStack()

void MakeTypedefStack

(

)

Define some functions from the .l or .y since cproto cannot dig them out:

Definition at line 243 of file splitc.c.

 {
   pips_assert("TypedefStack is undefined", stack_undefined_p(TypedefStack));
   TypedefStack = stack_make(int_domain, 0, 0);
}

pips_change_directory()

string pips_change_directory

(

const char *

dir

)

Change to the given directory if it exists and return a canonical name.

Return NULL if it does not exist, or fails

Parameters

dir

ir

Definition at line 142 of file source_file.c.

{
  if (directory_exists_p(dir))
  {
    int status = chdir(dir);
    if (status==-1)
    {
      perror("chdir");
      return NULL;
    }
    // should check status...
    return get_cwd();
  }
  return NULL;
}

References directory_exists_p(), and get_cwd().

Referenced by end_directory_notify().

Here is the call graph for this function:

Here is the caller graph for this function:

pips_get_fortran_list()

void pips_get_fortran_list

(

gen_array_t

array

)

Select the true file with names ending in ".[fF]" and return a sorted arg list:

Parameters

array

rray

Definition at line 89 of file source_file.c.

{
  list_files_in_directory(array, ".", "^.*\\.[fF]$", file_exists_p);
}

References array, file_exists_p(), and list_files_in_directory().

Referenced by continue_create_workspace_notify().

Here is the call graph for this function:

Here is the caller graph for this function:

pips_get_workspace_list()

void pips_get_workspace_list

(

gen_array_t

array

)

cproto-generated files

source_file.c

cproto-generated files

(For each name, there is a name.database directory in the current directory):

Parameters

array

rray

Definition at line 74 of file source_file.c.

{
  int i, n;
  // Find all directories with name ending with ".database":
  list_files_in_directory(array, ".", "^.*\\.database$", directory_exists_p);
  n = gen_array_nitems(array);
  // Remove the ".database":
  for (i = 0; i < n; i++) {
    *strchr(gen_array_item(array, i), '.') = '\0';
  }
}

References array, directory_exists_p(), gen_array_item(), gen_array_nitems(), and list_files_in_directory().

Referenced by generate_workspace_menu(), open_or_create_workspace(), open_workspace_notify(), and start_delete_workspace_notify().

Here is the call graph for this function:

Here is the caller graph for this function:

pips_srcpath_append()

string pips_srcpath_append

(

string

pathtoadd

)

returns an allocated pointer to the old value

Strdup the string since it is returned and use later in many other places

Parameters

pathtoadd

athtoadd

Definition at line 177 of file source_file.c.

{
  string old_path, new_path;
  old_path = getenv(SRCPATH);
  if (old_path)
    /* Strdup the string since it is returned and use later in many other
       places */
    old_path = strdup(old_path);
  new_path = concatenate(old_path? old_path: "", old_path? ":": "",
                         pathtoadd, NULL);
  pips_srcpath_set(new_path);
  return old_path;
}

References concatenate(), pips_srcpath_set(), SRCPATH, and strdup().

Referenced by parse_arguments(), and step_analyse_init().

Here is the call graph for this function:

Here is the caller graph for this function:

pips_srcpath_set()

void pips_srcpath_set

(

string

path

)

Set the PIPS source path.

Parameters

path	is used to set the search path or to unset if path is NULL

Strangely this environment variable is set many times in PIPS to pass some information...

Parameters

path

ath

Definition at line 167 of file source_file.c.

{
  if (path)
    setenv(SRCPATH, path, true);
  else
    unsetenv(SRCPATH);
}

References SRCPATH.

Referenced by parse_arguments(), pips_srcpath_append(), pop_path(), and safe_pop_path().

Here is the caller graph for this function:

pop_preprocessor_scope()

void pop_preprocessor_scope

(

void

)

Definition at line 316 of file splitc.c.

 {
   stack_pop(c_preprocessor_scope_stack);
   return;
 }

References c_preprocessor_scope_stack, and stack_pop().

Here is the call graph for this function:

preprocessed_to_user_file()

string preprocessed_to_user_file

(

string

preprocessed_user_file

)

Allocate a new string containing the user file name, before preprocessing.

No preprocessing has occured

Parameters

preprocessed_user_file

reprocessed_user_file

Definition at line 617 of file source_file.c.

{
  string user_file = strdup(preprocessed_user_file);
  string suffix = string_undefined;
 
  if ((suffix = find_suffix(user_file, PP_FORTRAN_ED)) != NULL) {
    strcpy(suffix, FORTRAN_FILE_SUFFIX);
  }
  else if((suffix = find_suffix(user_file, PP_C_ED)) != NULL) {
    strcpy(suffix, C_FILE_SUFFIX);
  }
  else {
    /* No preprocessing has occured */
    ;
  }
  return user_file;
}

References find_suffix(), strdup(), string_undefined, and user_file.

Referenced by get_new_user_file().

Here is the call graph for this function:

Here is the caller graph for this function:

preprocessor_init_keyword_typedef_table()

void preprocessor_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 567 of file csplit_file.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 csplit().

Here is the call graph for this function:

Here is the caller graph for this function:

preprocessor_scope_number()

int preprocessor_scope_number

(

void

)

Definition at line 345 of file splitc.c.

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

References c_preprocessor_scope_stack, and stack_size().

Referenced by is_c_preprocessor_keyword_typedef().

Here is the call graph for this function:

Here is the caller graph for this function:

preprocessor_scope_stack_empty_p()

bool preprocessor_scope_stack_empty_p

(

void

)

Definition at line 322 of file splitc.c.

{
  return stack_empty_p(c_preprocessor_scope_stack);
}

References c_preprocessor_scope_stack, and stack_empty_p().

Referenced by get_preprocessor_current_scope().

Here is the call graph for this function:

Here is the caller graph for this function:

process_bang_comments_and_hollerith()

char* process_bang_comments_and_hollerith	(	FILE *	in,
		FILE *	out
	)

processing extracted for includes...

Parameters

in	n
out	ut

Definition at line 836 of file split_file.c.

{
  char * error;
  ifp = in;
  current_line_number = 0;
  while (GetLine()>0) 
  {
    error = hollerith_and_bangcomments(buf);
    if (error) return error;
    fputs(buf, out);
  }
  ifp = NULL;
  return NULL;
}

References buf, current_line_number, error, GetLine(), hollerith_and_bangcomments(), ifp, and out.

Referenced by handle_include_file().

Here is the call graph for this function:

Here is the caller graph for this function:

process_user_file()

bool process_user_file

(

string

file

)

The file is looked for in the pips source path.

Do not check the syntax in the input file: quite dangerous in case it is wrong because PIPS is not designed to work on damaged source codes. But this may be useful is the input file is a validation file or if the input file has already been checked.

If two modules have the same name, the first splitted wins and the other one is hidden by the call since fsplit gives it a zzz00n.f name Let's hope no user module is called ###???.f

The newly created module files are registered in the database The file_list allows split to communicate with this function.

a_line: "MODULE1 ... MODULEn file_name"

The list modules comes from entries that might be included in the subroutine.

For each Fortran module in the line, put the initial_file and user_file resource. In C, line should have only one entry and a C source file and a user file resources are created.

hey, that's cleaning!

Seems to be recorded as a resource, causes problems later when closing the workspace...

unlink(nfile);

Parameters

file

ile

Definition at line 1090 of file source_file.c.

{
  bool success_p = false, cpp_processed_p;
  string dir_name = db_get_current_workspace_directory();
 
  // FC: hmmm this function is not very strict,
  // and sometime we need clean user errors...
  bool generate_user_error =
    get_bool_property("ABORT_ON_USER_ERROR") ||
    get_bool_property("CLOSE_WORKSPACE_AND_QUIT_ON_ERROR");
 
  static int number_of_files = 0;
  static int number_of_modules = 0;
  static int resource_name_conflicts = 0;
 
  number_of_files++;
  pips_debug(1, "file %s (number %d)\n", file, number_of_files);
 
  /* The file is looked for in the pips source path.
   */
  string nfile = find_file_in_directories(file, getenv(SRCPATH));
 
  if (!nfile)
  {
    pips_user_error("Cannot open file: \"%s\"", file);
    return false;
  }
 
  string initial_file = nfile;
  preprocessor_current_initial_file_name = nfile;
 
  // The new file is registered (well, not really...) in the database.
  user_log("Registering file %s\n", file);
 
  bool syntax_ok_p = true;
  if ((dot_F_file_p(nfile) || dot_f_file_p(nfile)) && pips_check_fortran())
  {
    // Note: a Fortran compiler is required on the machine.
    syntax_ok_p = check_fortran_syntax_before_pips(nfile);
  }
  else if (dot_c_file_p(nfile) && pips_check_c()) {
    // Note: a C compiler is required on the machine. Run it.
    syntax_ok_p = check_c_file_syntax(nfile);
  }
  else
  {
    /* Do not check the syntax in the input file: quite dangerous in
       case it is wrong because PIPS is not designed to work on
       damaged source codes. But this may be useful is the input file
       is a validation file or if the input file has already been
       checked. */
    pips_debug(1, "No syntactic check on file \"%s\"\n", nfile);
  }
 
  if (!syntax_ok_p)
  {
    if (generate_user_error)
      pips_user_error("Syntax check failed on \"%s\"", nfile);
    // It is up to the caller to decide if the syntax must be checked
    // for other files as well
    return false;
  }
 
  // CPP if file extension is .F or .c
  // (assumes string_equal_p(nfile, initial_file))
  cpp_processed_p = dot_F_file_p(nfile) || dot_c_file_p(nfile);
 
  if (cpp_processed_p)
  {
    user_log("Preprocessing file %s\n", initial_file);
    nfile = process_thru_cpp(initial_file);
    if (nfile==NULL)
    {
      if (generate_user_error)
        pips_user_error("Cannot preprocess file \"%s\"", initial_file);
      else
        pips_user_warning("Cannot preprocess file: %s\n", initial_file);
      return false;
    }
  }
  else if ( !dot_f_file_p( nfile ) && !dot_f90_file_p( nfile )
              && !dot_f95_file_p( nfile ) ) {
    pips_user_error("Unexpected file extension\n");
  }
 
  /* If two modules have the same name, the first splitted wins
   * and the other one is hidden by the call since fsplit gives
   * it a zzz00n.f name
   * Let's hope no user module is called ###???.f
   */
  string file_list =
    strdup(concatenate(dir_name,
                       dot_c_file_p(nfile)?
                       "/.csplit_file_list" : "/.fsplit_file_list", NULL));
  unlink(file_list);
 
  user_log("Splitting file    %s\n", nfile);
  if (pips_split_file(nfile, file_list))
  {
    if (generate_user_error)
      pips_user_error("error while splitting file \"%s\"", nfile);
    return false;
  }
 
  /* The newly created module files are registered in the database
   * The file_list allows split to communicate with this function.
   */
  FILE * fd = safe_fopen(file_list, "r");
  string a_line;
  while ((a_line = safe_readline(fd)) && resource_name_conflicts == 0)
  {
    string mod_name = NULL, res_name = NULL;
    list modules = NIL;
    bool renamed=false;
 
    /* a_line: "MODULE1 ... MODULEn file_name"
     *
     * The list modules comes from entries that might be included
     * in the subroutine.
     */
    string file_name = extract_last_name(a_line);
    success_p = true;
    number_of_modules++;
    pips_debug(2, "module %s (number %d)\n", file_name, number_of_modules);
 
    while (mod_name!=a_line && (mod_name = extract_last_name(a_line)))
      modules = CONS(STRING, mod_name, modules);
 
    /* For each Fortran module in the line, put the initial_file and
       user_file resource. In C, line should have only one entry and a C
       source file and a user file resources are created. */
    FOREACH(STRING, mod_name, modules)
    {
      user_log("  Module         %s\n", mod_name);
 
      if (!renamed)
      {
        FILE * rf = NULL;
 
        if (dot_c_file_p(nfile)) {
          res_name = db_build_file_resource_name
            (DBR_C_SOURCE_FILE, mod_name, C_FILE_SUFFIX);
        }
        else {
          res_name = db_build_file_resource_name
            (DBR_INITIAL_FILE, mod_name, FORTRAN_INITIAL_FILE_SUFFIX);
        }
 
        string abs_res = strdup(concatenate(dir_name, "/", res_name, NULL));
 
        if ((rf = fopen(abs_res, "r"))!=NULL)
        { // Resource name conflict
          string ofile =
            db_get_memory_resource(DBR_USER_FILE, mod_name, true);
 
          fclose(rf);
          pips_user_warning("Duplicate module name \"%s\""
                            " from files \"%s\" and \"%s\".\n",
                            res_name, ofile, nfile);
          resource_name_conflicts++;
          break;
        }
 
        if (rename(file_name, abs_res))
          pips_internal_error("mv %s %s failed", file_name, res_name);
        renamed = true;
        free(abs_res);
      }
 
      if(dot_c_file_p(nfile)) {
        DB_PUT_NEW_FILE_RESOURCE(DBR_C_SOURCE_FILE, mod_name,
                                 strdup(res_name));
        DB_PUT_NEW_FILE_RESOURCE(DBR_INPUT_FILE_NAME, mod_name,
                                 strdup(initial_file));
      }
      else {
        DB_PUT_NEW_FILE_RESOURCE(DBR_INITIAL_FILE, mod_name,
                                 strdup(res_name));
      }
      // from which file the initial source was derived.
      // absolute path to the file so that db moves should be ok?
      DB_PUT_NEW_FILE_RESOURCE(DBR_USER_FILE, mod_name, strdup(nfile));
 
      if ( dot_f90_file_p( nfile ) || dot_f95_file_p( nfile ) )
      {
        char *parsedcode_filename =
          get_resource_file_name(DBR_PARSED_CODE, mod_name);
        FILE *parsedcode_file = safe_fopen( parsedcode_filename, "r" );
        DB_PUT_NEW_FILE_RESOURCE(DBR_PARSED_CODE, mod_name,
                                 gen_read( parsedcode_file ));
        safe_fclose( parsedcode_file, parsedcode_filename );
        char *callees_filename =
          get_resource_file_name( DBR_CALLEES, mod_name );
        FILE *callees_file = safe_fopen( callees_filename, "r" );
        DB_PUT_NEW_FILE_RESOURCE(DBR_CALLEES, mod_name,
                                 gen_read( callees_file ) );
        safe_fclose( callees_file, callees_filename );
        string source_file_name =
          strdup(concatenate(dir_name, "/", mod_name, "/", mod_name, ".f90",
                             NULL));
        DB_PUT_NEW_FILE_RESOURCE( DBR_SOURCE_FILE, mod_name, source_file_name );
      }
    }
 
    gen_free_list(modules), modules=NIL;
 
    if (res_name) free(res_name), res_name = NULL;
    free(a_line);
  }
 
  safe_fclose(fd, file_list);
  unlink(file_list);
  free(file_list);
  free(dir_name);
 
  if (cpp_processed_p) {
    free(initial_file); /* hey, that's cleaning! */
    preprocessor_current_initial_file_name = string_undefined;
  }
 
  if (!success_p)
  {
    // empty file... ???
    pips_user_warning("No module was found when splitting file %s.\n", nfile);
  }
 
  if (cpp_processed_p) {
    // nfile is not the initial file
    pips_debug(1, "Remove output of preprocessing: %s\n", nfile);
    /* Seems to be recorded as a resource, causes problems later when
       closing the workspace... */
    /* unlink(nfile); */
  }
  free(nfile);
 
  // well, returns ok whether modules were found or not,
  // but do not accept name conflicts.
  return resource_name_conflicts==0;
}

References check_c_file_syntax(), check_fortran_syntax_before_pips(), concatenate(), CONS, db_build_file_resource_name(), db_get_current_workspace_directory(), db_get_memory_resource(), DB_PUT_NEW_FILE_RESOURCE, dot_c_file_p(), dot_f90_file_p(), dot_f95_file_p(), dot_F_file_p(), dot_f_file_p(), extract_last_name(), file_name, find_file_in_directories(), FOREACH, free(), gen_free_list(), gen_read(), get_bool_property(), get_resource_file_name(), NIL, pips_check_c(), pips_check_fortran(), pips_debug, pips_internal_error, pips_split_file(), pips_user_error, pips_user_warning, preprocessor_current_initial_file_name, process_thru_cpp(), safe_fclose(), safe_fopen(), safe_readline(), SRCPATH, strdup(), STRING, string_undefined, and user_log().

Referenced by add_a_file(), ask_a_missing_file(), create_workspace(), retrieve_a_missing_file_using_external_resolver(), and retrieve_a_missing_file_using_internal_resolver().

Here is the call graph for this function:

Here is the caller graph for this function:

push_new_preprocessor_scope()

void push_new_preprocessor_scope

(

void

)

Definition at line 307 of file splitc.c.

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

References asprintf, c_preprocessor_scope_number, c_preprocessor_scope_stack, stack_push(), and string_undefined.

Here is the call graph for this function:

reset_csplit_current_beginning()

void reset_csplit_current_beginning

(

void

)

This function is called at the end of any top-level C construct:

Snapshot the current file position as a potential function begin:

Aggregate following spaces and comments on the sameline to the previous top-level construct:

FI: I'm not ready to abort() here...

Definition at line 1152 of file lexer.c.

{
  int leaked = 0;
 
  csplit_current_beginning = 1000000;
  user_current_beginning = 1000000;
  csplit_is_static_p = false;
 
  /* Snapshot the current file position as a potential function begin: */
  csplit_file_offset_beginning = current_csplit_file_offset;
 
  /* Aggregate following spaces and comments on the sameline to the
     previous top-level construct: */
  gather_comment_state_machine = GATHER_COMMENT;
 
 
  if(!string_undefined_p(csplit_current_function_name))
    free(csplit_current_function_name);
  csplit_current_function_name = string_undefined;
 
  if(!string_undefined_p(csplit_current_function_name2))
    free(csplit_current_function_name2);
  csplit_current_function_name2 = string_undefined;
 
  if(!string_undefined_p(csplit_definite_function_name))
    free(csplit_definite_function_name);
  csplit_definite_function_name = string_undefined;
 
  if(!string_undefined_p(csplit_definite_function_signature))
    free(csplit_definite_function_signature);
  csplit_definite_function_signature = string_undefined;
 
  if((leaked=check_signature_balance())!=0) {
    /* FI: I'm not ready to abort() here... */
    pips_debug(5, "Likely memory leaks: %d\n", leaked);
  }
}

References check_signature_balance(), csplit_current_beginning, csplit_current_function_name, csplit_current_function_name2, csplit_definite_function_name, csplit_definite_function_signature, csplit_file_offset_beginning, csplit_is_static_p, current_csplit_file_offset, free(), GATHER_COMMENT, gather_comment_state_machine, pips_debug, string_undefined, string_undefined_p, and user_current_beginning.

Here is the call graph for this function:

reset_csplit_line_number()

void reset_csplit_line_number

(

void

)

Reinitialise global position numbers for a new file.

Definition at line 1124 of file lexer.c.

{
  csplit_line_number = 1;
  user_line_number = 1;
  current_csplit_file_offset = 0;
  csplit_file_offset_beginning = 0;
  gather_comment_state_machine = PUT_IN_NEXT_TOP_LEVEL_CONSTRUCT;
  bracket_depth = 0;
}

References bracket_depth, csplit_file_offset_beginning, csplit_line_number, current_csplit_file_offset, gather_comment_state_machine, PUT_IN_NEXT_TOP_LEVEL_CONSTRUCT, and user_line_number.

Referenced by csplit_error_handler(), and csplit_reset().

Here is the caller graph for this function:

reset_current_input_line()

void reset_current_input_line

(

void

)

In file just above.

Definition at line 93 of file csplit_file.c.

{
  current_input_line = 0;
}

References current_input_line.

Referenced by csplit_error_handler(), and csplit_reset().

Here is the caller graph for this function:

reset_module_name_list()

void reset_module_name_list

(

void

)

Definition at line 65 of file csplit_file.c.

{
  pips_assert("module_name_list is not undefined",
              !list_undefined_p(module_name_list));
  gen_free_list(module_name_list);
  module_name_list = list_undefined;
}

References gen_free_list(), list_undefined, list_undefined_p, module_name_list, and pips_assert.

Referenced by error_reset_module_name_list().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_preprocessor_scope_stack()

void reset_preprocessor_scope_stack

(

void

)

Definition at line 280 of file splitc.c.

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

References c_preprocessor_scope_number, c_preprocessor_scope_stack, pips_user_warning, SCOPE_UNDEFINED, stack_empty_p(), stack_free(), and stack_undefined.

Referenced by csplit_close_compilation_unit().

Here is the call graph for this function:

Here is the caller graph for this function:

ResetTypedefStack()

void ResetTypedefStack

(

)

Definition at line 249 of file splitc.c.

 {
   if(stack_empty_p(TypedefStack)) {
     stack_free(&TypedefStack);
     TypedefStack = stack_undefined;
   }
   else
     pips_internal_error("TypedefStack is not empty");
 }

splitc_alloc()

void* splitc_alloc

(

yy_size_t

)

splitc_error()

void splitc_error

(

const char *

)

splitc_free()

void splitc_free

(

void *

)

splitc_get_debug()

int splitc_get_debug

(

void

)

splitc_get_in()

FILE* splitc_get_in

(

void

)

splitc_get_leng()

int splitc_get_leng

(

void

)

splitc_get_lineno()

int splitc_get_lineno

(

void

)

splitc_get_out()

FILE* splitc_get_out

(

void

)

splitc_get_text()

char* splitc_get_text

(

void

)

splitc_lex()

int splitc_lex

(

)

splitc_lex_destroy()

int splitc_lex_destroy

(

)

splitc_parse()

int splitc_parse

(

)

splitc_pop_buffer_state()

void splitc_pop_buffer_state

(

void

)

splitc_realloc()

void* splitc_realloc	(	void *	,
		yy_size_t
	)

splitc_restart()

void splitc_restart

(

FILE *

)

splitc_set_debug()

void splitc_set_debug

(

int

)

splitc_set_in()

void splitc_set_in

(

FILE *

)

splitc_set_lineno()

void splitc_set_lineno

(

int

)

splitc_set_out()

void splitc_set_out

(

FILE *

)

splitc_wrap()

int splitc_wrap

(

void

)

update_csplit_file_offset_information()

void update_csplit_file_offset_information

(

void

)

Function called each time a token is read to trac file position information:

Definition at line 1218 of file lexer.c.

                                             {
  current_csplit_file_offset += yyleng;
}

References current_csplit_file_offset, and yyleng.

workspace_language()

language workspace_language

(

gen_array_t

files

)

Choose a language if all filenames in "files" have the same C or Fortran extensions.

Parameters

files

iles

Definition at line 667 of file source_file.c.

{
  int i, argc = gen_array_nitems(files);
  language l = language_undefined;
  int n_fortran = 0;
  int n_fortran95 = 0;
  int n_c = 0;
 
  for (i = 0; i < argc; i++) {
    string fn = gen_array_item(files, i);
    if(dot_F_file_p(fn) || dot_f_file_p(fn))
      n_fortran++;
    else if(dot_c_file_p(fn))
      n_c++;
    else if(dot_f90_file_p(fn) || dot_f95_file_p(fn)){
      n_fortran95++;
    } else {
      ;
    }
  }
 
  if(n_fortran>0 && n_fortran95==0 && n_c==0) {
    l = make_language_fortran();
  } else if(n_fortran==0 && n_fortran95>0 && n_c==0) {
    l = make_language_fortran95();
  } else if(n_fortran==0 && n_fortran95==0 && n_c>0) {
    l = make_language_c();
  } else {
    l = make_language_unknown();
  }
 
  return l;
}

References dot_c_file_p(), dot_f90_file_p(), dot_f95_file_p(), dot_F_file_p(), dot_f_file_p(), gen_array_item(), gen_array_nitems(), language_undefined, make_language_c(), make_language_fortran(), make_language_fortran95(), and make_language_unknown().

Referenced by add_a_file(), and create_workspace().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

csplit_current_function_name

string csplit_current_function_name

extern

to know if this is the declaration of a function or not, to distinguish between a static variable and a static function

Shared with the lexical analyzer

Definition at line 123 of file splitc.c.

Referenced by reset_csplit_current_beginning(), and reset_csplit_current_function_name().

csplit_current_function_name2

string csplit_current_function_name2

extern

Definition at line 124 of file splitc.c.

Referenced by reset_csplit_current_beginning(), and reset_csplit_current_function_name().

csplit_definite_function_name

string csplit_definite_function_name

extern

Definition at line 125 of file splitc.c.

Referenced by reset_csplit_current_beginning().

csplit_definite_function_signature

string csplit_definite_function_signature

extern

Definition at line 126 of file splitc.c.

Referenced by reset_csplit_current_beginning().

csplit_file_offset_beginning

size_t csplit_file_offset_beginning

extern

Definition at line 1093 of file lexer.c.

Referenced by get_csplit_file_offset_beginning(), reset_csplit_current_beginning(), and reset_csplit_line_number().

csplit_is_external

int csplit_is_external

extern

splitc.c

splitc.c

For the moment, block scope is not considered. CurrentScope can be File, Module, File'FILE_SEP_STRING'Module or TOP-LEVEL static string CurrentScope = NULL; static string CurrentDerivedName = NULL; to remember the name of a struct and add it to the member prefix name static int CurrentMode = 0; to know the mode of the formal parameter : by value or by reference

Definition at line 119 of file splitc.c.

csplit_is_function

int csplit_is_function

extern

to know if the variable is declared inside or outside a function

Definition at line 120 of file splitc.c.

csplit_is_static_p

bool csplit_is_static_p

extern

static int enum_counter = 0;

Shared with the lexical analyzer

Definition at line 143 of file splitc.c.

Referenced by reset_csplit_current_beginning().

csplit_line_number

int csplit_line_number

extern

To be exported to the parser for splitting the preprocessed file.

Definition at line 1085 of file lexer.c.

Referenced by csplit_parser_warning_alist(), reset_csplit_line_number(), and update_csplit_current_beginning().

current_csplit_file_offset

size_t current_csplit_file_offset

extern

Definition at line 1092 of file lexer.c.

Referenced by get_current_csplit_file_offset(), reset_csplit_current_beginning(), reset_csplit_line_number(), and update_csplit_file_offset_information().

current_file_name

string current_file_name

extern

Split a C file into one file per module (function or procedure) plus.

Parameters

dir_name	the directory name where the input file is to pick
file_name	the C input file name to split
out	file opened to record module and compilation unit names

Returns

an error message or NULL if no error has occurred.

Definition at line 640 of file csplit_file.c.

Referenced by csplit(), and csplit_parser_error().

current_file_path

char* current_file_path

extern

Definition at line 52 of file csplit_file.c.

Referenced by csplit(), and csplit_close_files().

current_include_file_path

char* current_include_file_path

extern

csplit_file.c

csplit_file.c

Definition at line 51 of file csplit_file.c.

Referenced by csplit(), csplit_close_files(), and csplit_copy().

fsplit_copyright

char fsplit_copyright[]

extern

split_file.c

Definition at line 114 of file split_file.c.

fsplit_sccsid

char fsplit_sccsid[]

extern

not lint

Definition at line 120 of file split_file.c.

gather_comment_state_machine

enum gather_comment_state_t gather_comment_state_machine

extern

Indeed it does not work since csplit_copy() is called from splitc.y when a function definition is found and thus we cannot gather the comment in it...

:-(

Definition at line 1096 of file lexer.c.

Referenced by reset_csplit_current_beginning(), reset_csplit_line_number(), and update_csplit_current_beginning().

preprocessor_current_initial_file_name

string preprocessor_current_initial_file_name

extern

The digestion of a user file by PIPS begins here.

The file is searched in the SRCPATH directories.

Definition at line 1088 of file source_file.c.

Referenced by csplit_copy(), csplit_parser_warning_alist(), and process_user_file().

preprocessor_current_split_file_name

string preprocessor_current_split_file_name

extern

Split a C or Fortran file into as many files as modules.

Definition at line 584 of file source_file.c.

Referenced by csplit_parser_warning_alist(), and pips_split_file().

splitc__flex_debug

int splitc__flex_debug

extern

splitc_char

int splitc_char

extern

splitc_in

FILE* splitc_in

extern

Definition at line 174 of file preprocessor.h.

splitc_leng

int splitc_leng

extern

lexer.c

splitc_lineno

int splitc_lineno

extern

splitc_nerrs

int splitc_nerrs

extern

splitc_out

FILE* splitc_out

extern

splitc_text

char* splitc_text

extern

Definition at line 178 of file preprocessor.h.

user_line_number

int user_line_number

extern

To be exported to the parser for error messages related to the user file.

Definition at line 1087 of file lexer.c.

Referenced by c_parser_error(), reset_csplit_line_number(), and update_csplit_current_beginning().