externals.c File Reference

#include "private.h"
#include "paf_ri.h"
#include "ri-util.h"

Include dependency graph for externals.c:

Go to the source code of this file.

Macros
#define	STATEMENT_FUNCTION_MAP(k, v, code, _map_hash_h)
	this piece of code makes low level assumptions about newgen internals. More...

Functions
static int	lire_int (FILE *fd)
	reads an int while sharing file and buffers with newgen... More...
char *	pipsdbm_read_entities (FILE *fd)
	externals.c More...
void	pipsdbm_free_entities (char *p)
static int	statement_mapping_count (statement_mapping h)
	The old statement_mapping is an hash_table managed directly. More...
void	pipsdbm_write_statement_mapping (FILE *fd, statement_mapping h)
	Write a statement mapping. More...
hash_table	pipsdbm_read_statement_mapping (FILE *fd)
	Read a statement mapping. More...
bool	pipsdbm_check_statement_mapping (statement_mapping h)
	a little bit partial, because domain are not checked. More...
void	pipsdbm_free_statement_mapping (statement_mapping h)
static int	number_of_ordered_statements (hash_table h)
	count the number of statements with a valid ordering. More...
bool	pipsdbm_consistent_statement_function (gen_chunkp map)
void	pipsdbm_write_statement_function (FILE *fd, gen_chunkp map)
	the stored stuff need be based on the ordering... More...
gen_chunkp	pipsdbm_read_statement_function (FILE *fd)
	Should use a higher level pipsdbm_read_statement_mapping() to survive to XML. More...
void	free_static_control_mapping (statement_mapping map)
	Modification Dec 11 1995: ne pas utiliser free_static_control car il libere des champs qui appartiennent a d'autres structures que celles controlees par static_controlize...(champs d'origine) Les liberation de ces champs par un autre transformer (use_def_elim) entrainait alors un core dump au niveau de cette procedure. More...
void	declarations_write (FILE *f, hash_table h)
	Functions to read and write declarations resource, which is a hash table whose key and value are string (keyword/typedef and TK_keyword/TK_typedef) More...
hash_table	declarations_read (FILE *f)

Macro Definition Documentation

STATEMENT_FUNCTION_MAP

#define STATEMENT_FUNCTION_MAP	(		k,
			v,
			code,
			_map_hash_h
	)

Value:

    { void * _map_hash_p = NULL;                                        \
      void * _map_k; void * _map_v;                                     \
      while ((_map_hash_p =                                             \
           hash_table_scan(_map_hash_h,_map_hash_p,&_map_k,&_map_v))) { \
        statement k = (statement) ((gen_chunkp)_map_k)->p ;             \
        gen_chunkp v = ((gen_chunkp)_map_v)->p;                         \
        code ; }}

this piece of code makes low level assumptions about newgen internals.

see also the comments about statement mappings above.

Definition at line 202 of file externals.c.

Function Documentation

declarations_read()

hash_table declarations_read

(

FILE *

f

)

Definition at line 345 of file externals.c.

{
  hash_table result = hash_table_make(hash_string,0);
  int c;
  while ((c = getc(f)) && c != EOF)
    {
      ungetc(c,f);
      char* key = safe_readline(f);
      _int value = atoi(safe_readline(f));
 
      hash_put(result,key,(void*)value);
    }
  return result;
}

References f(), hash_put(), hash_string, hash_table_make(), and safe_readline().

Here is the call graph for this function:

declarations_write()

void declarations_write	(	FILE *	f,
		hash_table	h
	)

Functions to read and write declarations resource, which is a hash table whose key and value are string (keyword/typedef and TK_keyword/TK_typedef)

Definition at line 335 of file externals.c.

{
  HASH_MAP(k,v,
  {
    fprintf(f, "%s\n", (char *) k);
    fprintf(f, "%td\n", (_int) v);
  },h);
}

References f(), fprintf(), and HASH_MAP.

Here is the call graph for this function:

free_static_control_mapping()

void free_static_control_mapping

(

statement_mapping

map

)

Modification Dec 11 1995: ne pas utiliser free_static_control car il libere des champs qui appartiennent a d'autres structures que celles controlees par static_controlize...(champs d'origine) Les liberation de ces champs par un autre transformer (use_def_elim) entrainait alors un core dump au niveau de cette procedure.

On fait a la place des gen_free_list en detail –DB ]

Parameters

map

ap

Definition at line 318 of file externals.c.

{
    STATEMENT_MAPPING_MAP(s, val, {
        gen_free_list(static_control_loops((static_control) val));
        gen_free_list(static_control_tests((static_control) val));
        static_control_loops((static_control) val)=NULL;
        static_control_tests((static_control) val)=NULL;
        static_control_params((static_control) val)=NULL;
        gen_free( (void*) val );
    }, map);
 
    FREE_STATEMENT_MAPPING(map);
}

References FREE_STATEMENT_MAPPING, gen_free(), gen_free_list(), STATEMENT_MAPPING_MAP, static_control_loops, static_control_params, and static_control_tests.

Here is the call graph for this function:

lire_int()

static int lire_int ( FILE *  fd )

static

reads an int while sharing file and buffers with newgen...

trim

Definition at line 40 of file externals.c.

{
    int c, i = 0, sign = 1;
    genread_in = fd;
 
    while (isspace(c = genread_input())) ; /* trim */
 
    if (c == '-') sign = -1;
    else if (isdigit(c))
        i = c-'0';
    else if(c==EOF)
        pips_internal_error("Unexpected EOF, corrupted resource file");
    else
        pips_internal_error("digit or '-' expected : %c %x", c, c);
 
    while (isdigit(c = genread_input())) 
        i = 10*i + (c-'0');
 
    return sign*i;
}

References genread_in, genread_input(), and pips_internal_error.

Referenced by pipsdbm_read_statement_function(), and pipsdbm_read_statement_mapping().

Here is the call graph for this function:

Here is the caller graph for this function:

number_of_ordered_statements()

static int number_of_ordered_statements ( hash_table  h )

static

count the number of statements with a valid ordering.

Definition at line 213 of file externals.c.

{
    int n = 0;
    STATEMENT_FUNCTION_MAP(s, x, 
    {
      pips_assert("variable not used", x==x);
      if (statement_ordering(s)!=STATEMENT_ORDERING_UNDEFINED) n++;
    }, 
                           h);
    return n;
}

References pips_assert, STATEMENT_FUNCTION_MAP, statement_ordering, STATEMENT_ORDERING_UNDEFINED, and x.

Referenced by pipsdbm_write_statement_function().

Here is the caller graph for this function:

pipsdbm_check_statement_mapping()

bool pipsdbm_check_statement_mapping

(

statement_mapping

h

)

a little bit partial, because domain are not checked.

Definition at line 178 of file externals.c.

{
    STATEMENT_MAPPING_MAP(k, v, {
        pips_assert("consistent statement", 
                    statement_consistent_p((statement) k));
        pips_assert("consistent val", gen_consistent_p((void*) v));
    },
        h);
    return true;
}

References gen_consistent_p(), pips_assert, statement_consistent_p(), and STATEMENT_MAPPING_MAP.

Here is the call graph for this function:

pipsdbm_consistent_statement_function()

bool pipsdbm_consistent_statement_function

(

gen_chunkp

map

)

Parameters

map

ap

Definition at line 226 of file externals.c.

{
    hash_table h = (map+1)->h;
    STATEMENT_FUNCTION_MAP(s, x, 
    {
        if (gen_type((void*)s)!=statement_domain) return false;
        if (!gen_consistent_p((void*)x)) return false;
    },
        h);
    return true;
}

References gen_consistent_p(), gen_type(), statement_domain, STATEMENT_FUNCTION_MAP, and x.

Here is the call graph for this function:

pipsdbm_free_entities()

void pipsdbm_free_entities

(

char *

p

)

Definition at line 72 of file externals.c.

{
  pips_assert("argument not used", p==p);
  gen_free_tabulated(entity_domain);
}

References entity_domain, gen_free_tabulated(), and pips_assert.

Here is the call graph for this function:

pipsdbm_free_statement_mapping()

void pipsdbm_free_statement_mapping

(

statement_mapping

h

)

Definition at line 190 of file externals.c.

{
    STATEMENT_MAPPING_MAP(k, v, gen_free((void*) v), h);
    FREE_STATEMENT_MAPPING(h);
}

References FREE_STATEMENT_MAPPING, gen_free(), and STATEMENT_MAPPING_MAP.

Here is the call graph for this function:

pipsdbm_read_entities()

char* pipsdbm_read_entities

(

FILE *

fd

)

externals.c

Parameters

fd

d

Definition at line 64 of file externals.c.

{
    int read = gen_read_tabulated(fd, false);
    pips_assert("entities were read", read==entity_domain);
    return (char *) entity_domain;
}

References entity_domain, gen_read_tabulated(), and pips_assert.

Here is the call graph for this function:

pipsdbm_read_statement_function()

gen_chunkp pipsdbm_read_statement_function

(

FILE *

fd

)

Should use a higher level pipsdbm_read_statement_mapping() to survive to XML.

get meta data.

allocate the statement function.

now reads each couple and rebuild the function.

Parameters

fd	file to read from

Definition at line 271 of file externals.c.

{
    statement stat; 
    int domain, n;
    gen_chunkp result;
    hash_table h;
    
    pips_assert("some current module name", dbll_current_module);
    pips_debug(3, "statement -> ??? for %s\n", dbll_current_module);
    stat = (statement)
        db_get_memory_resource(DBR_CODE, dbll_current_module, true);
 
    set_ordering_to_statement(stat);
 
    /* get meta data.
     */
    domain = lire_int(fd);
    n = lire_int(fd);
 
    /* allocate the statement function. 
     */
    result = gen_alloc(2*sizeof(gen_chunk), GEN_CHECK_ALLOC, domain);
    h = (result+1)->h;
 
    /* now reads each couple and rebuild the function.
     */
    while(n-->0) {
        int so = lire_int(fd);
        pips_assert("valid ordering", so!=STATEMENT_ORDERING_UNDEFINED);
        HASH_EXTEND(p, p, h, ordering_to_statement(so), gen_read(fd));
    }
 
    reset_ordering_to_statement();
 
    return result;
}

References db_get_memory_resource(), dbll_current_module, gen_alloc(), GEN_CHECK_ALLOC, gen_read(), HASH_EXTEND, lire_int(), ordering_to_statement(), pips_assert, pips_debug, reset_ordering_to_statement(), set_ordering_to_statement(), and STATEMENT_ORDERING_UNDEFINED.

Here is the call graph for this function:

pipsdbm_read_statement_mapping()

hash_table pipsdbm_read_statement_mapping

(

FILE *

fd

)

Read a statement mapping.

This function is quite too low level... It mixes raw getc() from a FILE with gen_read. To survive other NewGen backend (XML), fprintf could be replaced with a gen_getc() that could peek in a CDATA for example in the case of XML.

But in this case it should be a call to something like so = gen_read_int(fd) instead to do even simpler and read an int value (in textual form or in <int>...</int> in the case of XML.

get meta data.

Parameters

fd

d

Definition at line 147 of file externals.c.

{
    statement stat;
    hash_table result = hash_table_make(hash_pointer, 0);
    int n;
 
    pips_assert("some current module name", dbll_current_module);
    pips_debug(3, "statement -> ??? for %s\n", dbll_current_module);
    stat = (statement)
        db_get_memory_resource(DBR_CODE, dbll_current_module, true);
 
    set_ordering_to_statement(stat);
 
    /* get meta data.
     */
    n = lire_int(fd);
 
    while (n-->0) {
        int so = lire_int(fd);
        pips_assert("valid ordering", so!=STATEMENT_ORDERING_UNDEFINED);
        hash_put(result,(void*)ordering_to_statement(so),(void*)gen_read(fd));
    }
 
        reset_ordering_to_statement();
 
    return result;
}

References db_get_memory_resource(), dbll_current_module, gen_read(), hash_pointer, hash_put(), hash_table_make(), lire_int(), ordering_to_statement(), pips_assert, pips_debug, reset_ordering_to_statement(), set_ordering_to_statement(), and STATEMENT_ORDERING_UNDEFINED.

Here is the call graph for this function:

pipsdbm_write_statement_function()

void pipsdbm_write_statement_function	(	FILE *	fd,
		gen_chunkp	map
	)

the stored stuff need be based on the ordering...

because newgen won't regenerate pointers...

Should use a higher level pipsdbm_write_statement_mapping() to survive to XML

save it!

Parameters

fd	file to write to
map	statement function

Definition at line 245 of file externals.c.

{
    hash_table h = (map+1)->h;
    fprintf(fd, "%td\n%d\n", map->i, number_of_ordered_statements(h));
    STATEMENT_FUNCTION_MAP(s, x, 
    {
        int order = statement_ordering(s);
        if (order!=STATEMENT_ORDERING_UNDEFINED) { /* save it! */
            fprintf(fd, "%d\n", order);
            gen_write(fd, x);
        } 
        else {
          pips_user_warning("Statement with illegal ordering, lost data: %s\n",
                            statement_identification(s));
        }
    },
        h);
}

References fprintf(), gen_write(), gen_chunk::i, number_of_ordered_statements(), pips_user_warning, STATEMENT_FUNCTION_MAP, statement_identification(), statement_ordering, STATEMENT_ORDERING_UNDEFINED, and x.

Here is the call graph for this function:

pipsdbm_write_statement_mapping()

void pipsdbm_write_statement_mapping	(	FILE *	fd,
		statement_mapping	h
	)

Write a statement mapping.

This function is quite too low level... It mixes raw printf in a FILE with gen_write. To survive other NewGen backend (XML), fprintf could be replaced with a gen_fprintf() that could encapsulate the output in a CDATA for example in the case of XML.

But in this case it should be a call to something like gen_write_int(fd, order) instead to do even simpler.

save it!

Parameters

fd	file to write to
h	hash table to dump

Definition at line 115 of file externals.c.

{
  fprintf(fd, "%d\n", statement_mapping_count(h));
  STATEMENT_MAPPING_MAP(s, v,
  {
    statement key = (statement) s;
    gen_chunkp val = (gen_chunkp) v;
    int order = statement_ordering(key);
    if (order!=STATEMENT_ORDERING_UNDEFINED) { /* save it! */
      fprintf(fd, "%d\n", order);
      gen_write(fd, (gen_chunkp) val);
    } 
    else pips_user_warning("statement with illegal ordering\n");
  },
                        h);
}

References fprintf(), gen_write(), pips_user_warning, statement_mapping_count(), STATEMENT_MAPPING_MAP, statement_ordering, and STATEMENT_ORDERING_UNDEFINED.

Here is the call graph for this function:

statement_mapping_count()

static int statement_mapping_count ( statement_mapping  h )

static

The old statement_mapping is an hash_table managed directly.

this table associates statement to any newgen type. Now explicit newgen functions ("->") should be prefered. the storing of the mapping is based on the statement ordering for later reconstruction with the CODE. tabulating statements would help, but is that desirable?

MY opinion is that all newgen objects should have a unique id associated to it, as an addditional hidden field, to support persistence more easily. Well, there would be some problemes, too.

FC.

Definition at line 94 of file externals.c.

{
    int n = 0;
    STATEMENT_MAPPING_MAP(s, k,
        if (statement_ordering((statement) s)!=STATEMENT_ORDERING_UNDEFINED) 
            n++,
        h);
    return n;
}

References STATEMENT_MAPPING_MAP, statement_ordering, and STATEMENT_ORDERING_UNDEFINED.

Referenced by pipsdbm_write_statement_mapping().

Here is the caller graph for this function: