PIPS
solpip.c
Go to the documentation of this file.
1 /*
2 
3  $Id: solpip.c 23065 2016-03-02 09:05:50Z coelho $
4 
5  Copyright 1989-2016 MINES ParisTech
6 
7  This file is part of PIPS.
8 
9  PIPS is free software: you can redistribute it and/or modify it
10  under the terms of the GNU General Public License as published by
11  the Free Software Foundation, either version 3 of the License, or
12  any later version.
13 
14  PIPS is distributed in the hope that it will be useful, but WITHOUT ANY
15  WARRANTY; without even the implied warranty of MERCHANTABILITY or
16  FITNESS FOR A PARTICULAR PURPOSE.
17 
18  See the GNU General Public License for more details.
19 
20  You should have received a copy of the GNU General Public License
21  along with PIPS. If not, see <http://www.gnu.org/licenses/>.
22 
23 */
24 #ifdef HAVE_CONFIG_H
25  #include "pips_config.h"
26 #endif
27 /* Name : solpip.c
28  * Package : pip
29  * Author : F. Dumontet
30  * Date : july 93
31  * Historic :
32  * - 17 nov 93, replace MakeBinaryCall() by make_op_exp(). AP
33  *
34  * Documents:
35  *
36  * Comments :
37  */
38 
39 #include <stdlib.h>
40 #include <stdio.h>
41 #include <stdlib.h>
42 #include <string.h>
43 
44 #include "genC.h"
45 #include "misc.h"
46 #include "text.h"
47 #include "text-util.h"
48 #include "ri.h"
49 #include "ri-util.h"
50 #include "paf_ri.h"
51 #include "pip.h"
52 
53 #define PREMIERE_VAR1_BASE premiere_var1 == 0
54 #define RESET_PREMIERE_VAR1 premiere_var1 = 0;
55 #define SET_PREMIERE_VAR1 premiere_var1 = 1;
56 #define PREMIERE_VAR_BASE premiere_var == 0
57 #define RESET_PREMIERE_VAR premiere_var = 0;
58 #define SET_PREMIERE_VAR premiere_var = 1;
59 #define OLD_VAR(x) x->var==NULL
60 #define MY_MIN 0
61 #define MY_MAX 1
62 #define VARSUPP "Variable_pour_max_en_min_q"
63 
64 
65 typedef struct baseaux
66  {
67  expression var;
68  entity ent;
69  struct baseaux *succ;
70  } baseaux,*Pbaseaux;
71 
72 typedef struct pileaux
73  {
74  Pbaseaux pred;
75  Pbaseaux act;
76  struct pileaux *succ;
77  } pileaux,*Ppileaux;
78 
79 typedef struct pilepredicat
80  {
81  predicate x;
82  struct pilepredicat *succ;
83  } pilepredicat, *Ppilepredicat;
84 
85 typedef struct pilequast
86  {
87  quast q;
88  struct pilequast *succ;
89  } pilequast, *Ppilequast;
90 
91 list newparms_act;
92 list solution_act;
93 static Ppilepredicat predicate_act;
94 expression expression_act;
95 quast quast_false;
96 quast_value quast_value_act;
97 conditional conditional_act;
98 static Ppilequast quast_true;
99 static Ppileaux pile;
100 static Pbaseaux new_base_ref;
101 static Pbaseaux new_base_aux;
102 Pvecteur vect_act, vect_aux, vect_var_aux;
103 Psysteme psyst_act;
104 int aux, premiere_var, premiere_var1,compteur_de_var;
105 
106 
107 /*----------------------------------------------------------------------------*/
108 /* */
109 /* Name: ajoute_constante */
110 /* */
111 /* Parameters: ent : entier, valeur de la constante cree. */
112 /* */
113 /* Side effect : expression_act: est modifie, il lui est ajoute une */
114 /* constante. */
115 /* */
116 /* Result: void. */
117 /* */
118 /* Aims: ajouter une constante a expression_act: */
119 /* expression_act= expression_act+ent. */
120 /* */
121 /* Author: F Dumontet. */
122 /* */
123 /* Date of last change: */
124 /* */
125 /*----------------------------------------------------------------------------*/
126 void
127 ajoute_constante ( ent )
128 
129  int ent;
130 
131 {
132  if (expression_act == NULL)
133  {
134  expression_act=int_to_expression(ent);
135  return;
136  }
137 
138  if (ent>=0)
139  expression_act = make_op_exp(PLUS_OPERATOR_NAME, expression_act,
140  int_to_expression( ent ));
141  else
142  expression_act = make_op_exp(MINUS_OPERATOR_NAME, expression_act,
143  int_to_expression( -ent ));
144 
145  return;
146 }
147 /*----------------------------------------------------------------------------*/
148 /* */
149 /* Name: retire_par_de_pile. */
150 /* */
151 /* Parameters: */
152 /* */
153 /* Side effect: new_base_ref: on en retire le dernier "newparm" ajoute. */
154 /* newparms_act: on retire le premier element de la liste. */
155 /* pile: on retire l'element du haut de la pile de gestion de */
156 /* localite des "newparms". */
157 /* */
158 /* Result: void. */
159 /* */
160 /* Aims: retirer les parametres crees par le newparm correspondant:gestion de */
161 /* la localite. */
162 /* */
163 /* Author: F Dumontet. */
164 /* */
165 /* Date of last change: */
166 /* */
167 /*----------------------------------------------------------------------------*/
168 void retire_par_de_pile()
169 
170 {
171 
172  Ppileaux pile1 = pile;
173 
174  newparms_act = CDR(newparms_act);
175  if (pile->pred != NULL)
176  pile->pred->succ = pile->act->succ;
177  else
178  new_base_ref = new_base_ref->succ;
179 
180 
181  pile = pile->succ;
182  free( pile1 );
183 }
184 
185 /*----------------------------------------------------------------------------*/
186 /* */
187 /* Name: init_quast. */
188 /* */
189 /* Parameters: */
190 /* */
191 /* Side effect: expression_act: remis a 0. */
192 /* solution_act: remis a 0. */
193 /* */
194 /* Result: void */
195 /* */
196 /* Aims: initialiser les variables necessaires a la creation d'un "quast". */
197 /* */
198 /* Author: F. Dumontet. */
199 /* */
200 /* Date of last change: */
201 /* */
202 /*----------------------------------------------------------------------------*/
203 
204 void
205 init_quast ()
206 
207 {
208 extern expression expression_act;
209 
210  expression_act = NULL;
211  solution_act = NIL;
212 }
213 
214 /*----------------------------------------------------------------------------*/
215 /* */
216 /* Name: creer_quast_value */
217 /* */
218 /* Parameters: */
219 /* */
220 /* Side effect: quast_value_act: recoit le "quast_value" cree. */
221 /* */
222 /* Result: void. */
223 /* */
224 /* Aims: creer un "quast_value" a partir d'une "solution". */
225 /* */
226 /* Author: F. Dumontet */
227 /* */
228 /* Date of last change: */
229 /* */
230 /*----------------------------------------------------------------------------*/
231 void
232 creer_quast_value ()
233 
234 {
235 extern quast_value quast_value_act;
236 
237  if ( solution_act != NIL)
238  quast_value_act = make_quast_value (is_quast_value_quast_leaf,\
239  make_quast_leaf((char *) solution_act,
240  leaf_label_undefined) );
241  else
242  quast_value_act = quast_value_undefined;
243 }
244 
245 /*----------------------------------------------------------------------------*/
246 /* */
247 /* Name: creer_true_quast. */
248 /* */
249 /* Parameters: */
250 /* */
251 /* Side effect: quast_true: recoit le true "quast_cree" sur le haut de la */
252 /* pile. */
253 /* */
254 /* Result: void. */
255 /* */
256 /* Aims: conserver le "true_quast" d'un IF dans la pile des "true_quast". */
257 /* */
258 /* Author: F Dumontet. */
259 /* */
260 /* Date of last change: */
261 /* */
262 /*----------------------------------------------------------------------------*/
263 void
264 creer_true_quast ()
265 
266 {
267 
268  Ppilequast new_quast;
269 
270  new_quast = (Ppilequast)malloc(sizeof(pilequast));
271  new_quast->succ = quast_true;
272  new_quast->q = quast_act;
273  quast_true = new_quast;
274 }
275 
276 /*----------------------------------------------------------------------------*/
277 /* */
278 /* Name: creer_predicat. */
279 /* */
280 /* Parameters: */
281 /* */
282 /* Side effect: predicat_act: recoit le "predicat" cree sur le haut de la */
283 /* pile. */
284 /* */
285 /* Result: void. */
286 /* */
287 /* Aims: creer un "predicat" a partir d'un "Psysteme", ce "predicat" est mis */
288 /* sur le haut de la pile des "predicats". */
289 /* */
290 /* Author: F Dumontet. */
291 /* */
292 /* Date of last change: */
293 /* */
294 /*----------------------------------------------------------------------------*/
295 void
296 creer_predicat ()
297 
298 {
299 
300 
301  Ppilepredicat new_predicate;
302 
303  new_predicate = (Ppilepredicat)malloc(sizeof(pilepredicat));
304  if (psyst_act != NULL) {
305  psyst_act->base = NULL;
306  sc_creer_base( psyst_act );
307  }
308  new_predicate->x = make_predicate ( (char *) psyst_act);
309  new_predicate->succ = predicate_act;
310  predicate_act = new_predicate;
311 }
312 
313 /*----------------------------------------------------------------------------*/
314 /* */
315 /* Name: fait_quast. */
316 /* */
317 /* Parameters: */
318 /* */
319 /* Side effect: quast_false: recoit le second "quast" d'un IF. */
320 /* quast_act: idem. */
321 /* */
322 /* Result: void. */
323 /* */
324 /* Aims: creer un "quast" a partir d'un "quast_value" et d'un "newparms". */
325 /* */
326 /* Author: F Dumontet. */
327 /* */
328 /* Date of last change: */
329 /* */
330 /*----------------------------------------------------------------------------*/
331 void fait_quast ()
332 {
333 extern quast quast_false, quast_act;
334  list newparms_aux;
335 
336  newparms_aux = gen_append(newparms_act,NIL);
337  quast_act = make_quast ((char *) quast_value_act,\
338  (char *) newparms_aux);
339  quast_false = quast_act;
340 }
341 
342 /*----------------------------------------------------------------------------*/
343 /* */
344 /* Name: fait_quast_value. */
345 /* */
346 /* Parameters: */
347 /* */
348 /* Side effect: quast_value_act: recoit le "quast_value" cree. */
349 /* quast_true: on depile un element. */
350 /* predicate_act: on depile un element. */
351 /* conditional_act: recoit le "conditional" cree. */
352 /* */
353 /* Result: void. */
354 /* */
355 /* Aims: creer un "quast_value" a partir d'un "predicat", d'un "true_quast", */
356 /* d'un "false_quast". le" true_quast" et le" predicat" sont consommes */
357 /* et donc retires de leur pile respective. */
358 /* */
359 /* Author: F Dumontet. */
360 /* */
361 /* Date of last change: */
362 /* */
363 /*----------------------------------------------------------------------------*/
364 void
365 fait_quast_value ()
366 {
367 
368 extern quast_value quast_value_act;
369 extern conditional conditional_act;
370  Ppilepredicat old_predicate = predicate_act;
371  Ppilequast old_quast = quast_true;
372 
373  conditional_act = make_conditional (predicate_act->x,\
374  quast_true->q, quast_false);
375  quast_value_act = make_quast_value (is_quast_value_conditional,\
376  (char *) conditional_act);
377  predicate_act = predicate_act->succ;
378  free(old_predicate);
379  quast_true = quast_true->succ;
380  free(old_quast);
381 }
382 
383 /*----------------------------------------------------------------------------*/
384 /* */
385 /* Name: init_liste_vecteur. */
386 /* */
387 /* Parameters: */
388 /* */
389 /* Side effect: vect_var_aux: initialisation, pointe sur le debut de la base */
390 /* des variables (au sens Psysteme) initiales du probleme. */
391 /* solution_act: mise a vide de la file. */
392 /* */
393 /* Result: void. */
394 /* */
395 /* Aims: initialiser les variables necessaires a la construction d'une */
396 /* "liste de vecteurs". */
397 /* */
398 /* Author: F Dumontet. */
399 /* */
400 /* Date of last change: */
401 /* */
402 /*----------------------------------------------------------------------------*/
403 
404 void
405 init_liste_vecteur ()
406 {
407 
408 extern Pvecteur vect_var_aux;
409 
410  vect_var_aux = (Pvecteur) base_var_ref;
411  solution_act = NIL;
412 
413 }
414 
415 /*----------------------------------------------------------------------------*/
416 /* */
417 /* Name: init_vecteur. */
418 /* */
419 /* Parameters: */
420 /* */
421 /* Side effect: expression_act: mise a vide. */
422 /* new_base_aux: pointe sur le premier element de la base locale */
423 /* c a d celle qui contient les "newparms". */
424 /* vect_aux: pointe sur la base initiale des parametres du pb. */
425 /* premiere_var: positionne a RESET. */
426 /* */
427 /* Result: void. */
428 /* */
429 /* Aims: initialiser les variables necessaires a l'ecriture d'un "vecteur" */
430 /* sous forme d'une "expression". */
431 /* */
432 /* Author: F Dumontet. */
433 /* */
434 /* Date of last change: */
435 /* */
436 /*----------------------------------------------------------------------------*/
437 void
438 init_vecteur ()
439 {
440 
441 extern expression expression_act;
442 extern Pvecteur vect_aux;
443 extern int premiere_var;
444 
445  expression_act = NULL;
446  new_base_aux = new_base_ref;
447  vect_aux = (Pvecteur) base_ref;
448  RESET_PREMIERE_VAR
449 }
450 
451 /*----------------------------------------------------------------------------*/
452 /* */
453 /* Name: ecrit_coeff1. */
454 /* */
455 /* Parameters: ent: entier, coefficient de la variable pointee par */
456 /* "new_base_aux", a entrer dans le "Psysteme". */
457 /* */
458 /* Side effect: psyst_act: le "Psysteme" resultat avec une variable en plus */
459 /* (dans la "base" et dans le "vecteur"). NON !! */
460 /* vect_aux: pointe sur la variable suivante a traiter. */
461 /* new_base_aux: pointe sur la variable suivante a traiter. */
462 /* */
463 /* Result: void. */
464 /* */
465 /* Aims: ajouter le coefficient et sa variable correspondante dans le */
466 /* Psysteme a produire. */
467 /* */
468 /* Author: F Dumontet. */
469 /* */
470 /* Date of last change: */
471 /* */
472 /*----------------------------------------------------------------------------*/
473 void
474 ecrit_coeff1 ( ent )
475  int ent;
476 {
477  extern Psysteme psyst_act;
478  extern Pvecteur vect_aux;
479 
480  if ((ind_min_max == MY_MAX) && (vect_aux != NULL) &&
481  (vect_aux->var != NULL) &&
482  (strcmp(entity_local_name((entity) vect_aux->var), VARSUPP) == 0)) {
483  vect_aux = vect_aux->succ;
484  new_base_aux = new_base_aux->succ;
485  return;
486  }
487  if (new_base_aux == NULL) {
488  /*vect_add_elem(&psyst_act->base, TCST, (value) 1);*/
489  vect_add_elem(&psyst_act->inegalites->vecteur, (Variable) TCST,
490  (Value) -ent);
491  return;
492  }
493 
494  if (new_base_aux->var == NULL) {
495  vect_add_elem(&psyst_act->base, vect_aux->var, (Value) 1);
496  vect_add_elem(&psyst_act->inegalites->vecteur, vect_aux->var,
497  (Value) -ent);
498  vect_aux = vect_aux->succ;
499  psyst_act->dimension++;
500  }
501  else {
502  vect_add_elem(&psyst_act->base,
503  (Variable) new_base_aux->ent, (Value) 1);
504  vect_add_elem(&psyst_act->inegalites->vecteur,
505  (Variable) new_base_aux->ent, (Value) -ent);
506  }
507 
508  new_base_aux = new_base_aux->succ;
509 }
510 
511 /*----------------------------------------------------------------------------*/
512 /* TEMPORAIRE */
513 /* Name: */
514 /* */
515 /* Parameters: */
516 /* */
517 /* Side effect: */
518 /* */
519 /* Result: */
520 /* */
521 /* Aims: */
522 /* */
523 /* Author: F Dumontet. */
524 /* */
525 /* Date of last change: */
526 /* */
527 /*----------------------------------------------------------------------------*/
528 void
529 ecrit_resultat ()
530 
531 {
532  write_quast(stdout,quast_act);
533 }
534 
535 
536 /*----------------------------------------------------------------------------*/
537 /* */
538 /* Name: creer_Psysteme. */
539 /* */
540 /* Parameters: */
541 /* */
542 /* Side effect: psyst_act: recoit le "Psysteme" cree. */
543 /* vect_aux: pointe sur le premier parametre de la base initiale. */
544 /* new_base_aux: pointe sur le premier parametre de la base */
545 /* contenant des les newparms. */
546 /* */
547 /* Result: void. */
548 /* */
549 /* Aims: initialiser le psysteme et les variables permettant de le construire.*/
550 /* */
551 /* Author: F Dumontet. */
552 /* */
553 /* Date of last change: */
554 /* */
555 /*----------------------------------------------------------------------------*/
556 
557 void
558 creer_Psysteme()
559 
560 {
561 
562 extern Psysteme psyst_act;
563 extern Pvecteur vect_aux;
564  Psysteme p_syst;
565 
566  p_syst = sc_new();
567  p_syst->dimension = 0;
568  p_syst->nb_ineq = 1;
569  p_syst->inegalites = contrainte_new();
570  psyst_act = p_syst;
571  vect_aux = (Pvecteur) old_base;/* a changer par base_ref*/
572  new_base_aux = new_base_ref;
573 
574 }
575 
576 
577 /*----------------------------------------------------------------------------*/
578 /* */
579 /* Name: init_new_base. */
580 /* */
581 /* Parameters: */
582 /* */
583 /* Side effect: new_base_ref: recoit la nouvelle base initialisee. */
584 /* compteur de var: initialisation a 0. */
585 /* newparms: initialisation de la liste a vide. */
586 /* */
587 /* Result: void. */
588 /* */
589 /* Aims: creer a partir de la base initiale , la nouvelle base contenant aussi*/
590 /* les "newparms". Comme il s'agit de l'initialisation, il n'y a pas de */
591 /* "newparms" donc tous les champs "var" sont a NULL. Les autres "var" */
592 /* permettant la construction future de cette base sont initialisees. */
593 /* */
594 /* Author: F Dumontet. */
595 /* */
596 /* Date of last change: */
597 /* _ jan 5th 94, AP, new_base_ref MUST be initialized to NULL (when */
598 /* base_ref is empty) */
599 /* */
600 /*----------------------------------------------------------------------------*/
601 void init_new_base ( )
602 
603 {
604 
605 extern int compteur_de_var;
606  Pbaseaux new_base_aux1 = (Pbaseaux) NULL, bbase_aux;
607  Pvecteur vect_aux1 = (Pvecteur) base_ref;
608  int premiere_var;
609 
610  compteur_de_var=0;
611  RESET_PREMIERE_VAR
612  newparms_act = NIL;
613  new_base_ref = NULL;
614 
615  for ( ;vect_aux1 != NULL ; vect_aux1 =vect_aux1->succ)
616  {
617  bbase_aux = (Pbaseaux) malloc(sizeof(baseaux));
618  bbase_aux->var = NULL;
619  bbase_aux->ent = NULL;
620  bbase_aux->succ = NULL;
621 
622  if ( PREMIERE_VAR_BASE )
623  {
624  new_base_ref = bbase_aux;
625  new_base_aux1 = bbase_aux;
626  SET_PREMIERE_VAR
627  }
628  else
629  {
630  new_base_aux1->succ = bbase_aux;
631  new_base_aux1 = new_base_aux1->succ;
632  }
633  }
634 
635  return;
636 
637 }
638 
639 /*----------------------------------------------------------------------------*/
640 /* */
641 /* Name: creer_nom_entite. */
642 /* */
643 /* Parameters: module_name: le nom du module?? TOP_LEVEL_MODULE_NAME. */
644 /* */
645 /* Side effect: compteur_de_var: incrementation de 1. */
646 /* */
647 /* Result: une "entite" dont le nom est cree automatiquement. */
648 /* */
649 /* Aims: creer automatiquement des "entites" ayant pour nom nvarxxx. */
650 /* */
651 /* Author: F Dumontet. */
652 /* */
653 /* Date of last change: */
654 /* */
655 /*----------------------------------------------------------------------------*/
656 entity
657 creer_nom_entite(module_name)
658 
659 char *module_name;
660 
661 {
662 extern int compteur_de_var;
663  string full_name;
664  char *name;
665  char *num;
666  entity e ;
667  basic b ;
668 
669  compteur_de_var++;
670  num = (char*) malloc(64);
671  name= (char*) malloc(70);
672  (void) sprintf( name, "nvar%d" , compteur_de_var);
673  (void) sprintf((char *) (num), "%d", compteur_de_var);
674 
675  debug(8,"make_scalar_integer_entity", "begin name=%s, module_name=%s\n",
676  name, module_name);
677 
678  full_name = concatenate(module_name, MODULE_SEP_STRING, name, NULL);
679  e = make_entity((char *) strdup(full_name),
680  type_undefined,
681  storage_undefined,
682  value_undefined);
683 
684  b = make_basic(is_basic_int, 4);
685 
686  entity_type(e) = (type) MakeTypeVariable(b, NIL);
687 
688  return (e);
689 }
690 
691 /*----------------------------------------------------------------------------*/
692 /* */
693 /* Name: ajoute_new_var. */
694 /* */
695 /* Parameters: ent: valeur du diviseur. */
696 /* rang: position de la nouvelle variable dans le vecteur. */
697 /* */
698 /* Side effect: new_base_ref: lorsque la nouvelle variable est ajoutee en tete*/
699 /* de la base, recoit la nouvelle base modifiee. */
700 /* pile: ajout du nouveau parametre sur la pile pour la gestion */
701 /* de la localite de ces variables. */
702 /* newparms_act: ajout du nouveau parametre a la liste. */
703 /* */
704 /* Result: void. */
705 /* */
706 /* Aims: ajouter un nouveau parametre dans la nouvelle base. Les piles de */
707 /* gestion de la localite et de reference entre "entite" et "expression"*/
708 /* sont mises a jour. */
709 /* */
710 /* Author: F Dumontet. */
711 /* */
712 /* Date of last change: */
713 /* */
714 /*----------------------------------------------------------------------------*/
715 void ajoute_new_var ( ent , rang )
716 
717  int ent, rang;
718 
719 {
720 
721 
722  Pbaseaux new_var, new_base_aux1 = new_base_ref ;
723  expression expr;
724  Ppileaux new_pile;
725  entity enti_act;
726  var_val var_val_act;
727  int aux;
728 
729  expr = make_op_exp(DIVIDE_OPERATOR_NAME, expression_act,
730  int_to_expression( ent ));
731  for (aux=0; aux<(rang-1) ; aux++)
732  { new_base_aux1 = new_base_aux1->succ;}
733 
734  new_var=(Pbaseaux) malloc(sizeof(baseaux));
735  new_var->var = expr;
736 
737  enti_act = creer_nom_entite(TOP_LEVEL_MODULE_NAME);
738  new_var->ent = enti_act;
739 
740  var_val_act = make_var_val(enti_act, expr);
741  newparms_act = CONS(VAR_VAL,var_val_act,newparms_act);
742  new_pile = (Ppileaux) malloc(sizeof(pileaux));
743  new_pile->act = new_var;
744  new_pile->succ = pile;
745 
746  if ( rang > 0)
747  {
748  new_var->succ = new_base_aux1->succ;
749  new_base_aux1->succ = new_var;
750  new_pile->pred = new_base_aux1;
751  }
752  else
753  {
754  new_var->succ = new_base_ref;
755  new_base_ref = new_var;
756  new_pile->pred = NULL;
757  }
758  pile = new_pile;
759  return ;
760 }
761 
762 
763 /*----------------------------------------------------------------------------*/
764 /* */
765 /* Name: ecrit_liste_vecteur. */
766 /* */
767 /* Parameters: */
768 /* */
769 /* Side effect: solution_act: ajout d'un "vecteur" a la "liste de vecteurs". */
770 /* vect_var_aux: passe a la variable suivante. */
771 /* */
772 /* Result: void. */
773 /* */
774 /* Aims: mettre dans la "liste de vecteur" "l'expression" correspondant a un */
775 /* "vecteur". */
776 /* */
777 /* Author: F Dumontet. */
778 /* */
779 /* Date of last change: */
780 /* */
781 /*----------------------------------------------------------------------------*/
782 void
783 ecrit_liste_vecteur()
784 
785 
786 {
787 extern Pvecteur vect_var_aux;
788 
789  if ( vect_var_aux == NULL )
790  return;
791 
792  solution_act = gen_nconc(solution_act, CONS(EXPRESSION, expression_act, NIL));
793  vect_var_aux = vect_var_aux->succ;
794  return;
795 }
796 
797 
798 void ecrit_une_var_neg(int ent);
799 
800 /*----------------------------------------------------------------------------*/
801 /* */
802 /* Name: ecrire_une_var. */
803 /* */
804 /* Parameters: ent: valeur du parametre. */
805 /* */
806 /* Side effect: new_base_aux, vect_aux: pointent sur le prochain parametre */
807 /* respectivement dans les bases initiale et actuelle. */
808 /* expression_act: l'expression obtenue. */
809 /* premiere_ver: mis a set. */
810 /* */
811 /* Result: void. */
812 /* */
813 /* Aims: ajouter un parametre et son coefficient a une "expression" */
814 /* correspondant a un vecteur. Les pointeurs de base sont actualises . */
815 /* */
816 /* Author: F Dumontet. */
817 /* */
818 /* Date of last change: */
819 /* */
820 /*----------------------------------------------------------------------------*/
821 
822 void
823 ecrit_une_var ( ent )
824 
825  int ent;
826 
827 {
828 
829 extern Pvecteur vect_aux;
830 extern expression expression_act;
831 extern int premiere_var;
832  expression e_act = expression_act;
833  Pbaseaux p_base1 = new_base_aux;
834 
835  if (ind_min_max == MY_MAX)
836  {
837  if ((vect_aux != NULL) && (vect_aux->var != NULL) &&\
838  (strcmp(entity_local_name((entity) vect_aux->var), VARSUPP) == 0))
839  {
840  ent = 0;
841  }
842  else
843  {
844  if ( (p_base1 == NULL) || (OLD_VAR(p_base1)) )
845  {
846  ent = -ent;
847  }
848  else
849  {
850  ecrit_une_var_neg (ent);
851  return;
852  }
853  }
854  }
855 
856  if ((p_base1 == NULL) || ((vect_aux != NULL)&&(vect_aux->var == TCST)))
857  {
858  ajoute_constante( ent );
859  return;
860  }
861 
862  if ( ent == 0 )
863  {
864  if (OLD_VAR(p_base1))
865  vect_aux = vect_aux->succ;
866  new_base_aux = new_base_aux->succ;
867  return;
868  }
869 
870 
871 
872  if ( PREMIERE_VAR_BASE )
873  {
874  if ( OLD_VAR(p_base1) )
875  {
876  expression_act = make_factor_expression( ent, \
877  (entity) vect_aux->var);
878 
879  vect_aux = vect_aux->succ;
880  }
881  else
882  {
883  expression_act = make_op_exp(MULTIPLY_OPERATOR_NAME,
884  int_to_expression( ent ),
885  (expression) p_base1->var);
886  }
887  SET_PREMIERE_VAR
888  }
889  else
890  {
891  if ( OLD_VAR(p_base1) )
892  {
893  expression_act = make_op_exp(PLUS_OPERATOR_NAME, e_act,
894  make_factor_expression(ent,
895  (entity) vect_aux->var));
896 
897  vect_aux = vect_aux->succ;
898  }
899  else
900  {
901  expression_act = make_op_exp(PLUS_OPERATOR_NAME, e_act,
902  make_op_exp(MULTIPLY_OPERATOR_NAME,
903  int_to_expression( ent ),
904  (expression) p_base1->var));
905  }
906  }
907  new_base_aux = new_base_aux->succ;
908 
909  return ;
910 }
911 
912 /*----------------------------------------------------------------------------*/
913 /* */
914 /* Name: ecrit_une_var_neg. */
915 /* */
916 /* Parameters: ent: valeur du parametre negatif. */
917 /* */
918 /* Side effect: new_base_aux, vect_aux: pointent sur le prochain parametre */
919 /* respectivement dans les bases initiale et actuelle. */
920 /* expression_act: l'expression obtenue. */
921 /* premiere_ver: mis a set. */
922 /* */
923 /* Result: void. */
924 /* */
925 /* Aims: ajouter un parametre et son coefficient a une "expression" */
926 /* correspondant a un vecteur. Les pointeurs de base sont actualises . */
927 /* */
928 /* Author: F Dumontet. */
929 /* */
930 /* Date of last change: */
931 /* */
932 /*----------------------------------------------------------------------------*/
933 
934 void
935 ecrit_une_var_neg (ent)
936 
937  int ent;
938 
939 {
940 
941 
942 extern expression expression_act;
943 extern int premiere_var;
944 extern int ind_min_max;
945  expression e_act = expression_act;
946  Pbaseaux p_base1 = new_base_aux;
947 
948 
949  if (ind_min_max == MY_MAX)
950  {
951  if ((vect_aux != NULL) && (vect_aux->var != NULL) &&\
952  (strcmp(entity_local_name((entity) vect_aux->var), VARSUPP) == 0))
953  {
954  ent = 0;
955  }
956  else
957  {
958  ind_min_max = MY_MIN;
959  ecrit_une_var(ent);
960  ind_min_max = MY_MAX;
961  return;
962  }
963  }
964 
965  if ((p_base1 == NULL) || ((vect_aux != NULL)&&(vect_aux->var == TCST)))
966  {
967  ajoute_constante( -ent );
968  return;
969  }
970 
971  if ( OLD_VAR(p_base1) )
972  {
973  ecrit_une_var(-ent);
974  return;
975  }
976  else
977  {
978  expression_act = MakeUnaryCall(\
979  gen_find_tabulated(\
980  make_entity_fullname(\
981  TOP_LEVEL_MODULE_NAME,\
982  UNARY_MINUS_OPERATOR_NAME),\
983  entity_domain),\
984  int_to_expression( ent ));
985 
986  if ( PREMIERE_VAR_BASE )
987  {
988  expression_act = make_op_exp(MULTIPLY_OPERATOR_NAME,
989  expression_act,
990  (expression) p_base1->var);
991  SET_PREMIERE_VAR
992  }
993  else
994  {
995  expression_act = make_op_exp(PLUS_OPERATOR_NAME, e_act,
996  make_op_exp(MULTIPLY_OPERATOR_NAME,
997  expression_act,
998  (expression) p_base1->var));
999  }
1000  }
1001  new_base_aux = new_base_aux->succ;
1002  return;
1003 }
1004 
1005 /*----------------------------------------------------------------------------*/
1006 /* */
1007 /* Name: ecrit_coeff_neg2. */
1008 /* */
1009 /* Parameters: ent: valeur du parametre. */
1010 /* */
1011 /* Side effect: new_base_aux, vect_aux: pointent sur le prochain parametre */
1012 /* respectivement dans les bases initiale et actuelle. */
1013 /* expression_act: l'expression obtenue. */
1014 /* premiere_ver: mis a set. */
1015 /* */
1016 /* Result: void. */
1017 /* */
1018 /* Aims: ajouter un parametre et son coefficient a une "expression" */
1019 /* correspondant a un vecteur. Les pointeurs de base sont actualises . */
1020 /* */
1021 /* Author: F Dumontet. */
1022 /* */
1023 /* Date of last change: */
1024 /* */
1025 /*----------------------------------------------------------------------------*/
1026 
1027 void
1028 ecrit_coeff_neg2 ( ent )
1029 
1030  int ent;
1031 {
1032 
1033 extern int ind_min_max;
1034  int garde_min_max = MY_MIN;
1035 
1036 
1037  if (ind_min_max == MY_MAX)
1038  garde_min_max = MY_MAX;
1039  ind_min_max = MY_MIN;
1040  if (new_base_aux == NULL)
1041  ajoute_constante ( -ent );
1042  else
1043  ecrit_une_var_neg( ent );
1044  if (garde_min_max == MY_MAX)
1045  ind_min_max = MY_MAX;
1046 }
1047 /*----------------------------------------------------------------------------*/
1048 /* */
1049 /* Name: ecrire_coeff2 . */
1050 /* */
1051 /* Parameters: ent: valeur du parametre. */
1052 /* */
1053 /* Side effect: new_base_aux, vect_aux: pointent sur le prochain parametre */
1054 /* respectivement dans les bases initiale et actuelle. */
1055 /* expression_act: l'expression obtenue. */
1056 /* premiere_ver: mis a set. */
1057 /* */
1058 /* Result: void. */
1059 /* */
1060 /* Aims: ajouter un parametre et son coefficient a une "expression" */
1061 /* correspondant a un vecteur. Les pointeurs de base sont actualises . */
1062 /* */
1063 /* Author: F Dumontet. */
1064 /* */
1065 /* Date of last change: */
1066 /* */
1067 /*----------------------------------------------------------------------------*/
1068 
1069 void
1070 ecrit_coeff2 ( ent )
1071 
1072  int ent;
1073 {
1074 extern int ind_min_max;
1075  int garde_min_max = MY_MIN;
1076 
1077  if (ind_min_max == MY_MAX)
1078  garde_min_max = MY_MAX;
1079  ind_min_max = MY_MIN;
1080  if (new_base_aux == NULL)
1081  ajoute_constante ( ent );
1082  else
1083  ecrit_une_var( ent );
1084  if (garde_min_max == MY_MAX)
1085  ind_min_max = MY_MAX;
1086 }
1087 
1088 
make_var_val
var_val make_var_val(entity a1, expression a2)
Definition: paf_ri.c:697
write_quast
void write_quast(FILE *f, quast p)
Definition: paf_ri.c:510
make_quast_value
quast_value make_quast_value(enum quast_value_utype tag, void *val)
Definition: paf_ri.c:565
make_quast
quast make_quast(quast_value a1, list a2)
Definition: paf_ri.c:516
make_conditional
conditional make_conditional(predicate a1, quast a2, quast a3)
Definition: paf_ri.c:138
make_quast_leaf
quast_leaf make_quast_leaf(list a1, leaf_label a2)
Definition: paf_ri.c:474
make_basic
basic make_basic(enum basic_utype tag, void *val)
Definition: ri.c:155
make_predicate
predicate make_predicate(Psysteme a1)
Definition: ri.c:1820
Value
int Value
Definition: arithmetique-local.h:296
num
static int num
Definition: bourdoncle.c:137
type
struct _newgen_struct_type_ * type
Definition: c_parser_private.h:21
contrainte_new
Pcontrainte contrainte_new(void)
package contrainte - allocations et desallocations
Definition: alloc.c:47
make_entity_fullname
string make_entity_fullname(const char *module_name, const char *local_name)
END_EOLE.
Definition: entity_names.c:230
module_name
const char * module_name(const char *s)
Return the module part of an entity name.
Definition: entity_names.c:296
malloc
void * malloc(YYSIZE_T)
free
void free(void *)
NIL
#define NIL
The empty list (nil in Lisp)
Definition: newgen_list.h:47
CONS
#define CONS(_t_, _i_, _l_)
List element cell constructor (insert an element at the beginning of a list)
Definition: newgen_list.h:150
gen_nconc
list gen_nconc(list cp1, list cp2)
physically concatenates CP1 and CP2 but do not duplicates the elements
Definition: list.c:344
CDR
#define CDR(pcons)
Get the list less its first element.
Definition: newgen_list.h:111
gen_append
list gen_append(list l1, const list l2)
Definition: list.c:471
full_name
#define full_name(dir, name)
Definition: compile.c:414
debug
void debug(const int the_expected_debug_level, const char *calling_function_name, const char *a_message_format,...)
ARARGS0.
Definition: debug.c:189
TOP_LEVEL_MODULE_NAME
#define TOP_LEVEL_MODULE_NAME
Module containing the global variables in Fortran and C.
Definition: naming-local.h:101
MODULE_SEP_STRING
#define MODULE_SEP_STRING
Definition: naming-local.h:30
concatenate
string concatenate(const char *,...)
Return the concatenation of the given strings.
Definition: string.c:183
gen_find_tabulated
void * gen_find_tabulated(const char *, int)
Definition: tabulated.c:218
paf_ri.h
quast_value_undefined
#define quast_value_undefined
Definition: paf_ri.h:639
is_quast_value_quast_leaf
@ is_quast_value_quast_leaf
Definition: paf_ri.h:654
is_quast_value_conditional
@ is_quast_value_conditional
Definition: paf_ri.h:655
VAR_VAL
#define VAR_VAL(x)
VAR_VAL.
Definition: paf_ri.h:763
leaf_label_undefined
#define leaf_label_undefined
Definition: paf_ri.h:427
old_base
Pbase old_base
Base of the parameters.
Definition: pip.c:102
base_ref
Pbase base_ref
Base of the unknowns.
Definition: pip.c:102
ind_min_max
int ind_min_max
Definition: pip.c:103
quast_act
quast quast_act
Global variables
Definition: pip.c:101
base_var_ref
Pbase base_var_ref
Tag for MIN or MAX resolution.
Definition: pip.c:102
MINUS_OPERATOR_NAME
#define MINUS_OPERATOR_NAME
Definition: ri-util-local.h:113
PLUS_OPERATOR_NAME
#define PLUS_OPERATOR_NAME
Definition: ri-util-local.h:111
make_entity
#define make_entity(n, t, s, i)
Definition: ri-util-local.h:2335
DIVIDE_OPERATOR_NAME
#define DIVIDE_OPERATOR_NAME
Definition: ri-util-local.h:118
UNARY_MINUS_OPERATOR_NAME
#define UNARY_MINUS_OPERATOR_NAME
Definition: ri-util-local.h:115
MULTIPLY_OPERATOR_NAME
#define MULTIPLY_OPERATOR_NAME
Definition: ri-util-local.h:117
entity_local_name
const char * entity_local_name(entity e)
entity_local_name modified so that it does not core when used in vect_fprint, since someone thought t...
Definition: entity.c:453
make_factor_expression
expression make_factor_expression(int coeff, entity vari)
Some functions to generate expressions from vectors and constraint systems.
Definition: expression.c:1631
int_to_expression
expression int_to_expression(_int i)
transform an int into an expression and generate the corresponding entity if necessary; it is not cle...
Definition: expression.c:1188
make_op_exp
expression make_op_exp(char *op_name, expression exp1, expression exp2)
================================================================
Definition: expression.c:2012
MakeUnaryCall
expression MakeUnaryCall(entity f, expression a)
Creates a call expression to a function with one argument.
Definition: expression.c:342
MakeTypeVariable
type MakeTypeVariable(basic, cons *)
BEGIN_EOLE.
Definition: type.c:116
value_undefined
#define value_undefined
Definition: ri.h:3016
is_basic_int
@ is_basic_int
Definition: ri.h:571
EXPRESSION
#define EXPRESSION(x)
EXPRESSION.
Definition: ri.h:1217
type_undefined
#define type_undefined
Definition: ri.h:2883
entity_type
#define entity_type(x)
Definition: ri.h:2792
entity_domain
#define entity_domain
newgen_syntax_domain_defined
Definition: ri.h:410
storage_undefined
#define storage_undefined
Definition: ri.h:2476
sc_creer_base
void sc_creer_base(Psysteme ps)
void sc_creer_base(Psysteme ps): initialisation des parametres dimension et base d'un systeme lineair...
Definition: sc_alloc.c:129
sc_new
Psysteme sc_new(void)
Psysteme sc_new(): alloue un systeme vide, initialise tous les champs avec des valeurs nulles,...
Definition: sc_alloc.c:55
strdup
char * strdup()
return
return(s1)
MY_MAX
#define MY_MAX
Definition: solpip.c:61
Pbaseaux
struct baseaux * Pbaseaux
conditional_act
conditional conditional_act
Definition: solpip.c:97
quast_true
static Ppilequast quast_true
Definition: solpip.c:98
aux
int aux
Definition: solpip.c:104
fait_quast
void fait_quast()
Name: fait_quast.
Definition: solpip.c:331
compteur_de_var
int compteur_de_var
Definition: solpip.c:104
new_base_ref
static Pbaseaux new_base_ref
Definition: solpip.c:100
ecrit_coeff_neg2
void ecrit_coeff_neg2(int ent)
Name: ecrit_coeff_neg2.
Definition: solpip.c:1028
ajoute_new_var
void ajoute_new_var(int ent, int rang)
Name: ajoute_new_var.
Definition: solpip.c:715
premiere_var
int premiere_var
Definition: solpip.c:104
psyst_act
Psysteme psyst_act
Definition: solpip.c:103
vect_var_aux
Pvecteur vect_var_aux
Definition: solpip.c:102
newparms_act
list newparms_act
Definition: solpip.c:91
creer_Psysteme
void creer_Psysteme()
Name: creer_Psysteme.
Definition: solpip.c:558
ecrit_une_var
void ecrit_une_var(int ent)
Name: ecrire_une_var.
Definition: solpip.c:823
predicate_act
static Ppilepredicat predicate_act
Definition: solpip.c:93
ecrit_liste_vecteur
void ecrit_liste_vecteur()
Name: ecrit_liste_vecteur.
Definition: solpip.c:783
PREMIERE_VAR_BASE
#define PREMIERE_VAR_BASE
Definition: solpip.c:56
pileaux
struct pileaux pileaux
OLD_VAR
#define OLD_VAR(x)
Definition: solpip.c:59
ecrit_coeff2
void ecrit_coeff2(int ent)
Name: ecrire_coeff2 .
Definition: solpip.c:1070
creer_nom_entite
entity creer_nom_entite(char *module_name)
Name: creer_nom_entite.
Definition: solpip.c:657
ecrit_resultat
void ecrit_resultat()
TEMPORAIRE
Definition: solpip.c:529
pilequast
struct pilequast pilequast
retire_par_de_pile
void retire_par_de_pile()
Name: retire_par_de_pile.
Definition: solpip.c:168
Ppilequast
struct pilequast * Ppilequast
creer_true_quast
void creer_true_quast()
Name: creer_true_quast.
Definition: solpip.c:264
MY_MIN
#define MY_MIN
Definition: solpip.c:60
quast_value_act
quast_value quast_value_act
Definition: solpip.c:96
baseaux
struct baseaux baseaux
vect_act
Pvecteur vect_act
Definition: solpip.c:102
init_liste_vecteur
void init_liste_vecteur()
Name: init_liste_vecteur.
Definition: solpip.c:405
ajoute_constante
void ajoute_constante(int ent)
Name: ajoute_constante
Definition: solpip.c:127
fait_quast_value
void fait_quast_value()
Name: fait_quast_value.
Definition: solpip.c:365
init_vecteur
void init_vecteur()
Name: init_vecteur.
Definition: solpip.c:438
ecrit_une_var_neg
void ecrit_une_var_neg(int ent)
Name: ecrit_une_var_neg.
Definition: solpip.c:935
expression_act
expression expression_act
Definition: solpip.c:94
creer_predicat
void creer_predicat()
Name: creer_predicat.
Definition: solpip.c:296
premiere_var1
int premiere_var1
Definition: solpip.c:104
solution_act
list solution_act
Definition: solpip.c:92
Ppilepredicat
struct pilepredicat * Ppilepredicat
pile
static Ppileaux pile
Definition: solpip.c:99
creer_quast_value
void creer_quast_value()
Name: creer_quast_value
Definition: solpip.c:232
ecrit_coeff1
void ecrit_coeff1(int ent)
Name: ecrit_coeff1.
Definition: solpip.c:474
init_quast
void init_quast()
Name: init_quast.
Definition: solpip.c:205
quast_false
quast quast_false
Definition: solpip.c:95
Ppileaux
struct pileaux * Ppileaux
new_base_aux
static Pbaseaux new_base_aux
Definition: solpip.c:101
init_new_base
void init_new_base()
Name: init_new_base.
Definition: solpip.c:601
VARSUPP
#define VARSUPP
Definition: solpip.c:62
pilepredicat
struct pilepredicat pilepredicat
SET_PREMIERE_VAR
#define SET_PREMIERE_VAR
Definition: solpip.c:58
RESET_PREMIERE_VAR
#define RESET_PREMIERE_VAR
Definition: solpip.c:57
vect_aux
Pvecteur vect_aux
Definition: solpip.c:102
Scontrainte::vecteur
Pvecteur vecteur
Definition: contrainte-local.h:89
Ssysteme::inegalites
Pcontrainte inegalites
Definition: sc-local.h:71
Ssysteme::base
Pbase base
Definition: sc-local.h:75
Ssysteme::dimension
int dimension
Definition: sc-local.h:74
Ssysteme::nb_ineq
int nb_ineq
Definition: sc-local.h:73
Svecteur
le type des coefficients dans les vecteurs: Value est defini dans le package arithmetique
Definition: vecteur-local.h:89
Svecteur::var
Variable var
Definition: vecteur-local.h:90
Svecteur::succ
struct Svecteur * succ
Definition: vecteur-local.h:92
_newgen_struct_basic_
Definition: ri.h:595
_newgen_struct_conditional_
Definition: paf_ri.h:291
_newgen_struct_entity_
Definition: ri.h:2778
_newgen_struct_expression_
Definition: ri.h:1239
_newgen_struct_predicate_
Definition: ri.h:2062
_newgen_struct_quast_
Definition: paf_ri.h:619
_newgen_struct_quast_value_
Definition: paf_ri.h:662
_newgen_struct_var_val_
Definition: paf_ri.h:785
baseaux
Definition: solpip.c:66
baseaux::var
expression var
Definition: solpip.c:67
baseaux::ent
entity ent
Definition: solpip.c:68
baseaux::succ
struct baseaux * succ
Definition: solpip.c:69
cons
The structure used to build lists in NewGen.
Definition: newgen_list.h:41
pileaux
Definition: solpip.c:73
pileaux::succ
struct pileaux * succ
Definition: solpip.c:76
pileaux::act
Pbaseaux act
Definition: solpip.c:75
pileaux::pred
Pbaseaux pred
Definition: solpip.c:74
pilepredicat::x
predicate x
Definition: solpip.c:81
pilepredicat::succ
struct pilepredicat * succ
Definition: solpip.c:82
pilequast::succ
struct pilequast * succ
Definition: solpip.c:88
pilequast::q
quast q
Definition: solpip.c:87
TCST
#define TCST
VARIABLE REPRESENTANT LE TERME CONSTANT.
Definition: vecteur-local.h:131
Pvecteur
struct Svecteur * Pvecteur
Variable
void * Variable
arithmetique is a requirement for vecteur, but I do not want to inforce it in all pips files....
Definition: vecteur-local.h:60
vect_add_elem
void vect_add_elem(Pvecteur *pvect, Variable var, Value val)
void vect_add_elem(Pvecteur * pvect, Variable var, Value val): addition d'un vecteur colineaire au ve...
Definition: unaires.c:72