activate.c File Reference

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include "genC.h"
#include "database.h"
#include "linear.h"
#include "ri.h"
#include "properties.h"
#include "ri-util.h"
#include "pipsdbm.h"
#include "pipsmake.h"
#include "misc.h"

Include dependency graph for activate.c:

Go to the source code of this file.

Functions
static void	delete_derived_resources ()
void	save_active_phases (void)
	activate.c More...
void	retrieve_active_phases (void)
bool	active_phase_p (const char *phase)
bool	saved_active_phase_p (const char *phase)
	Debugging function. More...
void	fprint_activated (FILE *fd)
string	active_phase_for_resource (string res)
	return the phase which would be used to build a given resource. More...
const char *	activate_phase (const char *phase)
const char *	activate (const char *phase)
bool	activate_phases (void)
	Use property ACTIVE_PHASES to active the phases required by the user. More...
void	activate_language (language l)
	Choose the right combination of activate and setproperty for a given language. More...
static void	get_more_derived_resources (string vrn, set set_of_res)
bool	rule_use_resource_produced (rule r)
	Test if a rule uses a resource it produces. More...
static void	delete_derived_resources (virtual_resource res)

Variables
static list	saved_active_phases = NIL

Function Documentation

activate()

const char* activate

(

const char *

phase

)

Parameters

phase

hase

Definition at line 214 of file activate.c.

{
  const char* r = activate_phase(phase);
  if(!r)
    pips_user_error("Phase activation error: check the phase names\n");
  return r;
}

References activate_phase(), and pips_user_error.

Referenced by activate_language(), make_pre_post_transformation(), options_select(), select_rule(), and update_options().

Here is the call graph for this function:

Here is the caller graph for this function:

activate_language()

void activate_language

(

language

l

)

Choose the right combination of activate and setproperty for a given language.

This is not really compatible with the litterate programming of pipsmake-rc.tex, where this information should be encoded.

Usual properties for Fortran

Usual properties for Fortran 90/95

Usual properties for C

The language is unknown

Definition at line 254 of file activate.c.

{
  if(language_fortran_p(l)) {
    /* Usual properties for Fortran */
    set_bool_property("PRETTYPRINT_STATEMENT_NUMBER", true);
    set_bool_property("FOR_TO_WHILE_LOOP_IN_CONTROLIZER", false);
    set_bool_property("FOR_TO_DO_LOOP_IN_CONTROLIZER", false);
 
    if(!active_phase_p("PARSER"))
      activate("PARSER");
  } else if(language_fortran95_p(l)) {
    /* Usual properties for Fortran 90/95 */
    set_bool_property("PRETTYPRINT_STATEMENT_NUMBER", false);
    set_bool_property("FOR_TO_WHILE_LOOP_IN_CONTROLIZER", false);
    set_bool_property("FOR_TO_DO_LOOP_IN_CONTROLIZER", false);
 
    // Temporary fix for autogenerated file
    if(!active_phase_p("PARSER"))
      activate("PARSER");
  } else if(language_c_p(l)) {
    /* Usual properties for C */
    set_bool_property("PRETTYPRINT_STATEMENT_NUMBER", false);
    set_bool_property("FOR_TO_WHILE_LOOP_IN_CONTROLIZER", true);
    set_bool_property("FOR_TO_DO_LOOP_IN_CONTROLIZER", true);
 
    if(!active_phase_p("C_PARSER"))
      activate("C_PARSER");
    // No longer useful
    //if(!active_phase_p("C_SYMBOL_TABLE"))
    //  activate("C_SYMBOL_TABLE");
  }
  else {
    /* The language is unknown*/
    pips_user_warning("Unknown language initialization\n");
  }
}

References activate(), active_phase_p(), language_c_p, language_fortran95_p, language_fortran_p, pips_user_warning, and set_bool_property().

Referenced by add_a_file(), and create_workspace().

Here is the call graph for this function:

Here is the caller graph for this function:

activate_phase()

const char* activate_phase

(

const char *

phase

)

find rule that describes phase

Parameters

phase

hase

Definition at line 124 of file activate.c.

{
  makefile current_makefile = parse_makefile();
  bool rule_cyclic_p = true;
  const char * status = phase;
 
  debug_on("PIPSMAKE_DEBUG_LEVEL");
  pips_debug(1, "%s - requested\n", phase);
 
  pips_assert("a current workspace is defined",
              db_get_current_workspace_name());
 
  /* find rule that describes phase */
  rule r = find_rule_by_phase(phase);
 
  if (r == rule_undefined) {
    if (get_bool_property("PIPSMAKE_WARNINGS"))
      pips_user_warning("Rule `%s' undefined.\n"
                        "Check spelling and/or ACTIVE_PHASE property.\n",
                        phase);
    status = NULL;
  }
  else if (active_phase_p(phase)) {
    if (get_bool_property("PIPSMAKE_WARNINGS"))
      pips_user_warning ("Rule `%s' already active\n", phase);
  }
  else if (!gen_length(rule_produced(r))) {
    // if (get_bool_property("PIPSMAKE_WARNINGS"))
    pips_user_warning("Phase %s produces no resource\n", phase);
    status = NULL;
  }
  else {
    // GO: for many produced resources we loop over them
    // with the same 'old' code
    // find resource res that is produced by phase
    FOREACH(VIRTUAL_RESOURCE, res, rule_produced(r)) {
      bool require_produced_rule_p = false;
      string vrn = virtual_resource_name(res);
 
      FOREACH(VIRTUAL_RESOURCE, vr, rule_required(r)) {
        string vrn2 = virtual_resource_name(vr);
        owner vro = virtual_resource_owner(vr);
 
        // We do not check callers and callees
        // I dropped select also, just in case... FC
        if (!(owner_callers_p(vro) || owner_callees_p(vro) ||
              owner_select_p(vro)) && same_string_p(vrn, vrn2))
          require_produced_rule_p = true;
      }
 
      // If the current produced resource is not required by the new rule
      if (!require_produced_rule_p) {
        rule_cyclic_p = false;
        // find current active phase old_phase that produces res
        string old_phase = rule_phase(find_rule_by_resource(vrn));
 
        // replace old_phase by phase in active phase list
        if (old_phase != NULL) {
          pips_debug(5, "replacing %s by %s for %s\n", old_phase, phase, vrn);
          MAPL(pa, {
              string s = STRING(CAR(pa));
 
              if (strcmp(s, old_phase) == 0) {
                free(STRING(CAR(pa)));
                STRING(CAR(pa)) = strdup(phase);
              }
            }, makefile_active_phases(current_makefile));
        }
 
        // this generates many warnings when called from select...
        if (get_bool_property("ACTIVATE_DEL_DERIVED_RES"))
          delete_derived_resources (res);
        else
          if (db_get_current_workspace_name()) {
            // remove resources with the same name as res
            // to maintain consistency in the database
            db_unput_resources(vrn);
          }
      }
    }
 
    if (rule_cyclic_p == true) {
      pips_user_warning("Phase %s is cyclic\n", phase);
      status = NULL;
    }
  }
  debug_off();
  return status;
}

References active_phase_p(), CAR, db_get_current_workspace_name(), db_unput_resources(), debug_off, debug_on, delete_derived_resources(), find_rule_by_phase(), find_rule_by_resource(), FOREACH, free(), gen_length(), get_bool_property(), makefile_active_phases, MAPL, owner_callees_p, owner_callers_p, owner_select_p, parse_makefile(), pips_assert, pips_debug, pips_user_warning, rule_phase, rule_produced, rule_required, rule_undefined, same_string_p, strdup(), STRING, VIRTUAL_RESOURCE, virtual_resource_name, and virtual_resource_owner.

Referenced by activate(), and activate_phases().

Here is the call graph for this function:

Here is the caller graph for this function:

activate_phases()

bool activate_phases

(

void

)

Use property ACTIVE_PHASES to active the phases required by the user.

Definition at line 224 of file activate.c.

{
  string d = " ,\t\n";
  // strtok breaks its first argument string
  string ap = strdup(get_string_property("ACTIVE_PHASES"));
  string cap = strtok(ap, d);
  bool pips_special =
    !same_string_p("full", get_string_property("PIPS_VERSION"));
  bool result = true;
 
  while (cap!=NULL) {
    pips_debug(1, "Phase to activate: %s\n", cap);
    if (!active_phase_p(cap)) {
      const char* r =  activate_phase(cap);
      result = r!=NULL;
    }
    cap = strtok(NULL, d);
  }
  free(ap);
 
  // for a specialized pips, accept invalid phase names
  return pips_special? true: result;
}

References activate_phase(), active_phase_p(), free(), get_string_property(), pips_debug, same_string_p, and strdup().

Referenced by create_workspace().

Here is the call graph for this function:

Here is the caller graph for this function:

active_phase_for_resource()

string active_phase_for_resource

(

string

res

)

return the phase which would be used to build a given resource.

Parameters

res

es

Definition at line 119 of file activate.c.

{
  return rule_phase(find_rule_by_resource(res));
}

References find_rule_by_resource(), and rule_phase.

Here is the call graph for this function:

active_phase_p()

bool active_phase_p

(

const char *

phase

)

Parameters

phase

hase

Definition at line 80 of file activate.c.

{
  makefile current_makefile = parse_makefile();
  list apl = makefile_active_phases(current_makefile);
 
  FOREACH(STRING, s, apl)
    if (same_string_p(s, phase))
      return true; // new line for breakpoints
 
  return false;
}

References FOREACH, makefile_active_phases, parse_makefile(), same_string_p, and STRING.

Referenced by activate_language(), activate_phase(), activate_phases(), make_pre_post_transformation(), points_to_unary_operation_to_transformer(), and ProcessEntry().

Here is the call graph for this function:

Here is the caller graph for this function:

delete_derived_resources() [1/2]

static void delete_derived_resources ( )

static

Referenced by activate_phase().

Here is the caller graph for this function:

delete_derived_resources() [2/2]

static void delete_derived_resources ( virtual_resource  res )

static

Get the set of virtual resource to destroy

Definition at line 382 of file activate.c.

{
    set s = set_make (set_pointer);
    string vrn = virtual_resource_name(res);
    /* Get the set of virtual resource to destroy */
    get_more_derived_resources(vrn, s);
    SET_MAP(se, delete_named_resources((string) se), s);
    set_free(s);
}

References delete_named_resources(), get_more_derived_resources(), set_free(), set_make(), SET_MAP, set_pointer, and virtual_resource_name.

Here is the call graph for this function:

fprint_activated()

void fprint_activated

(

FILE *

fd

)

Parameters

fd

d

Definition at line 110 of file activate.c.

{
  makefile m = parse_makefile();
  FOREACH(STRING, s, makefile_active_phases(m))
    fprintf(fd, "%s\n", s);
}

References FOREACH, fprintf(), makefile_active_phases, parse_makefile(), and STRING.

Referenced by retrieve_active_phases(), and select_rule().

Here is the call graph for this function:

Here is the caller graph for this function:

get_more_derived_resources()

static void get_more_derived_resources ( string  vrn, set  set_of_res  )

static

If the given resource is not in the set

put it into the set

For all active phases

Search in the required rules

If the resource names are equal

make a recursion for all the produced rules

Here, there is no infinite loop problem with rule producing a ressource they require, because the resource has already been had to the set

Definition at line 294 of file activate.c.

{
    makefile m = parse_makefile();
    rule r;
 
    /* If the given resource is not in the set */
    if (set_belong_p (set_of_res, (char *) vrn))
        return;
 
    /* put it into the set  */
    set_add_element (set_of_res, set_of_res, (char *) vrn);
 
    pips_debug(8, "got %s\n", vrn);
 
    /* For all active  phases*/
    MAPL(pa, {
 
        r = find_rule_by_phase(STRING(CAR(pa)));
 
        if (rule_use_resource_produced(r) == true)
            debug(9, "get_more_derived_resources",
                  "Don't scan cycling phase %s\n",STRING(CAR(pa)));
        else
        {
            debug(9, "get_more_derived_resources",
                  "Scan phase %s\n",STRING(CAR(pa)));
 
            /* Search in the required rules */
            MAPL(pvr, {
                virtual_resource res2 = VIRTUAL_RESOURCE(CAR(pvr));
                string vrn2 = virtual_resource_name(res2);
 
                /* If the resource names are equal */
                if (same_string_p(vrn, vrn2)) {
                
                    debug(9, "get_more_derived_resources",
                          "Resource %s is required by phase %s\n",
                          vrn, STRING(CAR(pa)));
 
                    /* make a recursion for all the produced rules */
                    MAPL(pvr3, {
                        virtual_resource res3 = VIRTUAL_RESOURCE(CAR(pvr3));
                        string vrn3 = virtual_resource_name(res3);
                        /* Here, there is no infinite loop problem
                           with rule producing a ressource they require,
                           because the resource has already been had 
                           to the set */
                        get_more_derived_resources(vrn3, set_of_res);
                    }, (list) rule_produced ( r ) );
                    break;
                }
            }, (list) rule_required( r ) );
        }
    }, makefile_active_phases(m));
}

References CAR, debug(), find_rule_by_phase(), makefile_active_phases, MAPL, parse_makefile(), pips_debug, rule_produced, rule_required, rule_use_resource_produced(), same_string_p, set_add_element(), set_belong_p(), STRING, VIRTUAL_RESOURCE, and virtual_resource_name.

Referenced by delete_derived_resources().

Here is the call graph for this function:

Here is the caller graph for this function:

retrieve_active_phases()

void retrieve_active_phases

(

void

)

Definition at line 58 of file activate.c.

{
  makefile current_makefile = parse_makefile();
 
  ifdebug(9) {
    puts("----- BEFORE RETRIEVING -----");
    fprint_activated(stdout);
  }
 
  if (saved_active_phases != NIL)
  {
    gen_free_string_list(makefile_active_phases(current_makefile));
    makefile_active_phases(current_makefile) = saved_active_phases;
    saved_active_phases = NIL;
 
    ifdebug(9) {
            puts("----- AFTER RETREIVING -----");
            fprint_activated(stdout);
    }
  }
}

References fprint_activated(), gen_free_string_list(), ifdebug, makefile_active_phases, NIL, parse_makefile(), and saved_active_phases.

Referenced by apply(), concurrent_apply(), make(), safe_concurrent_apply(), and safe_do_something().

Here is the call graph for this function:

Here is the caller graph for this function:

rule_use_resource_produced()

bool rule_use_resource_produced

(

rule

r

)

Test if a rule uses a resource it produces.

find resource res that is produced by phase

owner vro = virtual_resource_owner(vr);

We DO check callers and callees (DB,08/96)

if ( owner_callers_p(vro) || owner_callees_p(vro) ) {} else

Definition at line 353 of file activate.c.

{
    MAPL(pvrp, {
        /* find resource res that is produced by phase */
        virtual_resource res = VIRTUAL_RESOURCE(CAR(pvrp));
        string vrn = virtual_resource_name(res);
 
        MAPL(pvr, {
            virtual_resource vr = VIRTUAL_RESOURCE(CAR(pvr));
            string vrn2 = virtual_resource_name(vr);
            /* owner vro = virtual_resource_owner(vr); */
 
            /* We DO check callers and callees (DB,08/96) */
            /* if ( owner_callers_p(vro) || owner_callees_p(vro) ) {}
            else
            */ 
            if (same_string_p(vrn, vrn2))
                return true;
        }, (list) rule_required( r ) );
 
    }, (list) rule_produced( r ) );
 
    return false;
}

References CAR, MAPL, rule_produced, rule_required, same_string_p, VIRTUAL_RESOURCE, and virtual_resource_name.

Referenced by get_more_derived_resources().

Here is the caller graph for this function:

save_active_phases()

void save_active_phases

(

void

)

activate.c

Definition at line 49 of file activate.c.

{
  makefile current_makefile = parse_makefile();
 
  if (saved_active_phases == NIL)
    saved_active_phases =
      gen_copy_string_list(makefile_active_phases(current_makefile));
}

References gen_copy_string_list(), makefile_active_phases, NIL, parse_makefile(), and saved_active_phases.

Referenced by apply(), concurrent_apply(), and make().

Here is the call graph for this function:

Here is the caller graph for this function:

saved_active_phase_p()

bool saved_active_phase_p

(

const char *

phase

)

Debugging function.

Parameters

phase

hase

Definition at line 93 of file activate.c.

{
  list sapl = saved_active_phases;
 
  if(ENDP(sapl)) {
    fprintf(stderr, "Active phases have not been saved\n");
  }
  else {
    FOREACH(STRING, s, sapl)
      if (same_string_p(s, phase))
        return true; // new line for breakpoints
  }
 
  return false;
}

References ENDP, FOREACH, fprintf(), same_string_p, saved_active_phases, and STRING.

Here is the call graph for this function:

Variable Documentation

saved_active_phases

list saved_active_phases = NIL

static

Definition at line 47 of file activate.c.

Referenced by retrieve_active_phases(), save_active_phases(), and saved_active_phase_p().