213 message_assert(
"defined references to domain cell_interpretation",
834 message_assert(
"defined references to domain persistant_expression_to_effects",
933 message_assert(
"defined references to domain statement_cell_relations",
string approximation_tag_as_string(enum approximation_utype tag)
action_kind make_action_kind(enum action_kind_utype tag, void *val)
action make_action_read(action_kind _field_)
bool statement_cell_relations_consistent_p(statement_cell_relations p)
list gen_statement_effects_cons(statement_effects p, list l)
recursive_selector copy_recursive_selector(recursive_selector p)
RECURSIVE_SELECTOR.
void statement_cell_relations_assign_contents(statement_cell_relations r, statement_cell_relations v)
bool cell_defined_p(cell p)
approximation make_approximation_must(void)
void persistant_expression_to_effects_non_recursive_free(persistant_expression_to_effects p)
path_selector check_path_selector(path_selector p)
bool bound_statement_cell_relations_p(statement_cell_relations f, statement k)
path_selector make_path_selector_expression(expression _field_)
effects apply_persistant_expression_to_effects(persistant_expression_to_effects f, expression k)
action_kind make_action_kind_environment(void)
void effects_non_recursive_free(effects p)
void effects_classes_assign_contents(effects_classes r, effects_classes v)
bool statement_effects_consistent_p(statement_effects p)
void cell_relation_non_recursive_free(cell_relation p)
effects read_effects(FILE *f)
void write_cell_relations(FILE *f, cell_relations p)
list gen_action_cons(action p, list l)
path_selectors copy_path_selectors(path_selectors p)
PATH_SELECTORS.
bool effects_defined_p(effects p)
cell make_cell_reference(reference _field_)
list gen_recursive_selector_cons(recursive_selector p, list l)
action_kind read_action_kind(FILE *f)
action copy_action(action p)
ACTION.
void write_interpreted_cell(FILE *f, interpreted_cell p)
void cell_interpretation_non_recursive_free(cell_interpretation p)
void update_entity_effects(entity_effects f, entity k, effects v)
void cell_relations_non_recursive_free(cell_relations p)
void write_statement_cell_relations(FILE *f, statement_cell_relations p)
descriptor make_descriptor(enum descriptor_utype tag, void *val)
cell_relation check_cell_relation(cell_relation p)
void write_statement_effects(FILE *f, statement_effects p)
statement_cell_relations check_statement_cell_relations(statement_cell_relations p)
void write_recursive_selector(FILE *f, recursive_selector p)
action_kind make_action_kind_store(void)
cell_relations read_cell_relations(FILE *f)
entity_effects check_entity_effects(entity_effects p)
void extend_entity_effects(entity_effects f, entity k, effects v)
bool interpreted_cell_consistent_p(interpreted_cell p)
void effect_non_recursive_free(effect p)
effects check_effects(effects p)
void extend_statement_cell_relations(statement_cell_relations f, statement k, cell_relations v)
bool approximation_defined_p(approximation p)
void write_descriptor(FILE *f, descriptor p)
cell_relation make_cell_relation(interpreted_cell a1, interpreted_cell a2, approximation a3, descriptor a4)
void free_effect(effect p)
bool path_selector_consistent_p(path_selector p)
void entity_effects_assign_contents(entity_effects r, entity_effects v)
list gen_action_kind_cons(action_kind p, list l)
cell_relations apply_statement_cell_relations(statement_cell_relations f, statement k)
bool entity_effects_consistent_p(entity_effects p)
void free_effects_classes(effects_classes p)
interpreted_cell copy_interpreted_cell(interpreted_cell p)
INTERPRETED_CELL.
bool action_consistent_p(action p)
cell make_cell_gap(gap _field_)
effects delete_statement_effects(statement_effects f, statement k)
interpreted_cell make_interpreted_cell(cell a1, cell_interpretation a2)
bool recursive_selector_consistent_p(recursive_selector p)
cell_interpretation read_cell_interpretation(FILE *f)
bool statement_cell_relations_defined_p(statement_cell_relations p)
void free_cell_relation(cell_relation p)
void descriptor_assign_contents(descriptor r, descriptor v)
interpreted_cell check_interpreted_cell(interpreted_cell p)
statement_effects copy_statement_effects(statement_effects p)
STATEMENT_EFFECTS.
effects_classes make_effects_classes(list a)
statement_cell_relations read_statement_cell_relations(FILE *f)
void action_non_recursive_free(action p)
bool bound_statement_effects_p(statement_effects f, statement k)
string action_tag_as_string(enum action_utype tag)
void approximation_non_recursive_free(approximation p)
void free_persistant_expression_to_effects(persistant_expression_to_effects p)
void persistant_expression_to_effects_assign_contents(persistant_expression_to_effects r, persistant_expression_to_effects v)
descriptor make_descriptor_convex(Psysteme _field_)
void interpreted_cell_assign_contents(interpreted_cell r, interpreted_cell v)
effects delete_entity_effects(entity_effects f, entity k)
bool effects_consistent_p(effects p)
path_selector copy_path_selector(path_selector p)
PATH_SELECTOR.
void action_kind_non_recursive_free(action_kind p)
path_selector make_path_selector_recursive_selector(recursive_selector _field_)
void effect_assign_contents(effect r, effect v)
list gen_persistant_expression_to_effects_cons(persistant_expression_to_effects p, list l)
action_kind make_action_kind_type_declaration(void)
recursive_selector read_recursive_selector(FILE *f)
action_kind copy_action_kind(action_kind p)
ACTION_KIND.
void statement_effects_assign_contents(statement_effects r, statement_effects v)
cell_relations delete_statement_cell_relations(statement_cell_relations f, statement k)
void free_statement_effects(statement_effects p)
bool bound_entity_effects_p(entity_effects f, entity k)
cell_interpretation make_cell_interpretation_value_of(void)
list gen_gap_cons(gap p, list l)
void write_effects(FILE *f, effects p)
bool descriptor_defined_p(descriptor p)
interpreted_cell read_interpreted_cell(FILE *f)
bool action_kind_defined_p(action_kind p)
path_selectors read_path_selectors(FILE *f)
string action_kind_tag_as_string(enum action_kind_utype tag)
entity_effects copy_entity_effects(entity_effects p)
ENTITY_EFFECTS.
list gen_entity_effects_cons(entity_effects p, list l)
persistant_expression_to_effects make_persistant_expression_to_effects(void)
void write_cell_interpretation(FILE *f, cell_interpretation p)
void statement_effects_non_recursive_free(statement_effects p)
bool cell_interpretation_defined_p(cell_interpretation p)
bool cell_relations_consistent_p(cell_relations p)
cell_interpretation make_cell_interpretation(enum cell_interpretation_utype tag, void *val)
recursive_selector make_recursive_selector(list a1, expression a2)
void approximation_assign_contents(approximation r, approximation v)
persistant_expression_to_effects copy_persistant_expression_to_effects(persistant_expression_to_effects p)
PERSISTANT_EXPRESSION_TO_EFFECTS.
bool bound_persistant_expression_to_effects_p(persistant_expression_to_effects f, expression k)
bool statement_effects_defined_p(statement_effects p)
void cell_non_recursive_free(cell p)
void free_entity_effects(entity_effects p)
descriptor make_descriptor_convexunion(list _field_)
void cell_interpretation_assign_contents(cell_interpretation r, cell_interpretation v)
statement_effects check_statement_effects(statement_effects p)
cell_relations copy_cell_relations(cell_relations p)
CELL_RELATIONS.
effects make_effects(list a)
void free_path_selectors(path_selectors p)
cell make_cell(enum cell_utype tag, void *val)
bool effect_consistent_p(effect p)
list gen_path_selectors_cons(path_selectors p, list l)
void write_path_selectors(FILE *f, path_selectors p)
effects apply_statement_effects(statement_effects f, statement k)
void write_cell(FILE *f, cell p)
action make_action(enum action_utype tag, void *val)
path_selectors make_path_selectors(list a)
path_selector make_path_selector(enum path_selector_utype tag, void *val)
effect check_effect(effect p)
list gen_effect_cons(effect p, list l)
void cell_relations_assign_contents(cell_relations r, cell_relations v)
cell_interpretation make_cell_interpretation_address_of(void)
effects apply_entity_effects(entity_effects f, entity k)
string cell_tag_as_string(enum cell_utype tag)
void extend_statement_effects(statement_effects f, statement k, effects v)
bool gap_defined_p(gap p)
void statement_cell_relations_non_recursive_free(statement_cell_relations p)
bool persistant_expression_to_effects_consistent_p(persistant_expression_to_effects p)
void write_gap(FILE *f, gap p)
bool action_defined_p(action p)
bool cell_relation_consistent_p(cell_relation p)
bool path_selectors_consistent_p(path_selectors p)
void write_effect(FILE *f, effect p)
action read_action(FILE *f)
bool path_selector_defined_p(path_selector p)
effects_classes read_effects_classes(FILE *f)
cell_relations make_cell_relations(list a)
action_kind check_action_kind(action_kind p)
void write_path_selector(FILE *f, path_selector p)
void free_action_kind(action_kind p)
void update_persistant_expression_to_effects(persistant_expression_to_effects f, expression k, effects v)
void free_path_selector(path_selector p)
entity_effects read_entity_effects(FILE *f)
void cell_assign_contents(cell r, cell v)
approximation make_approximation_exact(void)
void path_selector_non_recursive_free(path_selector p)
void gap_non_recursive_free(gap p)
approximation make_approximation(enum approximation_utype tag, void *val)
action make_action_write(action_kind _field_)
bool effects_classes_defined_p(effects_classes p)
statement_effects read_statement_effects(FILE *f)
effects copy_effects(effects p)
EFFECTS.
recursive_selector check_recursive_selector(recursive_selector p)
list gen_effects_cons(effects p, list l)
cell_relations check_cell_relations(cell_relations p)
void write_action(FILE *f, action p)
list gen_cell_relation_cons(cell_relation p, list l)
effect read_effect(FILE *f)
void free_action(action p)
bool gap_consistent_p(gap p)
bool effect_defined_p(effect p)
approximation copy_approximation(approximation p)
APPROXIMATION.
bool entity_effects_defined_p(entity_effects p)
void entity_effects_non_recursive_free(entity_effects p)
bool recursive_selector_defined_p(recursive_selector p)
void free_recursive_selector(recursive_selector p)
void free_statement_cell_relations(statement_cell_relations p)
approximation make_approximation_may(void)
void recursive_selector_assign_contents(recursive_selector r, recursive_selector v)
list gen_cell_interpretation_cons(cell_interpretation p, list l)
list gen_approximation_cons(approximation p, list l)
void action_kind_assign_contents(action_kind r, action_kind v)
approximation check_approximation(approximation p)
effect make_effect(cell a1, action a2, approximation a3, descriptor a4)
void free_effects(effects p)
void write_cell_relation(FILE *f, cell_relation p)
path_selector read_path_selector(FILE *f)
void write_entity_effects(FILE *f, entity_effects p)
void write_effects_classes(FILE *f, effects_classes p)
bool cell_consistent_p(cell p)
string path_selector_tag_as_string(enum path_selector_utype tag)
descriptor check_descriptor(descriptor p)
void free_interpreted_cell(interpreted_cell p)
persistant_expression_to_effects read_persistant_expression_to_effects(FILE *f)
void update_statement_effects(statement_effects f, statement k, effects v)
bool persistant_expression_to_effects_defined_p(persistant_expression_to_effects p)
cell_relation copy_cell_relation(cell_relation p)
CELL_RELATION.
descriptor copy_descriptor(descriptor p)
DESCRIPTOR.
cell_relation read_cell_relation(FILE *f)
void action_assign_contents(action r, action v)
approximation read_approximation(FILE *f)
effect copy_effect(effect p)
EFFECT.
bool approximation_consistent_p(approximation p)
string cell_interpretation_tag_as_string(enum cell_interpretation_utype tag)
descriptor make_descriptor_none(void)
void free_cell_interpretation(cell_interpretation p)
effects_classes check_effects_classes(effects_classes p)
persistant_expression_to_effects check_persistant_expression_to_effects(persistant_expression_to_effects p)
path_selectors check_path_selectors(path_selectors p)
list gen_descriptor_cons(descriptor p, list l)
cell_interpretation check_cell_interpretation(cell_interpretation p)
void write_approximation(FILE *f, approximation p)
action check_action(action p)
entity_effects make_entity_effects(void)
cell_interpretation copy_cell_interpretation(cell_interpretation p)
CELL_INTERPRETATION.
bool descriptor_consistent_p(descriptor p)
cell make_cell_preference(preference _field_)
effects delete_persistant_expression_to_effects(persistant_expression_to_effects f, expression k)
void path_selector_assign_contents(path_selector r, path_selector v)
void effects_classes_non_recursive_free(effects_classes p)
void interpreted_cell_non_recursive_free(interpreted_cell p)
list gen_path_selector_cons(path_selector p, list l)
descriptor read_descriptor(FILE *f)
void cell_relation_assign_contents(cell_relation r, cell_relation v)
cell copy_cell(cell p)
CELL.
void free_cell_relations(cell_relations p)
void descriptor_non_recursive_free(descriptor p)
void path_selectors_non_recursive_free(path_selectors p)
void free_approximation(approximation p)
gap make_gap(entity a1, path_selectors a2)
void effects_assign_contents(effects r, effects v)
list gen_cell_cons(cell p, list l)
bool cell_interpretation_consistent_p(cell_interpretation p)
statement_cell_relations copy_statement_cell_relations(statement_cell_relations p)
STATEMENT_CELL_RELATIONS.
list gen_statement_cell_relations_cons(statement_cell_relations p, list l)
effects_classes copy_effects_classes(effects_classes p)
EFFECTS_CLASSES.
list gen_cell_relations_cons(cell_relations p, list l)
statement_effects make_statement_effects(void)
bool path_selectors_defined_p(path_selectors p)
statement_cell_relations make_statement_cell_relations(void)
list gen_interpreted_cell_cons(interpreted_cell p, list l)
void free_descriptor(descriptor p)
void recursive_selector_non_recursive_free(recursive_selector p)
void write_action_kind(FILE *f, action_kind p)
bool interpreted_cell_defined_p(interpreted_cell p)
void update_statement_cell_relations(statement_cell_relations f, statement k, cell_relations v)
bool cell_relation_defined_p(cell_relation p)
void path_selectors_assign_contents(path_selectors r, path_selectors v)
string descriptor_tag_as_string(enum descriptor_utype tag)
void write_persistant_expression_to_effects(FILE *f, persistant_expression_to_effects p)
void extend_persistant_expression_to_effects(persistant_expression_to_effects f, expression k, effects v)
list gen_effects_classes_cons(effects_classes p, list l)
bool effects_classes_consistent_p(effects_classes p)
void gap_assign_contents(gap r, gap v)
bool action_kind_consistent_p(action_kind p)
bool cell_relations_defined_p(cell_relations p)
#define ACTION_NEWGEN_DOMAIN
#define EFFECT_NEWGEN_DOMAIN
#define cell_relations_domain
newgen_cell_relation_domain_defined
#define RECURSIVE_SELECTOR_NEWGEN_DOMAIN
#define action_kind_domain
newgen_Psysteme_domain_defined
#define PATH_SELECTORS_NEWGEN_DOMAIN
#define persistant_expression_to_effects_hash_table(x)
#define CELL_RELATION_NEWGEN_DOMAIN
@ is_path_selector_expression
@ is_path_selector_recursive_selector
#define interpreted_cell_domain
newgen_gap_domain_defined
#define cell_relation_domain
newgen_cell_domain_defined
#define ENTITY_EFFECTS_NEWGEN_DOMAIN
#define DESCRIPTOR_NEWGEN_DOMAIN
#define statement_effects_hash_table(x)
#define ACTION_KIND_NEWGEN_DOMAIN
#define cell_interpretation_domain
newgen_approximation_domain_defined
@ is_action_kind_environment
@ is_action_kind_type_declaration
#define CELL_RELATIONS_NEWGEN_DOMAIN
cell_interpretation_utype
@ is_cell_interpretation_address_of
@ is_cell_interpretation_value_of
#define entity_effects_domain
newgen_effects_domain_defined
#define persistant_expression_to_effects_domain
newgen_path_selectors_domain_defined
#define INTERPRETED_CELL_NEWGEN_DOMAIN
#define statement_cell_relations_domain
newgen_recursive_selector_domain_defined
#define entity_effects_hash_table(x)
#define EFFECTS_CLASSES_NEWGEN_DOMAIN
#define GAP_NEWGEN_DOMAIN
#define STATEMENT_CELL_RELATIONS_NEWGEN_DOMAIN
#define statement_cell_relations_hash_table(x)
#define effects_classes_domain
newgen_effect_domain_defined
#define action_domain
newgen_action_kind_domain_defined
#define PERSISTANT_EXPRESSION_TO_EFFECTS_NEWGEN_DOMAIN
#define approximation_domain
newgen_action_domain_defined
#define PATH_SELECTOR_NEWGEN_DOMAIN
#define cell_domain
newgen_cell_interpretation_domain_defined
#define effects_domain
newgen_effects_classes_domain_defined
#define recursive_selector_domain
newgen_persistant_expression_to_effects_domain_defined
#define path_selector_domain
newgen_interpreted_cell_domain_defined
@ is_descriptor_convexunion
#define descriptor_domain
newgen_cell_relations_domain_defined
#define APPROXIMATION_NEWGEN_DOMAIN
#define CELL_INTERPRETATION_NEWGEN_DOMAIN
#define statement_effects_domain
newgen_statement_cell_relations_domain_defined
#define gap_domain
newgen_entity_effects_domain_defined
#define CELL_NEWGEN_DOMAIN
#define effect_domain
newgen_descriptor_domain_defined
#define path_selectors_domain
newgen_path_selector_domain_defined
#define STATEMENT_EFFECTS_NEWGEN_DOMAIN
#define EFFECTS_NEWGEN_DOMAIN
void gen_free(gen_chunk *obj)
version without shared_pointers.
gen_chunk * gen_alloc(int size, int gen_check_p, int dom,...)
allocates something in newgen.
int gen_consistent_p(gen_chunk *obj)
GEN_CONSISTENT_P dynamically checks the type correctness of OBJ.
int gen_defined_p(gen_chunk *obj)
gen_chunk * gen_check(gen_chunk *obj, int t)
GEN_CHECK checks that the gen_chunk received OBJ is of the appropriate TYPE.
gen_chunk * gen_read(FILE *file)
GEN_READ reads any object from the FILE stream.
gen_chunk * gen_copy_tree(gen_chunk *obj)
void gen_write(FILE *fd, gen_chunk *obj)
GEN_WRITE writes the OBJect on the stream FD.
list gen_typed_cons(_int type, const void *item, const list next)
CONS a list with minimal type checking this cannot be done within the CONS macro because possible fun...
#define message_assert(msg, ex)
#define HASH_GET(start, image, h, k)
#define HASH_EXTEND(start, image, h, k, v)
#define HASH_DELETE(start, image, h, k)
#define HASH_UPDATE(start, image, h, k, v)
#define HASH_BOUND_P(start, image, h, k)
int f(int off1, int off2, int n, float r[n], float a[n], float b[n])
The structure used to build lists in NewGen.
A gen_chunk is used to store every object.