fpips.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include "genC.h"
#include "misc.h"

Include dependency graph for fpips.c:

Go to the source code of this file.

Macros
#define	PIPS(c, v)   pips_main(c, v)
#define	TPIPS(c, v)   tpips_main(c, v)
#define	WPIPS(c, v)   wpips_main(c, v)
#define	GPIPS(c, v)   gpips_main(c, v)
#define	USAGE

Functions
int	pips_main (int, char **)
int	tpips_main (int, char **)
int	wpips_main (int, char **)
int	gpips_main (int, char **)
static int	fpips_usage (int ret)
	print out usage informations. More...
static int	fpips_version (int ret)
	print out fpips version. More...
int	fpips_error (char *what, int __attribute__((unused)) argc, char __attribute__((unused)) **argv)
	non static to avoid a gcc warning if not called. More...
static int	name_end_p (char *name, char *ref)
	returns whether name ends with ref More...
int	fpips_main (int argc, char **argv)

Macro Definition Documentation

GPIPS

#define GPIPS	(		c,
			v
	)		gpips_main(c, v)

Definition at line 75 of file fpips.c.

PIPS

#define PIPS	(		c,
			v
	)		pips_main(c, v)

Definition at line 54 of file fpips.c.

TPIPS

#define TPIPS	(		c,
			v
	)		tpips_main(c, v)

Definition at line 61 of file fpips.c.

USAGE

#define USAGE

Value:

    "Usage: fpips [-hvGPTW] (other options and arguments...)\n" \
    "\t-h: this help...\n"                                      \
    "\t-v: version\n"                                           \
    "\t-G: gpips\n"                                             \
    "\t-P: pips\n"                                              \
    "\t-T: tpips\n"                                             \
    "\t-W: wpips\n"                                             \
    "\tdefault: run as tpips\n\n"

Definition at line 78 of file fpips.c.

WPIPS

#define WPIPS	(		c,
			v
	)		wpips_main(c, v)

Definition at line 68 of file fpips.c.

Function Documentation

fpips_error()

int fpips_error	(	char *	what,
		int __attribute__((unused))	argc,
		char __attribute__((unused)) **	argv
	)

non static to avoid a gcc warning if not called.

Definition at line 108 of file fpips.c.

{
    fprintf(stderr, "[fpips] sorry, %s not available (" STRINGIFY(SOFT_ARCH) ")\n", what);
    return fpips_usage(1);
}

References fpips_usage(), fprintf(), and STRINGIFY.

Here is the call graph for this function:

fpips_main()

int fpips_main	(	int	argc,
		char **	argv
	)

should not happen

According to the shell or the debugger, the path may be complete or not... RK.

parsing of options may be continuate by called version.

else try tpips...

Definition at line 130 of file fpips.c.

{
    int opt;
 
    debug_on("FPIPS_DEBUG_LEVEL");
    pips_debug(1, "considering %s for execution\n", argv[0]);
    debug_off();
 
    if (argc<1) return TPIPS(argc, argv); /* should not happen */
 
    /* According to the shell or the debugger, the path may be
       complete or not... RK. */
    if (name_end_p(argv[0], "gpips"))
        return GPIPS(argc, argv);
    if (name_end_p(argv[0], "tpips"))
        return TPIPS(argc, argv);
    if (name_end_p(argv[0], "wpips"))
        return WPIPS(argc, argv);
    if (name_end_p(argv[0], "/pips") || same_string_p(argv[0], "pips"))
        return  PIPS(argc, argv);
 
    /* parsing of options may be continuate by called version.
     */
    while ((opt = getopt(argc, argv, "hvGPTW"))!=-1)
    {
        switch (opt)
        {
        case 'h': fpips_usage(0); break;
        case 'v': fpips_version(0); break;
        case 'G': return GPIPS(argc, argv);
        case 'P': return PIPS(argc, argv);
        case 'T': return TPIPS(argc, argv);
        case 'W': return WPIPS(argc, argv);
        default:  return fpips_version(1);
        }
    }
 
    /* else try tpips...
     */
    fprintf(stderr, "[fpips] default: running as tpips\n\n");
    return TPIPS(argc, argv);
}

References debug_off, debug_on, fpips_usage(), fpips_version(), fprintf(), GPIPS, name_end_p(), PIPS, pips_debug, same_string_p, TPIPS, and WPIPS.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

fpips_usage()

static int fpips_usage ( int  ret )

static

print out usage informations.

Definition at line 92 of file fpips.c.

{
    fprintf(stderr, USAGE);
    return ret;
}

References fprintf(), ret, and USAGE.

Referenced by fpips_error(), and fpips_main().

Here is the call graph for this function:

Here is the caller graph for this function:

fpips_version()

static int fpips_version ( int  ret )

static

print out fpips version.

Definition at line 100 of file fpips.c.

{
  fprintf(stderr, "[fpips] (ARCH=" STRINGIFY(SOFT_ARCH) ", DATE=" STRINGIFY(UTC_DATE) ")\n\n");
    return ret;
}

References fprintf(), ret, STRINGIFY, and UTC_DATE.

Referenced by fpips_main().

Here is the call graph for this function:

Here is the caller graph for this function:

gpips_main()

int gpips_main	(	int	,
		char **
	)

name_end_p()

static int name_end_p ( char *  name, char *  ref  )

static

returns whether name ends with ref

Definition at line 118 of file fpips.c.

{
    int nlen = strlen(name), rlen = strlen(ref);
    if (nlen<rlen) return false;
    while (rlen>0)
        if (ref[--rlen]!=name[--nlen])
            return false;
    return true;
}

References ref.

Referenced by fpips_main().

Here is the caller graph for this function:

pips_main()

int pips_main	(	int	argc,
		char **	argv
	)

Definition at line 160 of file pips.c.

{
  volatile bool success = true;
  pips_checks();
  set_pips_meta_informations(soft_revisions, soft_date, cc_version);
 
  initialize_newgen();
  initialize_sc((char*(*)(Variable)) entity_local_name);
  set_exception_callbacks(push_pips_context, pop_pips_context);
 
  pips_parse_arguments(argc, argv);
 
  debug_on("PIPS_DEBUG_LEVEL");
  initialize_signal_catcher();
 
  CATCH(any_exception_error)
  {
    // no need to pop_pips_context() at top-level
    // FI: are you sure make_close_program() cannot call user_error() ?
    close_workspace(true);
    success = false;
  }
  TRY
  {
    // Initialize workspace
    if (gen_array_nitems(source_files)>0) {
            if(db_create_workspace(wspace)) {
        create_workspace(source_files);
            }
            else {
        user_log("Cannot create workspace %s!\n", wspace);
        exit(1);
            }
    } else {
            // Workspace must be opened
            if (!open_workspace(wspace)) {
        user_log("Cannot open workspace %s!\n", wspace);
        exit(1);
            }
    }
 
    // Open module
    if (module != NULL)
            open_module(module);
    else
            open_module_if_unique();
 
    // Activate rules
    if (success && selected_rules)
    {
      FOREACH(STRING, r, selected_rules) select_rule(r);
    }
 
    // Perform applies
    if (success && performed_rule && module)
    {
            success = safe_apply(performed_rule, module);
            if (success) {
        user_log("%s performed for %s.\n", performed_rule, module);
            }
            else {
        user_log("Cannot perform %s for %s.\n", performed_rule, module);
            }
    }
 
    // Build resources
    if (success && build_resource_names && module)
    {
            FOREACH(STRING, build_resource_name, build_resource_names)
      {
        success = safe_make(build_resource_name, module);
        if (!success)
        {
          user_log("Cannot build %s for %s.\n", build_resource_name, module);
          break;
        }
      }
    }
    // whether success or not...
    close_workspace(true);
 
    UNCATCH(any_exception_error);
  }
 
  debug_off();
 
  return !success;
}

References any_exception_error, build_resource_names, CATCH, cc_version, close_workspace(), create_workspace(), db_create_workspace(), debug_off, debug_on, entity_local_name(), exit, FOREACH, gen_array_nitems(), initialize_newgen(), initialize_sc(), initialize_signal_catcher(), module, open_module(), open_module_if_unique(), open_workspace(), performed_rule, pips_checks(), pips_parse_arguments(), pop_pips_context(), push_pips_context(), safe_apply(), safe_make(), select_rule(), selected_rules, set_exception_callbacks(), set_pips_meta_informations(), soft_date, soft_revisions, source_files, STRING, TRY, UNCATCH, user_log(), and wspace.

Here is the call graph for this function:

tpips_main()

int tpips_main	(	int	,
		char **
	)

wpips_main()

int wpips_main	(	int	,
		char **
	)