2 #include "pips_config.h"
call make_call(entity a1, list a2)
syntax make_syntax_call(call _field_)
expression make_expression(syntax a1, normalized a2)
subscript make_subscript(expression a1, list a2)
reference make_reference(entity a1, list a2)
syntax copy_syntax(syntax p)
SYNTAX.
syntax make_syntax_subscript(subscript _field_)
syntax make_syntax_reference(reference _field_)
#define call_constant_p(C)
#define gen_context_recurse(start, ctxt, domain_number, flt, rwt)
union gen_chunk * gen_chunkp
static void replace_entity_by_expression_loop_walker(loop l, struct param *p)
static void replace_entity_by_expression_declarations_walker(statement s, struct param *p)
void replace_entity_by_expression_with_filter(void *s, entity ent, expression exp, bool(*filter)(expression))
static void replace_entities_loop_walker(loop l, hash_table ht)
static void replace_entities_expression_walker(expression parent, hash_table ht)
static void replace_entity_by_expression_expression_walker(expression e, struct param *p)
void replace_entities(void *s, hash_table ht)
Recursively substitute a set of entities in a statement.
static void replace_entity_by_expression_entity_walker(entity e, struct param *p)
void replace_reference(void *s, reference old, entity new)
Replace an old reference by a reference to a new entity in a statement.
static void replace_entities_declaration_walker(statement s, hash_table ht)
void replace_entity(void *s, entity old, entity new)
per variable version of replace_entities.
void replace_entity_by_expression(void *s, entity ent, expression exp)
replace all reference to entity ent by expression exp in s.
static void replace_entities_call_walker(call c, hash_table ht)
void replace_entities_by_expression(void *s, hash_table ht)
void gen_context_multi_recurse(void *o, void *context,...)
Multi-recursion with context function visitor.
gen_chunk * gen_get_ancestor(int, const void *)
return the first ancestor object found of the given type.
bool gen_true2(__attribute__((unused)) gen_chunk *u1, __attribute__((unused)) void *u2)
bool gen_true(__attribute__((unused)) gen_chunk *unused)
Return true and ignore the argument.
#define ENDP(l)
Test if a list is empty.
#define POP(l)
Modify a list pointer to point on the next element of the list.
#define NIL
The empty list (nil in Lisp)
list gen_nconc(list cp1, list cp2)
physically concatenates CP1 and CP2 but do not duplicates the elements
#define CAR(pcons)
Get the value of the first element of a list.
#define FOREACH(_fe_CASTER, _fe_item, _fe_list)
Apply/map an instruction block on all the elements of a list.
list gen_full_copy_list(list l)
Copy a list structure with element copy.
hash_table hash_table_make(hash_key_type key_type, size_t size)
void * hash_get(const hash_table htp, const void *key)
this function retrieves in the hash table pointed to by htp the couple whose key is equal to key.
void hash_put(hash_table htp, const void *key, const void *val)
This functions stores a couple (key,val) in the hash table pointed to by htp.
void hash_table_free(hash_table htp)
this function deletes a hash table that is no longer useful.
#define pips_internal_error
#define HASH_MAP(k, v, code, ht)
#define HASH_UNDEFINED_VALUE
value returned by hash_get() when the key is not found; could also be called HASH_KEY_NOT_FOUND,...
bool set_belong_p(const set, const void *)
set set_make(set_type)
Create an empty set of any type but hash_private.
set set_add_element(set, const set, const void *)
void unnormalize_expression(void *st)
void unnormalize_expression(expression exp): puts all the normalized field of expressions in "st" to ...
#define INSTANCE_OF(type, value)
polymorhism thanks to newgen !
#define entity_constant_p(e)
bool same_entity_p(entity e1, entity e2)
predicates on entities
bool expression_call_p(expression e)
call expression_call(expression e)
void update_expression_syntax(expression e, syntax s)
frees expression syntax of e and replace it by the new syntax s
bool expression_reference_p(expression e)
Test if an expression is a reference.
reference expression_reference(expression e)
Short cut, meaningful only if expression_reference_p(e) holds.
#define value_undefined_p(x)
#define normalized_undefined
#define expression_domain
newgen_execution_domain_defined
#define reference_variable(x)
#define loop_domain
newgen_language_domain_defined
#define statement_domain
newgen_sizeofexpression_domain_defined
#define call_domain
newgen_callees_domain_defined
#define reference_indices(x)
#define statement_declarations(x)
#define value_expression_p(x)
#define expression_syntax(x)
#define value_expression(x)
#define entity_initial(x)
FI: I do not understand why the type is duplicated at the set level.
The structure used to build lists in NewGen.
A gen_chunk is used to store every object.
#define exp
Avoid some warnings from "gcc -Wshadow".