tab.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include "genC.h"
#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 "matrix.h"
#include "ri.h"
#include "constants.h"
#include "ri-util.h"
#include "misc.h"
#include "bootstrap.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 "paf-util.h"
#include "pip.h"

Include dependency graph for tab.c:

Go to the source code of this file.

Macros
#define	max(x, y)   (x>y? x : y)
	lint More...
#define	TAB_CHUNK   4096*sizeof(Entier)

Functions
void	tab_init ()
char *	tab_hwm ()
void	tab_reset (char *p)
Tableau *	tab_alloc (int h, int w, int n)
	h : le nombre de ligne reelles; n : le nombre de lignes virtuelles More...
Tableau *	tab_get (FILE *foo, int h, int w, int n)
void	tab_display (Tableau *p, FILE *foo)

Variables
char	vcid_pip_tab [] = "$Id: tab.c 23065 2016-03-02 09:05:50Z coelho $"
static char *	tab_free
static char *	tab_top
static struct A *	tab_base
int	allocation
	External variables for direct call to PIP. More...
long int	cross_product
long int	limit
char *	Attr [] = {"Unit", "+", "-", "0", "*", "?"}

Macro Definition Documentation

max

#define max	(		x,
			y
	)		(x>y? x : y)

lint

Newgen includes
C3 includes
Pips includes

Definition at line 69 of file tab.c.

TAB_CHUNK

#define TAB_CHUNK   4096*sizeof(Entier)

Definition at line 70 of file tab.c.

Function Documentation

tab_alloc()

Tableau* tab_alloc	(	int	h,
		int	w,
		int	n
	)

h : le nombre de ligne reelles; n : le nombre de lignes virtuelles

Definition at line 113 of file tab.c.

{
 char *p; Tableau *tp;
 Entier *q;
 long taille;
 int i;
 taille = 2 * sizeof(int) + (h+n) * sizeof (struct L)
          + h * w * sizeof (Entier);
 if(tab_free + taille >= tab_top)
     {struct A * g;
      long int d;
      d = max(TAB_CHUNK, taille + sizeof(struct A));
      tab_free = (char*) malloc(d);
      if(!tab_free)
          {printf("tab_alloc : plus de place\n");
           exit(23);
          }
      allocation++;
      g = (struct A *)tab_free;
      g->precedent = tab_base;
      tab_top = tab_free + d;
      tab_free += sizeof(struct A);
      tab_base = g;
      g->bout = tab_top;
     }
 p = tab_free;
 tab_free += taille;
 tp = (Tableau *)p;
 q = (Entier *)(p +  2 * sizeof(int) + (h+n) * sizeof (struct L));
 for(i = 0; i<n ; i++)
     {tp->row[i].flags = Unit | Zero;
      tp->row[i].objet.unit = i;
     }
 for(i = n; i < (h+n); i++)
     {tp->row[i].flags = 0;
      tp->row[i].objet.val = q;
      q += w;
     }
 tp->height = h + n; tp->width = w;
 return(tp);
}

References allocation, A::bout, Entier, exit, L::flags, T::height, int, malloc(), max, L::objet, A::precedent, printf(), T::row, tab_base, TAB_CHUNK, tab_free, tab_top, L::unit, Unit, L::val, T::width, and Zero.

Referenced by tab_get().

Here is the call graph for this function:

Here is the caller graph for this function:

tab_display()

void tab_display	(	Tableau *	p,
		FILE *	foo
	)

Definition at line 181 of file tab.c.

{
 
 int i, j, ff, fff, n;
 Entier x;
 fprintf(foo, "%ld/[%d * %d]\n", cross_product, p->height, p->width);
 for(i = 0; i<p->height; i++)
     {fff = ff = p->row[i].flags;
      if(ff == 0) break;
      n = 0;
      while(fff)
          {if(fff & 1) fprintf(foo, "%s ",Attr[n]);
           n++; fff >>= 1;
          }
      fprintf(foo, "#[");
      if(ff & Unit)
          for(j = 0; j<p->width; j++)
              fprintf(foo, " /%d/",(j == p->row[i].objet.unit)? 1: 0);
      else
          for(j = 0; j<p->width; j++)
              {x = Index(p,i,j);
               fprintf(foo, FORMAT, x);
               fprintf(foo, " ");
              }
      fprintf(foo, " ]\n");
     }
}

References Attr, cross_product, Entier, L::flags, FORMAT, fprintf(), T::height, Index, L::objet, T::row, L::unit, Unit, T::width, and x.

Here is the call graph for this function:

tab_get()

Tableau* tab_get	(	FILE *	foo,
		int	h,
		int	w,
		int	n
	)

Definition at line 159 of file tab.c.

{
 Tableau *p;
 int i, j, c;
 p = tab_alloc(h, w, n);
 while((c = dgetc(foo)) != EOF)if(c == '(')break;
 for(i = n; i<h+n; i++)
     {p->row[i].flags = Unknown;
      while((c = dgetc(foo)) != EOF)if(c == '[')break;
      for(j = 0; j<w; j++)
        if(dscanf(foo, FORMAT, p->row[i].objet.val+j) < 0)
                return NULL;
      while((c = dgetc(foo)) != EOF)if(c == ']')break;
     }
 while((c = dgetc(foo)) != EOF)if(c == ')')break;
 return((Tableau *) p);
}

References dgetc(), dscanf(), L::flags, FORMAT, L::objet, T::row, tab_alloc(), Unknown, and L::val.

Here is the call graph for this function:

tab_hwm()

char* tab_hwm

(

)

Definition at line 92 of file tab.c.

{
 return(tab_free);
}

References tab_free.

Referenced by compa_test(), pip_solve(), pip_solve_min_with_big(), and traiter().

Here is the caller graph for this function:

tab_init()

void tab_init

(

)

Definition at line 77 of file tab.c.

{
 tab_free = (char*) malloc(sizeof (struct A));
 if(!tab_free)
     {printf("tab_init : la machine est trop petite\n");
      exit(21);
     }
 allocation = 1;
 tab_top = tab_free + sizeof (struct A);
 tab_base = (struct A *)tab_free;
 tab_free += sizeof(struct A);
 tab_base->precedent = NULL;
 tab_base->bout = tab_top;
}

References allocation, A::bout, exit, malloc(), A::precedent, printf(), tab_base, tab_free, and tab_top.

Referenced by pip_solve(), and pip_solve_min_with_big().

Here is the call graph for this function:

Here is the caller graph for this function:

tab_reset()

void tab_reset

(

char *

p

)

Definition at line 97 of file tab.c.

{struct A *g;
 while(tab_base)
     {
      if((char *)tab_base + sizeof(struct A) <= p && p <= tab_top) break;
      g = tab_base->precedent;
      free(tab_base);
      allocation--;
      tab_base = g;
      tab_top = tab_base->bout;
     }
 if(tab_base) tab_free = p;
 else printf("tab_reset : panique\n");
}

References allocation, A::bout, free(), A::precedent, printf(), tab_base, tab_free, and tab_top.

Here is the call graph for this function:

Variable Documentation

allocation

int allocation

extern

External variables for direct call to PIP.

Definition at line 92 of file pip.c.

Referenced by tab_alloc(), tab_init(), and tab_reset().

Attr

char* Attr[] = {"Unit", "+", "-", "0", "*", "?"}

Definition at line 179 of file tab.c.

Referenced by tab_display().

cross_product

long int cross_product

extern

Definition at line 91 of file pip.c.

Referenced by pip_solve(), pip_solve_min_with_big(), and tab_display().

limit

long int limit

Definition at line 75 of file tab.c.

tab_base

struct A* tab_base

static

Definition at line 73 of file tab.c.

Referenced by tab_alloc(), tab_init(), and tab_reset().

tab_free

char* tab_free

static

Definition at line 72 of file tab.c.

Referenced by tab_alloc(), tab_hwm(), tab_init(), and tab_reset().

tab_top

char * tab_top

static

Definition at line 72 of file tab.c.

Referenced by tab_alloc(), tab_init(), and tab_reset().

vcid_pip_tab

char vcid_pip_tab[] = "$Id: tab.c 23065 2016-03-02 09:05:50Z coelho $"

Definition at line 29 of file tab.c.