tpips.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <unistd.h>
#include <strings.h>
#include <sys/param.h>
#include <getopt.h>
#include <readline/readline.h>
#include <readline/history.h>
#include "linear.h"
#include "genC.h"
#include "ri.h"
#include "database.h"
#include "misc.h"
#include "newgen.h"
#include "ri-util.h"
#include "pipsdbm.h"
#include "properties.h"
#include "constants.h"
#include "resources.h"
#include "pipsmake.h"
#include "preprocessor.h"
#include "top-level.h"
#include "tpips.h"
#include "completion_list.h"

Include dependency graph for tpips.c:

Go to the source code of this file.

Data Structures
struct	t_completion_scheme

Macros
#define	tpips_usage
	tp_lex.c More...
#define	SEPARATOR_P(c)   (index (" \t", c))
#define	TPIPS_IS_A_SHELL   "TPIPS_IS_A_SHELL"
	Whether pips should behave as a shell. More...
#define	JPIPS_TAG   "#jpips:"
	jpips specials. More...
#define	RESERVED_FOR_FILENAME   (char**) 0x01
#define	BEGIN_RQ   "begin_user_request"
	Tpips user request. More...
#define	END_RQ   "end_user_request"
#define	BEGIN_UE   "begin_user_error"
#define	END_UE   "end_user_error"
#define	TP_HELP(prefix, simple, full)
	Handlers. More...
#define	CACHED_STRING_LIST(NAME)

Enumerations
enum	COMPLETION_TYPES {   COMP_NONE , COMP_FILENAME , COMP_MODULE , COMP_RULE ,   COMP_RESOURCE , COMP_PROPERTY , COMP_HELP_TOPIC , COMP_FILE_RSC }

Functions
string	tpips_current_file_name ()
int	tpips_current_line_number ()
void	tpips_next_line (void)
int	tpips_current_line (void)
string	tpips_current_name (void)
int	tgetnum ()
void	tp_restart (FILE *)
static bool	prefix_equal_p (string str, string prf)
static bool	string_is_true (string s)
bool	tpips_behaves_like_a_shell (void)
FILE *	jpips_out_file (void)
void	jpips_begin_tag (string s)
void	jpips_add_tag (string s)
void	jpips_end_tag (void)
void	jpips_tag (string s)
void	jpips_tag2 (string s1, string s2)
void	jpips_done (void)
void	jpips_string (const char *a_message_format, va_list some_arguments)
void	jpips_printf (const string format,...)
static char *	fun_generator (const char *texte, int state)
	Generator function for command completion. More...
char **	get_module_names (void)
	Build an array with the names of all available modules. More...
static char *	param_generator (const char *texte, int state)
	Generator function for param. More...
static char **	fun_completion (char *texte, int start, int end)
	Attempt to complete on the contents of TEXT. More...
static void	initialize_readline (void)
	Tell the GNU Readline library how to complete. More...
static char *	get_next_line (char *prompt)
	returns the next line from the input, interactive tty or file... More...
static char *	tpips_read_a_line (char *main_prompt)
	returns an allocated line read, including continuations. More...
static string	tpips_user_request (const char *fmt, va_list *args)
static void	tpips_user_error (const char *calling_function_name, const char *format, va_list *args)
	handle a user error DO NOT TERMINATE here, see pips_log_end More...
void	tpips_internal_error (_UNUSED_ const char *calling_function_name, _UNUSED_ const char *a_message_format,...)
	In case of a tpips internal error, either core dump or try to save the workspace. More...
static string	default_hist_file_name (void)
	returns the allocated full tpips history file name, i.e. More...
static void	initialize_tpips_history (void)
void	tpips_help (string line)
static void	close_workspace_if_opened (bool is_quit)
void	tpips_close (void)
void	tpips_set_line_to_parse (char *)
	in lex file More...
char *	tpips_get_line_to_parse (void)
static void	handle (string line)
static bool	line_with_substitutions (string line)
	whether some substitutions are needed... More...
static string	tp_substitutions (string line)
	returns an allocated string after shell substitutions. More...
void	tpips_init (void)
static bool	blank_or_comment_line_p (string line)
static void	tpips_exec (char *line)
void	tpips_process_a_file (FILE *file, string name, bool use_rl)
	processing command line per line. More...
static string	default_tpipsrc (void)
	default .tpipsrc is $HOME/.tpipsrc. More...
static void	open_logfile (string filename, char opt)
static void	parse_arguments (int argc, char *argv[])
int	tpips_main (int argc, char *argv[])
	MAIN: interactive loop and history management. More...

Variables
bool	tpips_execution_mode = true
	Sometimes, already included by unistd.h. More...
bool	tpips_is_interactive = false
static bool	tpips_is_a_shell = false
static bool	use_readline = false
static FILE *	logfile
static FILE *	current_file = NULL
	current file being processed, with its name and the line number More...
static string	current_name = "<unknown>"
static int	current_line = 0
bool	jpips_is_running = false
static FILE *	in_from_jpips
	Ronan suggested a signal driven handling of jpips requests, so as to let the prompt available for direct commands. More...
static FILE *	out_to_jpips
static char **	current_completion_array
static struct t_completion_scheme	completion_scheme []
static char *	tp_help_topics []
bool	tpips_init_done = false
	variable globale, utilisee par le parser helas More...
bool	consistency_enforced_p = false
	Pipsmake does not enforce consistency when properties are changed. More...
char *	optarg
int	optind
const char *	soft_revisions
	could be shared somewhere? More...
const char *	soft_date
const char *	cc_version

Macro Definition Documentation

BEGIN_RQ

#define BEGIN_RQ   "begin_user_request"

Tpips user request.

Definition at line 568 of file tpips.c.

BEGIN_UE

#define BEGIN_UE   "begin_user_error"

Definition at line 605 of file tpips.c.

CACHED_STRING_LIST

#define CACHED_STRING_LIST

(

NAME

)

Value:

  bool NAME##_name_p(string name)                                       \
  {                                                                     \
    static hash_table cache = NULL;                                     \
    if (!cache) {                                                       \
      char ** p;                                                        \
      cache = hash_table_make(hash_string,                              \
                            2*sizeof(tp_##NAME##_names)/sizeof(char*)); \
      for (p=tp_##NAME##_names; *p; p++)                                \
        hash_put(cache, *p, (char*) 1);                                 \
    }                                                                   \
                                                                        \
    return hash_get(cache, name)!=HASH_UNDEFINED_VALUE;                 \
  }

Definition at line 1324 of file tpips.c.

END_RQ

#define END_RQ   "end_user_request"

Definition at line 569 of file tpips.c.

END_UE

#define END_UE   "end_user_error"

Definition at line 606 of file tpips.c.

JPIPS_TAG

#define JPIPS_TAG   "#jpips:"

jpips specials.

#jpips: modules MAIN FOO BLA... #jpips: prop ... #jpips: done #jpips: begin_user_error ... #jpips: end_user_error #jpips: show ... #jpips: {begin,end}_user_request #jpips:

Definition at line 164 of file tpips.c.

RESERVED_FOR_FILENAME

#define RESERVED_FOR_FILENAME   (char**) 0x01

SEPARATOR_P

#define SEPARATOR_P

(

c

)

(index (" \t", c))

Definition at line 123 of file tpips.c.

TP_HELP

#define TP_HELP	(		prefix,
			simple,
			full
	)

Value:

  if (!*line || prefix_equal_p(line, prefix)) {  \
    printf(simple); if (*line) printf(full);}

Handlers.

Definition at line 684 of file tpips.c.

TPIPS_IS_A_SHELL

#define TPIPS_IS_A_SHELL   "TPIPS_IS_A_SHELL"

Whether pips should behave as a shell.

Can be turned on from the command line, from properties and from the environment. Default is FALSE.

Definition at line 141 of file tpips.c.

tpips_usage

#define tpips_usage

Value:

  "Usage: %s [-nscvh?jwa] "                                             \
  "[-l logfile] [-r rcfile] [-e tpips-cmds] tpips-scripts\n"            \
  "\t-n: no execution mode. just to check a script for syntax errors\n" \
  "\t-s: behaves like a shell. tpips commands simply extend a shell.\n" \
  "\t-c: behaves like a command, not a shell (it is the default).\n"    \
  "\t-h: this help. (also -?)\n"                                        \
  "\t-v: display version and architecture informations.\n"              \
  "\t-a: create a logfile automatically.\n"                             \
  "\t-j: jpips special mode.\n"                                         \
  "\t-w: starts with a wrapper (jpips special again)...\n"              \
  "\t-l  logfile: log to logfile.\n"                                    \
  "\t-r  rcfile: tpips rc file to source. (default ~/.tpipsrc)\n"       \
  "\t-x  xml-logfile: log to this file in XML.\n"                       \
  "\t-e  tpips-cmds: here tpips commands.\n"                            \
  "\n"

tp_lex.c

Definition at line 106 of file tpips.c.

Enumeration Type Documentation

COMPLETION_TYPES

enum COMPLETION_TYPES

Enumerator
COMP_NONE
COMP_FILENAME
COMP_MODULE
COMP_RULE
COMP_RESOURCE
COMP_PROPERTY
COMP_HELP_TOPIC
COMP_FILE_RSC

Definition at line 241 of file tpips.c.

                      {
  COMP_NONE,
  COMP_FILENAME,
  COMP_MODULE,
  COMP_RULE,
  COMP_RESOURCE,
  COMP_PROPERTY,
  COMP_HELP_TOPIC,
  COMP_FILE_RSC
};

Function Documentation

blank_or_comment_line_p()

static bool blank_or_comment_line_p ( string  line )

static

Definition at line 994 of file tpips.c.

{
  skip_blanks(line);
  return line[0]==TPIPS_COMMENT_PREFIX || line[0]=='\0';
}

References line, skip_blanks, and TPIPS_COMMENT_PREFIX.

Referenced by tpips_exec().

Here is the caller graph for this function:

close_workspace_if_opened()

static void close_workspace_if_opened ( bool  is_quit )

static

Definition at line 862 of file tpips.c.

{
  if (db_get_current_workspace_name())
    close_workspace(is_quit);
}

References close_workspace(), and db_get_current_workspace_name().

Referenced by tpips_close().

Here is the call graph for this function:

Here is the caller graph for this function:

default_hist_file_name()

static string default_hist_file_name ( void  )

static

returns the allocated full tpips history file name, i.e.

• $TPIPS_HISTORY (if any)
• $HOME/"TPIPS_HISTORY"

else builds the default name.

Definition at line 662 of file tpips.c.

{
  string home, hist = getenv(TPIPS_HISTENV);
  if (hist) return strdup(hist);
  /* else builds the default name.
   */
  home = getenv("HOME");
  return strdup(concatenate(home? home: "", "/", TPIPS_HISTORY, NULL));
}

References concatenate(), strdup(), TPIPS_HISTENV, and TPIPS_HISTORY.

Referenced by initialize_tpips_history(), and tpips_close().

Here is the call graph for this function:

Here is the caller graph for this function:

default_tpipsrc()

static string default_tpipsrc ( void  )

static

default .tpipsrc is $HOME/.tpipsrc.

the returned string is allocated.

Definition at line 1104 of file tpips.c.

{
  return strdup(concatenate(getenv("HOME"), "/.tpipsrc", NULL));
}

References concatenate(), and strdup().

Referenced by parse_arguments().

Here is the call graph for this function:

Here is the caller graph for this function:

fun_completion()

static char** fun_completion ( char *  texte, int  start, int  end  )

static

Attempt to complete on the contents of TEXT.

START and END show the region of TEXT that contains the word to complete. We can use the entire line in case we want to do some simple parsing. Return the array of matches, or NULL if there aren't any.

If this word is at the start of the line, then it is a command to complete. Otherwise it is the name of a file in the current directory.

Definition at line 478 of file tpips.c.

{
 
  char **matches;
 
  matches = (char **)NULL;
 
  /* If this word is at the start of the line, then it is a command
     to complete.  Otherwise it is the name of a file in the current
     directory. */
  if (start == 0)
  {
    pips_debug (9, "completing function (START = %d, END= %d)\n\n",
                start, end);
    matches = rl_completion_matches (texte , fun_generator);
  }
  return matches;
}

References end, fun_generator(), matches, pips_debug, and start.

Referenced by initialize_readline().

Here is the call graph for this function:

Here is the caller graph for this function:

fun_generator()

static char* fun_generator ( const char *  texte, int  state  )

static

Generator function for command completion.

STATE lets us know whether to start from scratch; without any state (i.e. STATE == 0), then we start at the top of the list.

If this is a new word to complete, initialize now. This includes saving the length of TEXT for efficiency, and initializing the index variable to 0.

Return the next name which partially matches from the command list.

If no names matched, then return NULL.

Definition at line 302 of file tpips.c.

{
  static int list_index, len;
  char *name;
 
  /* If this is a new word to complete, initialize now.  This includes
     saving the length of TEXT for efficiency, and initializing the index
     variable to 0. */
  if (!state)
  {
    list_index = 0;
    len = strlen (texte);
  }
 
  /* Return the next name which partially matches from the command list. */
  while ((name = completion_scheme[list_index].fun_name))
  {
    list_index++;
 
    if (strncmp (name, texte, len) == 0)
      return (strdup(name));
  }
 
  /* If no names matched, then return NULL. */
  return NULL;
}

References completion_scheme, t_completion_scheme::fun_name, and strdup().

Referenced by fun_completion().

Here is the call graph for this function:

Here is the caller graph for this function:

get_module_names()

char** get_module_names

(

void

)

Build an array with the names of all available modules.

Free after a previous use:

By default, no available module:

Mainly inspired from wpips/emacs.c

Overkilling since most of time, the module list does not change but I guess there is no indicator in PIPS to tell some modules have been created or destroyed.

Note that since calloc initialize the memory to 0, this array will end with a NULL pointer as expected.

Definition at line 332 of file tpips.c.

{
  static char **names = NULL;
  static gen_array_t modules = NULL;
 
  if (names != NULL) {
    /* Free after a previous use: */
    free(names);
    gen_array_full_free(modules);
    /* By default, no available module: */
    names = NULL;
  }
 
  /* Mainly inspired from wpips/emacs.c
 
     Overkilling since most of time, the module list does not change but I
     guess there is no indicator in PIPS to tell some modules have been
     created or destroyed. */
  if (db_get_current_workspace_name() != NULL) {
    int module_list_length, i;
    modules = db_get_module_list();
    module_list_length = gen_array_nitems(modules);
    /* Note that since calloc initialize the memory to 0, this array will
       end with a NULL pointer as expected. */
    names = calloc(module_list_length + 1, sizeof(char *));
    for(i = 0; i < module_list_length; i++)
      names[i] = gen_array_item(modules, i);
  }
  return names;
}

References db_get_current_workspace_name(), db_get_module_list(), free(), gen_array_full_free(), gen_array_item(), and gen_array_nitems().

Referenced by param_generator().

Here is the call graph for this function:

Here is the caller graph for this function:

get_next_line()

static char* get_next_line ( char *  prompt )

static

returns the next line from the input, interactive tty or file...

the final
does not appear.

Definition at line 529 of file tpips.c.

{
  tpips_next_line();
  return use_readline? readline(prompt): safe_readline(current_file);
}

References current_file, safe_readline(), tpips_next_line(), and use_readline.

Referenced by tpips_read_a_line().

Here is the call graph for this function:

Here is the caller graph for this function:

handle()

static void handle ( string  line )

static

parse if non-null line

Definition at line 894 of file tpips.c.

{
  tpips_set_line_to_parse(line);
 
  /* parse if non-null line */
  if (*tpips_get_line_to_parse()) {
    tp_init_lex ();
    tp_parse ();
  }
 
  fflush(stderr);
  fflush(stdout);
}

References line, tp_init_lex(), tp_parse(), tpips_get_line_to_parse(), and tpips_set_line_to_parse().

Referenced by tpips_exec().

Here is the call graph for this function:

Here is the caller graph for this function:

initialize_readline()

static void initialize_readline ( void  )

static

Tell the GNU Readline library how to complete.

We want to try to complete on command names if this is the first word in the line, or on filenames if not.

Definition at line 501 of file tpips.c.

{
  // Allow conditional parsing of the ~/.inputrc file.
  rl_readline_name = "Tpips";
 
  // allow "." to separate words
  rl_basic_word_break_characters = " \t\n\"\\@$><=;|&{(";
 
  // Tell the completer that we want a crack first.
#if defined (_RL_FUNCTION_TYPEDEF)
  rl_attempted_completion_function = (rl_completion_func_t *) fun_completion;
#else
  rl_attempted_completion_function = (CPPFunction *) fun_completion;
#endif
 
  // function for completing parameters
  rl_completion_entry_function = (rl_compentry_func_t *) param_generator;
 
  // do not override pips signals?
  rl_catch_signals = 0;
}

References fun_completion(), and param_generator().

Referenced by tpips_process_a_file().

Here is the call graph for this function:

Here is the caller graph for this function:

initialize_tpips_history()

static void initialize_tpips_history ( void  )

static

Definition at line 672 of file tpips.c.

{
  string file_name = default_hist_file_name();
  // read the history file, then point to the last entry.
  using_history();
  read_history(file_name);
  free(file_name);
  history_set_pos(history_length);
}

References default_hist_file_name(), file_name, and free().

Referenced by tpips_process_a_file().

Here is the call graph for this function:

Here is the caller graph for this function:

jpips_add_tag()

void jpips_add_tag

(

string

s

)

Definition at line 192 of file tpips.c.

{
  fprintf(out_to_jpips, " %s", s);
}

References fprintf(), and out_to_jpips.

Referenced by jpips_tag2(), and tp_some_info().

Here is the call graph for this function:

Here is the caller graph for this function:

jpips_begin_tag()

void jpips_begin_tag

(

string

s

)

Definition at line 187 of file tpips.c.

{
  fprintf(out_to_jpips, JPIPS_TAG " %s", s);
}

References fprintf(), JPIPS_TAG, and out_to_jpips.

Referenced by jpips_tag(), jpips_tag2(), and tp_some_info().

Here is the call graph for this function:

Here is the caller graph for this function:

jpips_done()

void jpips_done

(

void

)

Definition at line 216 of file tpips.c.

{
  jpips_tag("done");
}

References jpips_tag().

Referenced by tpips_process_a_file().

Here is the call graph for this function:

Here is the caller graph for this function:

jpips_end_tag()

void jpips_end_tag

(

void

)

Definition at line 197 of file tpips.c.

{
  fprintf(out_to_jpips, "\n");
  fflush(out_to_jpips);
}

References fprintf(), and out_to_jpips.

Referenced by jpips_tag(), jpips_tag2(), and tp_some_info().

Here is the call graph for this function:

Here is the caller graph for this function:

jpips_out_file()

FILE* jpips_out_file

(

void

)

Definition at line 182 of file tpips.c.

{
  return out_to_jpips;
}

References out_to_jpips.

jpips_printf()

void jpips_printf	(	const string	format,
			...
	)

Parameters

format

ormat

Definition at line 229 of file tpips.c.

{
  va_list some_arguments;
  va_start(some_arguments, format);
  (void) vfprintf(out_to_jpips, format, some_arguments);
  va_end(some_arguments);
}

References out_to_jpips.

Referenced by tpips_user_error(), and tpips_user_request().

Here is the caller graph for this function:

jpips_string()

void jpips_string	(	const char *	a_message_format,
		va_list	some_arguments
	)

Parameters

a_message_format	_message_format
some_arguments	ome_arguments

Definition at line 221 of file tpips.c.

{
  vfprintf(out_to_jpips, a_message_format, some_arguments);
  fflush(out_to_jpips);
}

References out_to_jpips.

Referenced by tpips_user_error(), and tpips_user_request().

Here is the caller graph for this function:

jpips_tag()

void jpips_tag

(

string

s

)

Definition at line 203 of file tpips.c.

{
  jpips_begin_tag(s);
  jpips_end_tag();
}

References jpips_begin_tag(), and jpips_end_tag().

Referenced by jpips_done(), tpips_user_error(), and tpips_user_request().

Here is the call graph for this function:

Here is the caller graph for this function:

jpips_tag2()

void jpips_tag2	(	string	s1,
		string	s2
	)

Parameters

s1	1
s2	2

Definition at line 209 of file tpips.c.

{
  jpips_begin_tag(s1);
  jpips_add_tag(s2);
  jpips_end_tag();
}

References jpips_add_tag(), jpips_begin_tag(), jpips_end_tag(), and s1.

Referenced by display_a_resource(), and tp_some_info().

Here is the call graph for this function:

Here is the caller graph for this function:

line_with_substitutions()

static bool line_with_substitutions ( string  line )

static

whether some substitutions are needed...

variables are restricted to the ${xxx} syntax.

autres : ~ ???

Definition at line 913 of file tpips.c.

{
  static char SHELL_CHARS[] = "${`*?"; /* autres : ~ ??? */
  while (*line)
  {
    if (strchr(SHELL_CHARS, *line))
      return true;
    line++;
  }
  return false;
}

References line.

Referenced by tp_substitutions().

Here is the caller graph for this function:

open_logfile()

static void open_logfile ( string  filename, char  opt  )

static

Definition at line 1112 of file tpips.c.

{
  if (logfile)
  {
    fprintf(logfile,
            "# logfile moved to %s by -%c tpips option\n", filename, opt);
    safe_fclose(logfile, "the current log file");
  }
  logfile = safe_fopen(filename, "w");
}

References fprintf(), logfile, safe_fclose(), and safe_fopen().

Referenced by parse_arguments().

Here is the call graph for this function:

Here is the caller graph for this function:

param_generator()

static char* param_generator ( const char *  texte, int  state  )

static

Generator function for param.

completion. STATE lets us know whether to start from scratch; without any state (i.e. STATE == 0), then we start at the top of the list.

If this is a new word to complete, initialize now. This includes saving the length of TEXT for efficiency, and initializing the index variable to 0.

e should count the number of separator before the actual pos

We scan the array of function to find the used function

Now we can determine the completion type

Return the next name which partially matches from the command list.

If no names matched, then return NULL.

Definition at line 367 of file tpips.c.

{
  static int list_index, len;
  char *name;
 
  /* If this is a new word to complete, initialize now.  This includes
     saving the length of TEXT for efficiency, and initializing the index
     variable to 0. */
  if (!state)
  {
    int number_of_sep = 0;
    int current_pos = 0;
    struct t_completion_scheme * cs = completion_scheme;
    int completion_type;
 
    pips_debug (9, "completing parameters\n\n");
 
    /*We should count the number of separator before the actual pos*/
    while (rl_line_buffer[current_pos])
    {
      if (SEPARATOR_P(rl_line_buffer[current_pos]))
      {
        number_of_sep ++;
        current_pos++;
        while ((rl_line_buffer[current_pos]) &&
               (SEPARATOR_P(rl_line_buffer[current_pos])))
          current_pos++;
      }
      else
        current_pos++;
    }
    pips_debug (9, "%d separator have been found on line\n\n",
                number_of_sep);
 
    /* We scan the array of function to find
     the used function */
    while ((cs->fun_name) &&
           !prefix_equal_p(rl_line_buffer, cs->fun_name))
    {
      cs++;
      pips_debug (9, "text is '%s', function found is '%s'\n\n",
                  rl_line_buffer,
                  cs->fun_name!=NULL? cs->fun_name : "<none>");
    }
 
    /* Now we can determine the completion type */
    if (number_of_sep == 1)
      completion_type = cs->first_completion_type;
    else
      completion_type = cs->other_completion_type;
 
    pips_debug (9, "completion type %d has been selected\n\n",
                completion_type);
 
    switch (completion_type)
    {
    case COMP_NONE:
      current_completion_array = NULL;
      break;
    case COMP_FILENAME:
#define RESERVED_FOR_FILENAME (char**) 0x01
      current_completion_array = RESERVED_FOR_FILENAME;
      break;
    case COMP_MODULE:
      current_completion_array = get_module_names();
      break;
    case COMP_RULE:
      current_completion_array = tp_phase_names;
      break;
    case COMP_RESOURCE:
      current_completion_array = tp_resource_names;
      break;
    case COMP_PROPERTY:
      current_completion_array = tp_property_names;
      break;
    case COMP_HELP_TOPIC:
      current_completion_array = tp_help_topics;
      break;
    case COMP_FILE_RSC:
      current_completion_array = tp_file_rsc_names;
      break;
    default:
      current_completion_array = NULL;
    }
    list_index = 0;
    len = strlen (texte);
  }
 
  if (current_completion_array == NULL)
    return NULL;
  else if (current_completion_array == RESERVED_FOR_FILENAME)
    return rl_filename_completion_function(texte,state);
 
  /* Return the next name which partially matches from the command list. */
  while ((name = current_completion_array[list_index]))
  {
  list_index++;
 
  if (strncmp (name, texte, len) == 0)
    return (strdup(name));
  }
 
  /* If no names matched, then return NULL. */
  return NULL;
}

References COMP_FILE_RSC, COMP_FILENAME, COMP_HELP_TOPIC, COMP_MODULE, COMP_NONE, COMP_PROPERTY, COMP_RESOURCE, COMP_RULE, completion_scheme, current_completion_array, t_completion_scheme::first_completion_type, t_completion_scheme::fun_name, get_module_names(), t_completion_scheme::other_completion_type, pips_debug, prefix_equal_p(), RESERVED_FOR_FILENAME, SEPARATOR_P, strdup(), tp_file_rsc_names, tp_help_topics, tp_phase_names, tp_property_names, and tp_resource_names.

Referenced by initialize_readline().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_arguments()

static void parse_arguments ( int  argc, char *  argv[]  )

static

the wrapper process will never return

sources ~/.tpipsrc or the like, if any.

no arguments, parses stdin.

process file arguments.

the tpips dirname is appended to PIPS_SRCPATH

Definition at line 1126 of file tpips.c.

{
  int c, opt_ind;
  string tpipsrc = default_tpipsrc();
  static struct option lopts[] = {
    { "version", 0, NULL, 'v' },
    { "jpips", 0, NULL, 'j' },
    { "help", 0, NULL, 'h' },
    { "shell", 0, NULL, 's' },
    { "log", 1, NULL, 'l' },
    { "rc", 1, NULL, 'r' },
    { "xml", 1, NULL, 'x' },
    { NULL, 0, NULL, 0 }
  };
 
  while ((c = getopt_long(argc, argv, "ane:l:h?vscr:jwx:", lopts, &opt_ind))
         != -1)
  {
    switch (c)
    {
    case 'j':
      jpips_is_running = true;
      // -j => -a
      _FALLTHROUGH_;
    case 'a':
    {
      string filename = safe_new_tmp_file("tpips_session");
      fprintf(stderr, "tpips session logged in \"%s\"\n", filename);
      open_logfile(filename, c);
      free(filename);
      break;
    }
    case 's':
      tpips_is_a_shell = true;
      break;
    case 'c':
      tpips_is_a_shell = false;
      break;
    case 'l':
      open_logfile(optarg, c);
      break;
    case 'x':
      open_xml_logfile(optarg);
      break;
    case 'h':
    case '?':
      fprintf (stderr, tpips_usage, argv[0]);
      return;
      break;
    case 'n':
      tpips_execution_mode = false;
      break;
    case 'e':
      tpips_exec(optarg);
      break;
    case 'v':
      fprintf(stdout,
              "tpips: (%s)\n"
              "ARCH=" STRINGIFY(SOFT_ARCH) "\n"
              "REVS=\n"
              "%s"
              "DATE=%s\n"
              "CC_VERSION=%s\n",
              argv[0], soft_revisions, soft_date, cc_version);
      exit(0);
      break;
    case 'r':
      free(tpipsrc);
      tpipsrc = strdup(optarg);
      break;
    case 'w':
      tpips_wrapper(); /* the wrapper process will never return */
      break;
    default:
      fprintf(stderr, tpips_usage, argv[0]);
      exit(1);
    }
  }
 
  /* sources ~/.tpipsrc or the like, if any.
   */
  if (tpipsrc)
  {
    if (file_exists_p(tpipsrc))
    {
      FILE * rc = fopen(tpipsrc, "r");
      if (rc)
      {
        user_log("sourcing tpips rc file: %s\n", tpipsrc);
        tpips_process_a_file(rc, tpipsrc, false);
        fclose(rc);
      }
    }
    free(tpipsrc), tpipsrc=NULL;
  }
 
  if (argc == optind)
  {
    /* no arguments, parses stdin. */
    bool use_rl = isatty(0);
    tpips_is_interactive = use_rl;
    pips_debug(1, "reading from stdin, which is%s a tty\n",
               use_rl ? "" : " not");
    tpips_process_a_file(stdin, "<stdin>", use_rl);
  }
  else
  {
    /* process file arguments. */
    while (optind < argc)
    {
      string tps = NULL, saved_srcpath = NULL;
      FILE * toprocess = (FILE*) NULL;
      bool use_rl = false;
 
      if (same_string_p(argv[optind], "-"))
      {
        tps = strdup("-");
        toprocess = stdin;
        use_rl = isatty(0);
        tpips_is_interactive = use_rl;
      }
      else
      {
        tpips_is_interactive = false;
        tps = find_file_in_directories(argv[optind],
                                       getenv("PIPS_SRCPATH"));
        if (tps)
        {
          /* the tpips dirname is appended to PIPS_SRCPATH */
          string dir = pips_dirname(tps);
          set_script_directory_name(dir);
          saved_srcpath = pips_srcpath_append(dir);
          free(dir), dir = NULL;
 
          if ((toprocess = fopen(tps, "r"))==NULL)
          {
            perror(tps);
            fprintf(stderr, "[TPIPS] cannot open \"%s\"\n", tps);
            free(tps), tps=NULL;
          }
 
          use_rl = false;
        }
        else
          fprintf(stderr, "[TPIPS] \"%s\" not found...\n",
                  argv[optind]);
      }
 
      if (tps)
      {
        pips_debug(1, "reading from file %s\n", tps);
 
        tpips_process_a_file(toprocess, tps, use_rl);
 
          safe_fclose(toprocess, tps);
        if (!same_string_p(tps, "-"))
          free(tps), tps = NULL;
      }
 
      if (saved_srcpath)
      {
        pips_srcpath_set(saved_srcpath);
        free(saved_srcpath), saved_srcpath = NULL;
      }
 
      optind++;
    }
  }
}

References _FALLTHROUGH_, cc_version, default_tpipsrc(), exit, file_exists_p(), find_file_in_directories(), fprintf(), free(), jpips_is_running, open_logfile(), open_xml_logfile(), optarg, optind, pips_debug, pips_dirname(), pips_srcpath_append(), pips_srcpath_set(), safe_fclose(), safe_new_tmp_file(), same_string_p, set_script_directory_name(), soft_date, soft_revisions, strdup(), STRINGIFY, tpips_exec(), tpips_execution_mode, tpips_is_a_shell, tpips_is_interactive, tpips_process_a_file(), tpips_usage, tpips_wrapper(), and user_log().

Referenced by tpips_main().

Here is the call graph for this function:

Here is the caller graph for this function:

prefix_equal_p()

static bool prefix_equal_p ( string  str, string  prf  )

static

Definition at line 125 of file tpips.c.

{
  skip_blanks(str);
  return !strncmp(str, prf, strlen(prf));
}

References skip_blanks.

Referenced by param_generator(), tp_substitutions(), and tpips_help().

Here is the caller graph for this function:

string_is_true()

static bool string_is_true ( string  s )

static

Definition at line 131 of file tpips.c.

{
  return s && (*s=='1' || *s=='t' || *s=='T' || *s=='y' || *s=='Y' ||
               *s=='o' || *s=='O');
}

Referenced by tpips_behaves_like_a_shell().

Here is the caller graph for this function:

tgetnum()

int tgetnum

(

)

Referenced by tpips_help().

Here is the caller graph for this function:

tp_restart()

void tp_restart

(

FILE *

)

Referenced by tpips_exec().

Here is the caller graph for this function:

tp_substitutions()

static string tp_substitutions ( string  line )

static

returns an allocated string after shell substitutions.

shell and comments are not substituted...

substitutions are performed by forking sh;-) however sh does not understand ~

Definition at line 927 of file tpips.c.

{
  string substituted;
 
  /* shell and comments are not substituted...
   */
  if (!prefix_equal_p(line, "shell") && !prefix_equal_p(line, "!")
      && !prefix_equal_p(line, "#") && line_with_substitutions(line))
  {
    /* substitutions are performed by forking sh;-)
     * however sh does not understand ~
     */
    substituted = safe_system_substitute(line);
    if (!substituted)
    {
      tpips_init();
      pips_user_warning("error in shell substitutions...\n");
      if (get_bool_property("ABORT_ON_USER_ERROR")) abort();
      substituted = strdup(line);
    }
    if (line_with_substitutions(substituted))
    {
      // not sure whether there is really an error, so we cannot abort
      tpips_init();
      pips_user_warning("maybe error in substituted lines:\n\t%s\n"
                        "For instance, check location of your source files.\n",
                        substituted);
    }
  }
  else
    substituted = strdup(line);
 
  pips_debug(2, "after substitution: %s\n", substituted);
  return substituted;
}

References abort, get_bool_property(), line, line_with_substitutions(), pips_debug, pips_user_warning, prefix_equal_p(), safe_system_substitute(), strdup(), and tpips_init().

Referenced by tpips_exec().

Here is the call graph for this function:

Here is the caller graph for this function:

tpips_behaves_like_a_shell()

bool tpips_behaves_like_a_shell

(

void

)

Definition at line 143 of file tpips.c.

{
  return tpips_is_a_shell || get_bool_property(TPIPS_IS_A_SHELL) ||
    string_is_true(getenv(TPIPS_IS_A_SHELL));
}

References get_bool_property(), string_is_true(), tpips_is_a_shell, and TPIPS_IS_A_SHELL.

Here is the call graph for this function:

tpips_close()

void tpips_close

(

void

)

Definition at line 868 of file tpips.c.

{
  // close history: truncate list and write history file
  if (use_readline)
  {
    char *file_name = default_hist_file_name();
    stifle_history(TPIPS_HISTORY_LENGTH);
    write_history(file_name);
  }
 
  close_workspace_if_opened(true);
 
  if (logfile) {
    safe_fclose (logfile, "the log file");
    logfile = NULL;
  }
 
  // do not close yet!
  //close_xml_logfile();
}

References close_workspace_if_opened(), default_hist_file_name(), file_name, logfile, safe_fclose(), TPIPS_HISTORY_LENGTH, and use_readline.

Referenced by tpips_exec(), and tpips_main().

Here is the call graph for this function:

Here is the caller graph for this function:

tpips_current_file_name()

string tpips_current_file_name

(

void

)

Definition at line 76 of file tpips.c.

{
  return current_name;
}

References current_name.

tpips_current_line()

int tpips_current_line

(

void

)

Definition at line 91 of file tpips.c.

{
  return current_line;
}

References current_line.

Referenced by tpips_lex_print_pos().

Here is the caller graph for this function:

tpips_current_line_number()

int tpips_current_line_number

(

void

)

Definition at line 81 of file tpips.c.

{
  return current_line;
}

References current_line.

tpips_current_name()

string tpips_current_name

(

void

)

Definition at line 96 of file tpips.c.

{
  return current_name;
}

References current_name.

Referenced by tpips_lex_print_pos().

Here is the caller graph for this function:

tpips_exec()

static void tpips_exec ( char *  line )

static

after environment variable substitution

leading setenv/getenv in a tpips script are performed PRIOR to pips initialization, hence the environment variable NEWGEN_MAX_TABULATED_ELEMENTS can be taken into account for a run. little of a hack. That results in a core dump when the tpips script starts with setenv commands generating user warnings because those imply a check of the property NO_USER_WARNING. Also errors are likely to lead to a check of ABORT_ON_USER_ERROR. And properties cannot be used before tpips_init() has been executed. So pips_user_warning() have to be protected in tpips.c by a preliminary call to tpips_init()

Definition at line 1000 of file tpips.c.

{
  pips_debug(3, "considering line: %s\n", line? line: " --- empty ---");
 
  _int db = get_debug_stack_pointer();
 
  CATCH(any_exception_error)
  {
    set_debug_stack_pointer(db);
 
    if (the_last_just_thrown_exception == timeout_error)
    {
      // hmmm... what should it do on timeout?
      // currently this is a clean "quit"... should it abort? other??
      tpips_close();
      pips_stop(user_error_log, TIMEOUT_CODE, "tpips stopped on timeout");
    }
 
    // on other errors, restart
    pips_debug(2, "restating tpips scanner\n");
    tp_restart(tp_in);
  }
  TRY
  {
    char * sline; /* after environment variable substitution */
    if (use_readline && line)
      add_history(strdup(line));
 
    pips_debug(2, "restarting tpips scanner\n");
    tp_restart(tp_in);
 
    /* leading setenv/getenv in a tpips script are performed
     * PRIOR to pips initialization, hence the environment variable
     * NEWGEN_MAX_TABULATED_ELEMENTS can be taken into account
     * for a run. little of a hack. That results in a core
     * dump when the tpips script starts with setenv
     * commands generating user warnings because those
     * imply a check of the property NO_USER_WARNING. Also
     * errors are likely to lead to a check of
     * ABORT_ON_USER_ERROR. And properties cannot be used
     * before tpips_init() has been executed. So
     * pips_user_warning() have to be protected in tpips.c
     * by a preliminary call to tpips_init()
     */
    if (!tpips_init_done &&
        strncmp(line, SET_ENV, strlen(SET_ENV))!=0 &&
        strncmp(line, GET_ENV, strlen(GET_ENV))!=0 &&
        strncmp(line, TPIPS_SOURCE, strlen(TPIPS_SOURCE))!=0 &&
        !blank_or_comment_line_p(line))
      tpips_init();
 
    sline = tp_substitutions(line);
    handle(sline);
    free(sline), sline = (char*) NULL;
 
    UNCATCH(any_exception_error);
  }
}

References any_exception_error, blank_or_comment_line_p(), CATCH, free(), get_debug_stack_pointer(), GET_ENV, handle(), line, pips_debug, pips_stop, set_debug_stack_pointer(), SET_ENV, strdup(), the_last_just_thrown_exception, TIMEOUT_CODE, timeout_error, tp_in, tp_restart(), tp_substitutions(), tpips_close(), tpips_init(), tpips_init_done, TPIPS_SOURCE, TRY, UNCATCH, use_readline, and user_error_log.

Referenced by parse_arguments(), and tpips_process_a_file().

Here is the call graph for this function:

Here is the caller graph for this function:

tpips_get_line_to_parse()

char* tpips_get_line_to_parse

(

void

)

Definition at line 961 of file tp_lex.c.

{
  return line_to_parse;
}

Referenced by handle().

Here is the caller graph for this function:

tpips_help()

void tpips_help

(

string

line

)

get the number of colunms for 80 chars

get the number of colunms for 80 chars

Parameters

line

ine

Definition at line 688 of file tpips.c.

{
  skip_blanks(line);
 
  printf("\n");
  TP_HELP("readline", "* readline interaction facilities\n",
          "\ttry <tab><tab> for automatic completion\n"
          "\temacs-tyle editing capabilities (see man readline)\n");
  TP_HELP("create", "create   <workspace-name> <file-name>...\n",
          "\tcreate a new worspace from a list of fortran files\n"
          "\tfirst delete the workspace if it exists\n");
  TP_HELP("open", "open     <workspace-name>\n",
          "\topen an existing workspace\n");
  TP_HELP("checkactive", "checkactive <resourcename>\n",
          "\ttell which phase would produce this resource.\n");
  TP_HELP("checkpoint", "checkpoint\n",
          "\tcheckpoint the current workspace\n");
  TP_HELP("close", "close\n",
          "\tclose the current opened workspace\n");
  TP_HELP("delete", "delete   <workspace-name>\n",
          "\tdelete an existing workspace\n");
  TP_HELP("module", "module   <module-name>\n",
          "\tselect a module from an opened workspace\n");
  TP_HELP("activate", "activate <rule-name>\n",
          "\ttell a rule to be active\n");
  TP_HELP("make", "make     <resourcename([OWNER])>\n",
          "\tbuild a resource\n"
          "\n\tExamples:\n\n"
          "\t\t make PRINTED_FILE\n"
          "\t\t make CALLGRAPH_FILE[my_module]\n"
          "\t\t make DG_FILE[%%ALL]\n"
          "\t\t make ICFG_FILE[%%CALLEES]\n\n");
  TP_HELP("apply", "apply    <rulename[(OWNER)]>\n",
          "\tmake the produced resources of a rule\n"
          "\n\tExamples:\n\n"
          "\t\t apply PRINT_SOURCE_WITH_REGIONS\n"
          "\t\t apply HPFC_CLOSE[my_module]\n"
          "\t\t apply PRINT_CODE[%%ALL]\n"
          "\t\t apply PRINT_ICFG[%%CALLEES]\n");
  TP_HELP("capply", "capply    <rulename[(OWNER)]>\n",
          "\tconcurrently apply a transformation rule\n"
          "\n\tExamples:\n\n"
          "\t\t apply SUPPRESS_DEAD_CODE[%%ALL]\n"
          "\t\t apply PARTIAL_EVAL[%%CALLEES]\n");
  TP_HELP("display", "display  <fileresourcename([OWNER])>\n",
          "\tprint a file resource\n"
          "\n\tExamples:\n\n"
          "\t\t display PRINTED_FILE\n"
          "\t\t display CALLGRAPH_FILE[my_module]\n"
          "\t\t display DG_FILE[%%ALL]\n"
          "\t\t display ICFG_FILE[%%CALLEES]\n\n");
  TP_HELP("remove", "remove  <resourcename([OWNER])>\n",
          "\tremove a resource from the database.\n");
  TP_HELP("cd", "cd       <dirname>\n",
          "\tchange directory\n");
  TP_HELP("pwd", "pwd\n", "\tprint current working directory\n");
  TP_HELP("setenv", "setenv    <name>=<value>\n",
          "\tchange environment\n");
  TP_HELP("unsetenv", "unsetenv    <name>\n",
          "\tremove variable from environment\n");
  TP_HELP("getenv", "getenv   <name>\n",
          "\tprint from environment (echo ${<name>} also ok)\n");
  TP_HELP("setproperty", "setproperty <name>=<value>\n",
          "\tchange property\n");
  TP_HELP(GET_PROP, GET_PROP " <name>\n",
          "\t print property\n");
  TP_HELP("echo", "echo     <string>\n",
          "\tprint the string\n");
  TP_HELP("quit", "quit\n",
          "\texit tpips (you should close the workspace before\n");
  TP_HELP("exit", "exit\n",
          "\texit tpips quickly (rhough!)\n");
  TP_HELP("source", "source <filenames...>\n",
          "\tread tpips commands from files.\n");
  TP_HELP("help", "help     (<help-item>)\n",
          "\tprint a list of all the commands or a \"detailled\""
          " description of one\n");
  TP_HELP("show", "show     <resourcename([OWNER])>\n",
          "\treturns the file of this resource\n");
  TP_HELP("timeout", "timeout <delay>\n",
          "\tset pips timeout in seconds\n");
  TP_HELP("info", "info <name>\n",
          "\tprint information about <name>\n"
          "\tname: module, modules, workspace, directory\n");
  TP_HELP("shell", "shell   [<shell-function>]\n",
          "\tallow shell functions call\n");
  TP_HELP("version", "version\n",
          "\tshow tpips version informations, such as:\n"
          "\t\trepository revisions used by the compilation\n"
          "\t\tdate of compilation\n"
          "\t\tcompiler used\n");
  TP_HELP("owner", "- owner : variable*\n",
          "\tList of available owners:\n"
          "\t\t%%MODULE\n"
          "\t\t%%ALL\n"
          "\t\t%%ALLFUNC\n"
          "\t\t%%PROGRAM\n"
          "\t\t%%CALLEES\n"
          "\t\t%%CALLERS\n"
          "\t\t<module_name>\n");
  TP_HELP("*", "* default rule...\n",
          "\tan implicit \"shell\" is assumed.\n");
 
  if (!*line || prefix_equal_p(line,"rulename") ||
      prefix_equal_p(line,"rule")) {
    printf("* rulename : variable*\n");
    if (*line) {
      char ** ps = tp_phase_names;
      int big_size = 0;
      int current_size;
      int columns, count;
 
      while (*ps) {
        current_size = strlen (*ps);
        if (big_size < current_size)
          big_size = current_size;
        ps++;
      }
      big_size++;
      /* get the number of colunms for 80 chars */
      columns = tgetnum ("co");
      pips_debug (1, "number of columns is %d\n", columns);
      columns = (columns > 0) ? columns /big_size : 1;
      count = 1;
      printf("\tList of available rules\n");
      ps = tp_phase_names;
      while (*ps)
      {
        printf("%-*s",big_size,*ps);
        if ((count % columns) == 0)
          printf("\n");
        ps++;
        count++;
      }
    }
  }
  if (!*line || prefix_equal_p(line,"resourcename") ||
      prefix_equal_p(line,"resource")) {
    printf("* resourcename : variable*\n");
    if (*line) {
      char ** ps = tp_resource_names;
      int big_size = 0;
      int current_size;
      int columns, count;
 
      while (*ps)
      {
        current_size = strlen (*ps);
        if (big_size < current_size)
          big_size = current_size;
        ps++;
      }
      /* get the number of colunms for 80 chars */
      columns = tgetnum ("co");
      big_size++;
      pips_debug (1, "number of columns is %d\n", columns);
      columns = (columns > 0) ? columns /big_size : 1;
      count = 1;
      printf("\tList of available resources\n");
      ps = tp_resource_names;
      while (*ps)
      {
        printf("%-*s",big_size,*ps);
        if ((count % columns) == 0)
          printf("\n");
        ps++;
        count++;
      }
    }
  }
  printf("\n");
  fflush(stdout);
}

References count, current_size, GET_PROP, line, pips_debug, prefix_equal_p(), printf(), skip_blanks, tgetnum(), TP_HELP, tp_phase_names, and tp_resource_names.

Here is the call graph for this function:

tpips_init()

void tpips_init

(

void

)

set_exception_callbacks(push_pips_context, pop_pips_context);

initialize_signal_catcher();

???

Definition at line 970 of file tpips.c.

{
  if (tpips_init_done) return;
 
  in_from_jpips = stdin;
  out_to_jpips = stdout;
 
  pips_checks();
 
  initialize_newgen();
  initialize_sc((char*(*)(Variable))entity_local_name);
  /* set_exception_callbacks(push_pips_context, pop_pips_context); */
  /* initialize_signal_catcher(); */
 
  set_bool_property("ABORT_ON_USER_ERROR", false); /* ??? */
  consistency_enforced_p = get_bool_property("CONSISTENCY_ENFORCED_P");
 
  pips_request_handler = tpips_user_request;
  pips_error_handler = tpips_user_error;
  pips_internal_error_handler = tpips_internal_error;
 
  tpips_init_done = true;
}

References consistency_enforced_p, entity_local_name(), get_bool_property(), in_from_jpips, initialize_newgen(), initialize_sc(), out_to_jpips, pips_checks(), pips_error_handler, pips_internal_error_handler, pips_request_handler, set_bool_property(), tpips_init_done, tpips_internal_error(), tpips_user_error(), and tpips_user_request().

Referenced by tp_substitutions(), and tpips_exec().

Here is the call graph for this function:

Here is the caller graph for this function:

tpips_internal_error()

void tpips_internal_error	(	_UNUSED_ const char *	calling_function_name,
		_UNUSED_ const char *	a_message_format,
			...
	)

In case of a tpips internal error, either core dump or try to save the workspace.

Definition at line 643 of file tpips.c.

{
  if (get_bool_property("CLOSE_WORKSPACE_AND_QUIT_ON_ERROR"))
  {
    // Try to close the workspace... hmmm, it may raise an internal error...
    db_close_workspace(true);
    // FI: it should be exit(1), but this is not compatible with the
    // current validation process. -- FC: why???
    exit(1);
  }
}

References db_close_workspace(), exit, and get_bool_property().

Referenced by tpips_init().

Here is the call graph for this function:

Here is the caller graph for this function:

tpips_main()

int tpips_main	(	int	argc,
		char *	argv[]
	)

MAIN: interactive loop and history management.

I need this one right now, as tpips init may be called too late.

Parameters

argc	rgc
argv	rgv

Definition at line 1298 of file tpips.c.

{
  // what about initialize_sc?
  variable_debug_name = (char * (*)(Variable)) entity_local_name;
  debug_on("TPIPS_DEBUG_LEVEL");
  initialize_signal_catcher();
  /* I need this one right now, as tpips init may be called too late. */
  set_exception_callbacks(push_pips_context, pop_pips_context);
  set_pips_meta_informations(soft_revisions, soft_date, cc_version);
 
  {
    char *pid = NULL;
    asprintf(&pid, "PID=%d", (int) getpid());
    putenv(pid);
  }
 
  parse_arguments(argc, argv);
  fprintf(stdout, "\n");  // for Ctrl-D terminations
  tpips_close();
  pips_stop(info_log, 0, "tpips end of main");
  return 0; // not reached
}

References asprintf, cc_version, debug_on, entity_local_name(), fprintf(), info_log, initialize_signal_catcher(), parse_arguments(), pips_stop, pop_pips_context(), push_pips_context(), set_exception_callbacks(), set_pips_meta_informations(), soft_date, soft_revisions, tpips_close(), and variable_debug_name.

Here is the call graph for this function:

tpips_next_line()

void tpips_next_line

(

void

)

Definition at line 86 of file tpips.c.

{
  current_line++;
}

References current_line.

Referenced by get_next_line().

Here is the caller graph for this function:

tpips_process_a_file()

void tpips_process_a_file	(	FILE *	file,
		string	name,
		bool	use_rl
	)

processing command line per line.

might be called recursively thru source.

push globals

interactive loop

Parameters

file	ile
name	ame
use_rl	se_rl

Definition at line 1062 of file tpips.c.

{
  static bool readline_initialized = false;
  char * line;
 
  // PUSH
  FILE * saved_file = current_file;
  string saved_name = current_name;
  int saved_line = current_line;
  bool saved_use_rl = use_readline;
 
  /* push globals */
  current_file = file;
  current_name = name;
  current_line = 0;
  use_readline = use_rl;
 
  if (use_readline && !readline_initialized)
  {
    initialize_readline();
    initialize_tpips_history();
    readline_initialized = true;
  }
 
  /* interactive loop
   */
  while ((line = tpips_read_a_line(TPIPS_PRIMARY_PROMPT)))
  {
    tpips_exec(line);
    free(line);
    if (jpips_is_running && file==stdin) jpips_done();
  }
 
  // POP
  current_file = saved_file;
  current_name = saved_name;
  current_line = saved_line;
  use_readline = saved_use_rl;
}

References current_file, current_line, current_name, free(), initialize_readline(), initialize_tpips_history(), jpips_done(), jpips_is_running, line, tpips_exec(), TPIPS_PRIMARY_PROMPT, tpips_read_a_line(), and use_readline.

Referenced by parse_arguments(), and process_file_list().

Here is the call graph for this function:

Here is the caller graph for this function:

tpips_read_a_line()

static char* tpips_read_a_line ( char *  main_prompt )

static

returns an allocated line read, including continuations.

may return NULL at end of file.

Definition at line 538 of file tpips.c.

{
  char *line;
  int l;
 
  line = get_next_line(main_prompt);
 
  // handle backslash-style continuations
  while (line && (l=strlen(line), l>1 && line[l-1]==TPIPS_CONTINUATION_CHAR))
  {
    char * next = get_next_line(TPIPS_SECONDARY_PROMPT);
    line[l-1] = '\0';
    char * tmp = strdup(concatenate(line, next, NULL));
    free(line); if (next) free(next);
    line = tmp;
  }
 
  // keep track of commands (there is also a log_file...)
  if (logfile && line)
    fprintf(logfile,"%s\n",line);
 
  pips_debug(3, "line is --%s--\n", line? line: "<NULL>");
 
  return line;
}

References concatenate(), fprintf(), free(), get_next_line(), line, logfile, pips_debug, strdup(), TPIPS_CONTINUATION_CHAR, and TPIPS_SECONDARY_PROMPT.

Referenced by tpips_process_a_file(), and tpips_user_request().

Here is the call graph for this function:

Here is the caller graph for this function:

tpips_set_line_to_parse()

void tpips_set_line_to_parse

(

char *

line

)

in lex file

store line pointer

Definition at line 953 of file tp_lex.c.

{
  skip_blanks(line);
  /* store line pointer */
  line_parsed = line_to_parse = line;
  cr_not_returned = true;
}

Referenced by handle().

Here is the caller graph for this function:

tpips_user_error()

static void tpips_user_error ( const char *  calling_function_name, const char *  format, va_list *  args  )

static

handle a user error DO NOT TERMINATE here, see pips_log_end

Definition at line 611 of file tpips.c.

{
  if (jpips_is_running)
  {
    va_list acpy;
    va_copy(acpy, *args);
    jpips_tag(BEGIN_UE);
    jpips_printf("%s\n", calling_function_name);
    jpips_string(format, acpy);
    jpips_tag(END_UE);
    va_end(acpy);
  }
 
  if (properties_initialized_p() &&
      get_bool_property("CLOSE_WORKSPACE_AND_QUIT_ON_ERROR"))
  {
    if (db_get_current_workspace_name())
    {
      pips_user_warning("Close workspace and quit on user error requested.");
      db_close_workspace(true);
    }
  }
 
  // DO NOT TERMINATE
}

References BEGIN_UE, db_close_workspace(), db_get_current_workspace_name(), END_UE, get_bool_property(), jpips_is_running, jpips_printf(), jpips_string(), jpips_tag(), pips_user_warning, and properties_initialized_p().

Referenced by tpips_init().

Here is the call graph for this function:

Here is the caller graph for this function:

tpips_user_request()

static string tpips_user_request ( const char *  fmt, va_list *  args  )

static

Definition at line 571 of file tpips.c.

{
  char * response;
  va_list acpy;
  va_copy(acpy, *args);
 
  debug_on("TPIPS_DEBUG_LEVEL");
 
  if (jpips_is_running)
  {
    jpips_tag(BEGIN_RQ);
    jpips_string( fmt, acpy);
    jpips_printf("\n");
    jpips_tag(END_RQ);
  }
  else if (use_readline)
  {
    (void) fprintf(stdout,"\nWaiting for your response: ");
    (void) vfprintf(stdout, fmt, acpy);
    fflush(stdout);
  }
  va_end(acpy);
 
  response = tpips_read_a_line(TPIPS_REQUEST_PROMPT);
 
  pips_debug(2, "returning --%s--\n", response? response: "<NULL>");
 
  debug_off();
 
  return response;
}

References BEGIN_RQ, debug_off, debug_on, END_RQ, fprintf(), jpips_is_running, jpips_printf(), jpips_string(), jpips_tag(), pips_debug, tpips_read_a_line(), TPIPS_REQUEST_PROMPT, and use_readline.

Referenced by tpips_init().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

cc_version

const char * cc_version

Definition at line 1124 of file tpips.c.

Referenced by parse_arguments(), pips_main(), tpips_main(), and wpips_main().

completion_scheme

struct t_completion_scheme completion_scheme[]

static

Initial value:

=
{
{ SHELL_ESCAPE, COMP_FILENAME,   COMP_FILENAME },
{ TPIPS_SOURCE,  COMP_FILENAME,   COMP_FILENAME },
{ CHANGE_DIR,   COMP_FILENAME,   COMP_NONE },
{ QUIT,    COMP_NONE,       COMP_NONE },
{ "checkpoint", COMP_NONE,       COMP_NONE },
{ HELP,    COMP_HELP_TOPIC, COMP_NONE },
{ ECHO_N,    COMP_NONE,       COMP_NONE },
{ "open",       COMP_NONE,       COMP_NONE },
{ "create",     COMP_NONE,       COMP_FILENAME },
{ "close",      COMP_NONE,       COMP_NONE },
{ "delete",     COMP_NONE,       COMP_NONE },
{ "module",     COMP_MODULE,       COMP_NONE },
{ "make",       COMP_RESOURCE,   COMP_NONE },
{ "remove",  COMP_RESOURCE,   COMP_NONE },
{ "apply",      COMP_RULE,       COMP_NONE },
{ "capply",      COMP_RULE,       COMP_NONE },
{ "display",    COMP_FILE_RSC,   COMP_NONE },
{ "activate",   COMP_RULE,       COMP_NONE },
{ SET_ENV,  COMP_NONE,   COMP_NONE },
{ GET_ENV,  COMP_NONE,   COMP_NONE },
{ "unsetenv",   COMP_NONE, COMP_NONE },
{ SET_PROP,     COMP_PROPERTY,   COMP_NONE },
{ GET_PROP,     COMP_PROPERTY,   COMP_NONE },
{ "info",       COMP_NONE,   COMP_NONE },
{ "show",  COMP_RESOURCE,   COMP_NONE },
{ "timeout",    COMP_NONE, COMP_NONE },
{ (char*)NULL,  COMP_FILENAME,   COMP_FILENAME } 
}

Definition at line 239 of file tpips.c.

Referenced by fun_generator(), and param_generator().

consistency_enforced_p

bool consistency_enforced_p = false

Pipsmake does not enforce consistency when properties are changed.

The consistency can be enforced by forbidding setproperty during a processing phase.

Definition at line 968 of file tpips.c.

Referenced by tpips_init().

current_completion_array

char** current_completion_array

static

Definition at line 239 of file tpips.c.

Referenced by param_generator().

current_file

FILE* current_file = NULL

static

current file being processed, with its name and the line number

Definition at line 72 of file tpips.c.

Referenced by get_next_line(), and tpips_process_a_file().

current_line

int current_line = 0

static

Definition at line 74 of file tpips.c.

Referenced by tpips_current_line(), tpips_current_line_number(), tpips_next_line(), and tpips_process_a_file().

current_name

string current_name = "<unknown>"

static

Definition at line 73 of file tpips.c.

Referenced by lazy_open_module(), tpips_current_file_name(), tpips_current_name(), and tpips_process_a_file().

in_from_jpips

FILE* in_from_jpips

static

Ronan suggested a signal driven handling of jpips requests, so as to let the prompt available for direct commands.

This seems great, but is not implemented at the time. This would mean interruption driven tpips execution from jpips. The executions should not interfere... SIGIO handling on in_from_jpips... forward to readline maybe... a new -J option? how to link C FILE* to unix file descriptors? ? f = fopen(); dup2(..., fileno(f)); OR freopen()...

Definition at line 179 of file tpips.c.

Referenced by tpips_init().

jpips_is_running

bool jpips_is_running = false

Definition at line 166 of file tpips.c.

Referenced by display_a_resource(), parse_arguments(), tp_some_info(), tpips_process_a_file(), tpips_user_error(), and tpips_user_request().

logfile

FILE* logfile

static

Definition at line 69 of file tpips.c.

Referenced by open_logfile(), tpips_close(), and tpips_read_a_line().

optarg

char* optarg

extern

Referenced by parse_arguments(), pips_parse_arguments(), and set_hyperplane_parameters().

optind

int optind

extern

Referenced by gpips_parse_arguments(), main(), parse_arguments(), pips_parse_arguments(), set_hyperplane_parameters(), and wpips_parse_arguments().

out_to_jpips

FILE* out_to_jpips

static

Definition at line 180 of file tpips.c.

Referenced by jpips_add_tag(), jpips_begin_tag(), jpips_end_tag(), jpips_out_file(), jpips_printf(), jpips_string(), and tpips_init().

soft_date

const char * soft_date

Definition at line 1124 of file tpips.c.

Referenced by parse_arguments(), pips_main(), pips_parse_arguments(), tpips_main(), and wpips_main().

soft_revisions

const char* soft_revisions

extern

could be shared somewhere?

First part of user prologue.

Definition at line 33 of file revisions.c.

Referenced by parse_arguments(), and tpips_main().

tp_help_topics

char* tp_help_topics[]

static

Initial value:

=
{
  "readline", "create","close","delete","echo","module","activate",
  "make","apply","capply","display",SET_ENV, SET_PROP,GET_PROP,SHELL_ESCAPE,
  CHANGE_DIR,QUIT,"source", HELP,"rule","resource","owner", "remove",
  "checkpoint", "info", "show", "timeout", "checkactive", (char*) NULL
}

Definition at line 290 of file tpips.c.

Referenced by param_generator().

tpips_execution_mode

bool tpips_execution_mode = true

Sometimes, already included by unistd.h.

cproto-generated files

Definition at line 64 of file tpips.c.

Referenced by parse_arguments(), perform(), and tp_close_the_workspace().

tpips_init_done

bool tpips_init_done = false

variable globale, utilisee par le parser helas

Definition at line 964 of file tpips.c.

Referenced by process_file_list(), tpips_exec(), and tpips_init().

tpips_is_a_shell

bool tpips_is_a_shell = false

static

Definition at line 67 of file tpips.c.

Referenced by parse_arguments(), and tpips_behaves_like_a_shell().

tpips_is_interactive

bool tpips_is_interactive = false

Definition at line 65 of file tpips.c.

Referenced by parse_arguments(), process_file_list(), and tp_system().

use_readline

bool use_readline = false

static

Definition at line 68 of file tpips.c.

Referenced by get_next_line(), tpips_close(), tpips_exec(), tpips_process_a_file(), and tpips_user_request().