bounds.c

Go to the documentation of this file.

/*
 
  $Id: bounds.c 23065 2016-03-02 09:05:50Z coelho $
 
  Copyright 1989-2016 MINES ParisTech
 
  This file is part of PIPS.
 
  PIPS is free software: you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  any later version.
 
  PIPS is distributed in the hope that it will be useful, but WITHOUT ANY
  WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.
 
  See the GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with PIPS.  If not, see <http://www.gnu.org/licenses/>.
 
*/
#ifdef HAVE_CONFIG_H
    #include "pips_config.h"
#endif
/************************************************************************/
/* Name     : bounds.c
 * Package  : reindexing
 * Author   : Alexis Platonoff
 * Date     : March 1995
 * Historic :
 *
 * Documents: SOON
 * Comments : This file contains the functions dealing with the bounds of
 * the variables and the loops.
 */
 
/* Ansi includes        */
#include <stdio.h>
 
/* Newgen includes      */
#include "genC.h"
 
/* C3 includes          */
#include "boolean.h"
#include "arithmetique.h"
#include "vecteur.h"
#include "contrainte.h"
#include "ray_dte.h"
#include "sommet.h"
#include "sg.h"
#include "sc.h"
#include "polyedre.h"
#include "matrice.h"
#include"union.h"
#include "matrix.h"
#include "sparse_sc.h"
 
/* Pips includes        */
#include "boolean.h"
#include "ri.h"
#include "constants.h"
#include "ri-util.h"
#include "misc.h"
#include "complexity_ri.h"
#include "database.h"
#include "graph.h"
#include "dg.h"
#include "paf_ri.h"
#include "parser_private.h"
#include "property.h"
#include "reduction.h"
#include "text.h"
#include "text-util.h"
#include "tiling.h"
#include "text-util.h"
#include "pipsdbm.h"
#include "resources.h"
#include "static_controlize.h"
#include "paf-util.h"
#include "pip.h"
#include "array_dfg.h"
#include "prgm_mapping.h"
#include "conversion.h"
#include "scheduling.h"
#include "reindexing.h"
 
/*====================================================================*/
/* void set_array_declaration(entity var_to_decl, list lrange)
 *
 * Set the dimensions of entity "var_to_decl" with the ranges of
 * "lrange". */
 
void set_array_declaration(var_to_decl, lrange)
entity var_to_decl;
list lrange;
{
  list lr, ldims;
  variable var;
 
  var = type_variable(entity_type(var_to_decl));
  ldims = NIL;
 
  for(lr = lrange; !ENDP(lr); POP(lr)) {
    expression lb, ub, st;
    range ra = RANGE(CAR(lr));
    
    lb = range_lower(ra);
    ub = range_upper(ra);
    st = range_increment(ra);
    
    if(!expression_equal_integer_p(st, 1))
      user_error("set_array_declaration", "\n Increment diff de 1\n");
    
    ldims = gen_nconc(ldims, CONS(DIMENSION, make_dimension(lb, ub, NIL),
                                  NIL));
  }
  variable_dimensions(var) = ldims;
}
 
 
#define IS_LOWER 0
#define IS_UPPER 1
 
/*====================================================================*/
/*
 * expression constraint_to_bound(Pcontrainte pc, entity ent, list lvar,
 *                               list lrange, int lower_or_upper,
 *                               int array_or_loop)
 *
 * Build a bound of the variable "ent" (named "e" in the following) from a
 * constraint "pc".
 *
 * This constraint may contains other variables from the list "lvar" which
 * have to be eliminated if we are in the case of ARRAY BOUNDS
 * ("array_or_loop") using their bounds (in "lrange"). See make_bounds(),
 * below.
 *
 * The nature (lower or upper) of the bound to compute is given by
 * "lower_or_upper" (lower: 0, upper: 1).
 *
 * For example, let us compute the lower bound of e with the constraint
 * (e-i+n-2 <= 0), knowing that (1 <= i <= MAX(n,m)). The elimination of i
 * is done by replacing it by n. We obtain the following lower bound : e
 * <= 2
 *
 * If the bound of a variable that have to be substitute is expressed via
 * a MIN or MAX function, we have to make a bound that will have as many
 * expressions  as there are arguments in this MIN or MAX function. This
 * variable is then successively replaced by each of these arguments.
 *
 * */
expression constraint_to_bound(pc, ent, lvar, lrange, lower_or_upper,
                               array_or_loop)
Pcontrainte pc;
entity ent;
list lvar, lrange;
int lower_or_upper, array_or_loop;
{
  expression bound = expression_undefined;
  Pvecteur vect;
  Value val;
  list llv, llr;
  Pcontrainte lvect;
  
  vect = vect_dup(pc->vecteur);
 
  /* "val" corresponds to the absolute value of the coefficient of "e" in
   * the constraint. */
  val = vect_coeff((Variable) ent, vect);
  value_absolute(val);
 
  /* "vect" represents the term of the constraints that does not contains
   * "e". We have : (e+vect <= 0) or (-e+vect <= 0), whether it is a lower
   * or upper bound. */
  vect = vect_del_var(vect, (Variable) ent);
 
  /* In the case of the upper bound, we have to change the sign of "vect"
   * in order to have a positive coefficient for "e". */
  if(lower_or_upper == IS_UPPER)
    vect_chg_sgn(vect);
 
  /* We build this Pcontrainte which will be used as a list of
   * Pvecteur. */
  lvect = contrainte_make(vect);
  
  if (get_debug_level() > 6) {
    fprintf(stderr, "\nlvect :");
    vecteur_fprint(stderr, lvect, pu_variable_name);
    fprintf(stderr, "\n");
  }
  
  /* In the case of ARRAY BOUNDS, we substitute in "vect" all the var of
   * "lvar" that have a non zero coeff by their min or max value, which is
   * given by "lrange". */
  if(array_or_loop == IS_ARRAY_BOUNDS) {
    for(llv = lvar, llr = lrange; (!ENDP(llv)) && (!ENDP(llr));
        POP(llv), POP(llr)) {
      entity var = ENTITY(CAR(llv));
      range cr = RANGE(CAR(llr));
      Value coeff;
    
      if(value_notzero_p(coeff = vect_coeff((Variable) var, vect))) {
        Pvecteur new_vect;
        expression cexp;
        normalized new_nor;
        int sign = value_sign(coeff);
 
        /* We replace the current var by whether its lower or upper bound,
         * it depends on the sign of its coefficient. It also depends on the
         * kind of bound we have to build. */
        if(lower_or_upper == IS_LOWER) {
          if(sign ==1)
            cexp = range_lower(cr);
          else
            cexp = range_upper(cr);
        }
        else                    /* lower_or_upper == IS_UPPER */ {
          if(sign==-1)
            cexp = range_lower(cr);
          else
            cexp = range_upper(cr);
        }
 
        if (get_debug_level() > 6) {
          fprintf(stderr, "Subs of %s by %s\n",
                  entity_local_name(var),
                  expression_to_string(cexp));
        }
 
        /* This expression by which we replace the current var can be of two
         * forms. The first, a single linear expression, is just
         * substitute. The second, a MAX or MIN expression has to be switch
         * in as many expressions as there are linear expressions in this
         * expression.
         * */
        new_nor = NORMALIZE_EXPRESSION(cexp);
        if(normalized_tag(new_nor) == is_normalized_linear) {
 
          if (get_debug_level() > 6) {
            fprintf(stderr, "SINGLE expression\n");
          }
 
          /* We apply the substitution on all the vectors of our list. */
          new_vect = (Pvecteur) normalized_linear(new_nor);
          for(pc = lvect; pc != NULL; pc = pc->succ) {
            pc->vecteur = vect_var_subst(pc->vecteur, (Variable) var,
                                         vect_dup(new_vect));
          }
 
        }
        else {
          if(min_or_max_expression_p(cexp)) {
            list args, la;
 
            args = call_arguments(syntax_call(expression_syntax(cexp)));
 
            if (get_debug_level() > 6) {
              fprintf(stderr, "MAX or MIN expression of %d args\n",
                      gen_length(args)); 
            }
 
            /* For each vector of our list, we duplicate it in order to take
             * into account all the arguments of this MIN or MAX
             * function. */
            for(pc = lvect; pc != NULL; pc = pc->succ) {
              Pvecteur pcv = pc->vecteur;
              Pcontrainte pcsucc = pc->succ;
 
              if (get_debug_level() > 6) {
                fprintf(stderr, "Subs in:\n");
                pu_vect_fprint(stderr, pcv);
              }
 
              /* We walk through all these arguments. */
              for(la = args; !ENDP(la); POP(la)) {
                expression arg = EXPRESSION(CAR(la));
                new_nor = NORMALIZE_EXPRESSION(arg);
                new_vect = (Pvecteur) normalized_linear(new_nor);
 
                /* This "arg" is not the last one, so we duplicate our
                 * vector before substituting. */
                pcv = pc->vecteur;
                if(CDR(la) != NIL) {
                  Pcontrainte npc = contrainte_make(vect_dup(pcv));
                  pc->succ = npc;
                  npc->succ = pcsucc;
                }
                pc->vecteur = vect_var_subst(pcv, (Variable) var,
                                             vect_dup(new_vect));
                
                if (get_debug_level() > 6) {
                  Psysteme aux_ps = sc_make(lvect, NULL);
 
                  fprintf(stderr, "Subs with %s gives:\n",
                          expression_to_string(arg));
                  pu_vect_fprint(stderr, pc->vecteur);
 
                  fprintf(stderr, "\tlvect : \n");
                  fprint_psysteme(stderr, aux_ps);
                  fprintf(stderr, "\n");
                }
 
                /* This is not the last argument, so the successor is our
                 * current vector which has been just duplicated. */
                if(CDR(la) != NIL) 
                  pc = pc->succ;
              }
            }
          }
          else
            user_error("constraint_to_bound",
                       "\nWe want a linear bound\n");
        }
      }
    }
  }
 
  /* We now build the expression that represent the bound of our variable
   * "e". This expression is a single linear one if "lvect" contains only
   * one vector, otherwise, it is a MIN or MAX expression, depending on
   * whether it is a lower or upper bound. */
  if(lvect->succ == NULL)
    bound = make_rational_exp(lvect->vecteur, val);
  else {
    call ca;
    list args = NIL;
         
    for(pc = lvect; pc != NULL; pc = pc->succ)
      ADD_ELEMENT_TO_LIST(args, EXPRESSION,
                          make_rational_exp(pc->vecteur, val));
    if(lower_or_upper == IS_LOWER)
      ca = make_call(entity_intrinsic("MIN"), args);
    else /* lower_or_upper == IS_UPPER */
      ca = make_call(entity_intrinsic("MAX"), args);
    bound = make_expression(make_syntax(is_syntax_call, ca),
                            normalized_undefined);
  }
  return(bound);
}
 
/*====================================================================*/
/*
 * expression bound_compute(Psysteme sc, entity ent, list lvar,
 *                          list lrange, int lower_or_upper
 *                         int array_or_loop) 
 *
 * Computes the lower or upper bound of a given variable "ent" from a
 * system of constraints "sc". Each constraint should contains a reference
 * to this variable and is treated separatly with constraint_to_bound(),
 * see above.
 *
 */
 
expression bound_compute(sc, ent, lvar, lrange, lower_or_upper, array_or_loop)
Psysteme sc;
entity ent;
list lvar, lrange;
int lower_or_upper, array_or_loop;
{
  expression bound = expression_undefined;
  Pcontrainte inequ;
  
  if (get_debug_level() > 6) {
    if(lower_or_upper == IS_LOWER)
      fprintf(stderr, "\nIN LOWER\n");
    else
      fprintf(stderr, "\nIN UPPER\n");
  }
  
  if(SC_UNDEFINED_P(sc))
    user_error("bound_compute", "Undefined systeme\n");
 
  for(inequ = sc->inegalites; inequ != NULL; inequ = inequ->succ) {
    if(bound == expression_undefined)
      bound = constraint_to_bound(inequ, ent, lvar, lrange,
                                  lower_or_upper, array_or_loop);
    else {
      int min_or_max;
      if(lower_or_upper == IS_LOWER)
        min_or_max = IS_MAX;
      else
        min_or_max = IS_MIN;
      bound = merge_expressions(bound,
                                constraint_to_bound(inequ, ent, lvar,
                                                    lrange,
                                                    lower_or_upper,
                                                    array_or_loop),
                                min_or_max);
    }
  }
  
  return(bound);
}
 
 
/*======================================================================*/
/* range make_bounds(ps, ent, array_or_loop, list lvar, list lrange)
 *
 * Builds the bounds of variable "ent" from the psysteme
 * "ps". "array_or_loop" gives which kind of bounds we want:
 * IS_LOOP_BOUNDS or IS_ARRAY_BOUNDS. For the first, these bounds will be
 * used in a loop, so we just have to get the constraints of "ps" and use
 * them to build these bounds (in the bounds of a given loop may appear
 * other loop indices from englobing loops). On the contrary, for the
 * second, these bounds will be used in an array dimension declaration, so
 * we first have to eliminate the other variables (in "lvar") using their
 * bounds (in "lrange") before building these bounds.
 *
 * AP 95/01/20 */
 
range make_bounds(ps, ent, array_or_loop, lvar, lrange)
Psysteme     ps;
entity       ent;
int array_or_loop;
list lvar, lrange;
{
  Pcontrainte  cont;
  expression   upper, lower, incr;
  Psysteme     sc_upper = sc_new(), sc_lower = sc_new();
  list         llr;
  
  if (get_debug_level() > 5) {
    fprintf(stderr,"\nBEGIN make_bounds : %s", entity_local_name(ent));
    fprintf(stderr,"\n\tKind : %d", array_or_loop);
    fprint_psysteme(stderr, ps);
    fprintf(stderr, "List of vars : ");
    fprint_entity_list(stderr, lvar);
    fprintf(stderr, "\nList of ranges :\n");
    for(llr = lrange; !ENDP(llr); POP(llr)) {
      fprintf(stderr, "\t%s\n",
              words_to_string(words_range(RANGE(CAR(llr)))));
    }
  }
  
  if (SC_UNDEFINED_P(ps))
    user_error("make_bounds", "\nUndefined system\n");
 
  /* the psysteme should have two constraints, one for the lb and the
   * other for the ub, but we don't know which one is what.  In fact, it
   * may have more constraints, in which case the lower or/and upper
   * bounds are expressed by MIN or MAX functions. */
  cont = ps->inegalites;
  while (cont != NULL) {
    if (value_posz_p(vect_coeff((Variable) ent, cont->vecteur)))
    { sc_add_inegalite(sc_upper, contrainte_dup(cont)); }
    else
    { sc_add_inegalite(sc_lower, contrainte_dup(cont)); }
    cont = cont->succ;
  }
    
  if (get_debug_level() > 6) {
    fprintf(stderr, "\n LOWER ps\n");
    fprint_psysteme(stderr, sc_lower);
    fprintf(stderr, "\n UPPER ps\n");
    fprint_psysteme(stderr, sc_upper);
  }
 
  /* We compute these lower and upper bounds. */
  lower = bound_compute(sc_lower, ent, lvar, lrange, IS_LOWER,
                        array_or_loop);
  upper = bound_compute(sc_upper, ent, lvar, lrange, IS_UPPER,
                        array_or_loop);
 
  ifdebug(7) {
    fprintf(stderr, "\nEND make_bounds : %s\n", entity_local_name(ent));
    fprintf(stderr, " Lower bound : %s\n",
            expression_to_string(lower));
    fprintf(stderr, " Upper bound : %s\n\n",
            expression_to_string(upper));
  }
 
  incr = int_to_expression(1);
  
  return(make_range(lower, upper, incr));
}
 
 
/*======================================================================*/
/* void get_bounds_expression(sys, lt, lb, ub)
 *
 * From the list of Psysteme psys, we determine the value of each lower
 * and upper bound of the local time.
 *
 * Lower bounds are in the inequalities of "sys" ; upper bounds are in the
 * equalities.
 *
 * AC 94/06/13
 *
 * Lower and upper bounds are now in the inequalities. So, first, we have
 * to sort these ineq in two groups, one for the lower bound and one for
 * the upper bound.
 *
 * AP 95/01/30 */
 
void get_bounds_expression(sys, lt, lb, ub)
 
     Psyslist     sys;
     list         lt, *lb, *ub;
{
  Psyslist     p = sys;
  Psysteme     sc, sc_lower = sc_new(), sc_upper = sc_new();
  Pcontrainte  cont;
  Pvecteur     vect;
  expression   lower = expression_undefined, upper = expression_undefined;
  Value        val;
  list         l = lt;
  entity       ent;
  
  for (l = lt; l != NIL; l = l->cdr)
    {
      sc = p->psys;
      ent = ENTITY(CAR(l));
      
      if (get_debug_level() > 6) {
        fprintf(stderr,"\nSysteme :");
        fprint_psysteme(stderr, sc);
      }
      
      /* Sort the inequalities */
      cont = sc->inegalites;
      while (cont != NULL) {
        if (value_posz_p(vect_coeff((Variable) ent, cont->vecteur)))
        { sc_add_inegalite(sc_upper, contrainte_dup(cont)); }
        else
        { sc_add_inegalite(sc_lower, contrainte_dup(cont)); }
        cont = cont->succ;
      }
 
      if (sc_lower->nb_ineq == 1)
        /* Only one lower bound */
        {
          vect = vect_dup((sc_lower->inegalites)->vecteur);
          val = vect_coeff((Variable) ent, vect);
          value_absolute(val);
          vect = vect_del_var(vect, (Variable) ent);
          lower = make_rational_exp(vect, val);
        }
      else if (sc_lower->nb_ineq > 1)   {
        /* More than one lower bound, build a max */
        list llower = NIL;
        for (cont = sc_lower->inegalites; cont != NULL; cont = cont->succ) {
          vect = vect_dup(cont->vecteur);
          val = vect_coeff((Variable) ent, vect);
          value_absolute(val);
          vect = vect_del_var(vect, (Variable) ent);
          llower = CONS(EXPRESSION, make_rational_exp(vect, val),
                        llower);
        }  
        lower = make_expression(make_syntax(is_syntax_call,
                                            make_call(entity_intrinsic("MAX"),
                                                      llower)),
                                normalized_undefined);
      }
      else
        user_error("get_bounds_expression", "\n No lower bound\n");
      
      if (sc_upper->nb_ineq == 1) {
        /* Only one upper bound */
        vect = vect_dup((sc_upper->inegalites)->vecteur);
        val = vect_coeff((Variable) ent, vect);
        value_absolute(val);
        vect = vect_del_var(vect, (Variable) ent);
        vect_chg_sgn(vect);
        upper = make_rational_exp(vect, val);
      }
      else if(sc_upper->nb_ineq > 1) {
        /* More than one upper bound, build a min */
        list lupper = NIL;
        for (cont = sc_upper->inegalites; cont != NULL; cont = cont->succ) {
          vect = vect_dup(cont->vecteur);
          val = vect_coeff((Variable) ent, vect);
          value_absolute(val);
          vect = vect_del_var(vect, (Variable) ent);
          vect_chg_sgn(vect);
          lupper = CONS(EXPRESSION,
                        make_rational_exp(vect, val), lupper);
        }
        upper = make_expression(make_syntax(is_syntax_call,
                                            make_call(entity_intrinsic("MIN"),
                                                      lupper)),
                                normalized_undefined);
      }
      else
        {
          user_error("get_bounds_expression", "\n No upper bound\n");
        }
      ADD_ELEMENT_TO_LIST((*lb), EXPRESSION, lower);
      ADD_ELEMENT_TO_LIST((*ub), EXPRESSION, upper);
 
      ifdebug(7) {
        fprintf(stderr,
                "\nNew lb and ub expressions :\n\tLB: %s\n\tUB: %s\n",
                expression_to_string(lower),
                expression_to_string(upper));
      }
 
    }
}
 
 
/*=========================================================================*/
/* Psyslist separate_variables(ps, l)
 *
 * We have a psystem ps containing all variables in l, and we want to have
 * a list of psystem where each system is containing the variable of its
 * rank.
 *
 *    Ex: variable t1, t2, p1.
 *  => we will have 3 systems, ps1, ps2, ps3.
 *     ps1 = f(n, t1)  (n structure parameters);
 *     ps2 = f(t1, n, t2);
 *     ps3 = f(p1, t1, t2);
 *
 * We also separate the bounds and put the constraints on the upper bound
 * in the equalities and the constraints on the lower bound in the
 * inequalities.
 *
 * AC 94/04/05 */
 
Psyslist separate_variables(ps, l, sp, c)
Psysteme     ps, *sp;
list         l;
int          c;
{
  list         lp, lr = gen_nreverse(l);
  Psyslist     lsys = NULL, lsys_aux;
  entity       ent;
  Pcontrainte  cont;
  int          i;
  Psysteme     ps_aux;
  
  (*sp) = SC_UNDEFINED;
  
  if(l != NIL) {
    for (lp = lr; lp != NIL; lp = lp->cdr) {
      Psysteme   cps = sc_new();
      ent = ENTITY(CAR(lp));
      for (cont = ps->inegalites; cont != NULL; cont = cont->succ) {
        if (base_contains_variable_p(cont->vecteur, (Variable) ent)) {
          if (value_neg_p(vect_coeff((Variable) ent, cont->vecteur)))
            { sc_add_inegalite(cps, contrainte_dup(cont)); }
          else
            { sc_add_egalite(cps, contrainte_dup(cont)); }
          cont->vecteur = VECTEUR_NUL;
        }
      }
      for (cont = ps->egalites; cont != NULL; cont = cont->succ) {
        Pvecteur pv = cont->vecteur;
        if (base_contains_variable_p(pv, (Variable) ent)) {
          if (value_neg_p(vect_coeff((Variable) ent, pv))) {
            sc_add_inegalite(cps, contrainte_make(vect_dup(pv)));
            vect_chg_sgn(pv);
            sc_add_egalite(cps, contrainte_make(vect_dup(pv))); 
          }
          else {
            sc_add_egalite(cps, contrainte_make(vect_dup(pv))); 
            vect_chg_sgn(pv);
            sc_add_inegalite(cps, contrainte_make(vect_dup(pv)));
          }
          cont->vecteur = VECTEUR_NUL;
        }
      }
      sc_normalize(cps);
      lsys = add_sc_to_sclist(cps, lsys);
    }
    
    if (get_debug_level() > 5) {
      fprintf(stderr,"\nListe de psystemes construite :");
      sl_fprint(stderr,lsys,entity_local_name);
    }
 
    lsys_aux = lsys;
    for (i = 1; i <= c; i++) {
      lsys_aux = lsys_aux->succ;
    }
 
    for (; lsys_aux != NULL; lsys_aux = lsys_aux->succ) {
      ps_aux = lsys_aux->psys;
 
      /* add inequalities on the max */
      while (ps_aux->egalites != NULL) {
        cont = ps_aux->egalites;
        ps_aux->egalites = (ps_aux->egalites)->succ;
        cont->succ = NULL;
        sc_add_inegalite(ps_aux, cont);
      }
      (*sp) = sc_append(*sp, sc_dup(ps_aux));
    }
  }
    
  return(lsys); 
}
 
/*=========================================================================*/
/* Psyslist separate_variables_2(ps, l): we have a psystem ps containing all
 * variables in l, and we want to have a list of psystem where each system
 * is containing the variable of its rank.
 *    Ex: variable t1, t2, p1.
 *  => we will have 3 systems, ps1, ps2, ps3.
 *     ps1 = f(n, t1)  (n structure parameters);
 *     ps2 = f(t1, n, t2);
 *     ps3 = f(p1, t1, t2);
 *
 * same function as above but we do not distinguish the min from the max.
 *
 * AC 94/04/05
 */
 
Psyslist separate_variables_2(ps, l, sp, c)
 
 Psysteme     ps, *sp;
 list         l;
 int          c;
{
 list         lp, lr = gen_nreverse(l);
 Psyslist     lsys = NULL, lsys_aux, lsys_aux2;
 entity       ent;
 Pcontrainte  cont;
 int          i;
 Psysteme     ps_aux;
 
 (*sp) = SC_UNDEFINED;
 
 for (lp = lr; lp != NIL; lp = lp->cdr)
   {
    Psysteme   cps = sc_new();
    ent = ENTITY(CAR(lp));
    for (cont = ps->inegalites; cont != NULL; cont = cont->succ)
      {
       if (base_contains_variable_p(cont->vecteur, (Variable) ent))
         {
          sc_add_inegalite(cps, contrainte_dup(cont));
          cont->vecteur = VECTEUR_NUL;
         }
      }
    sc_normalize(cps);
    lsys = add_sc_to_sclist(cps, lsys);
   }
 
 if (get_debug_level() > 5)
   {
    fprintf(stderr,"\nListe de psystemes construite 2:");
    sl_fprint(stderr,lsys,entity_local_name);
   }
 
 if (c == 1)
   {
    lsys_aux = lsys->succ;
 
    for (; lsys_aux != NULL; lsys_aux = lsys_aux->succ)
      {
       ps_aux = lsys_aux->psys;
 
       /* add inequalities on the max */
       while (ps_aux->egalites != NULL)
         {
          cont = ps_aux->egalites;
          ps_aux->egalites = (ps_aux->egalites)->succ;
          cont->succ = NULL;
          sc_add_inegalite(ps_aux, cont);
         }
       (*sp) = sc_append(*sp, sc_dup(ps_aux));
      }
   }
 else
   {
    lsys_aux = lsys->succ;
    lsys_aux2 = lsys;
    for (i = 2; i <= c; i++)
      {
       lsys_aux = lsys_aux->succ;
       lsys_aux2 = lsys_aux2->succ;
      }
 
    for (; lsys_aux != NULL; lsys_aux = lsys_aux->succ)
      {
       ps_aux = lsys_aux->psys;
       /* add inequalities on the max */
       while (ps_aux->egalites != NULL)
         {
          cont = ps_aux->egalites;
          ps_aux->egalites = (ps_aux->egalites)->succ;
          cont->succ = NULL;
          sc_add_inegalite(ps_aux, cont);
         }   
       (*sp) = sc_append(*sp, sc_dup(ps_aux));
      }
   }
 
 if (get_debug_level() > 5)
   {
    fprintf(stderr,"\nListe de psystemes construite en final 2:");
    sl_fprint(stderr,lsys,entity_local_name);
   }
 
 return(reverse_psyslist(lsys)); 
}