#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "genC.h"
#include "effects.h"

Include dependency graph for effects.c:

Typedefs
typedef void *	Psysteme

Functions
action_kind	copy_action_kind (action_kind p)
	ACTION_KIND. More...

void	free_action_kind (action_kind p)

action_kind	check_action_kind (action_kind p)

bool	action_kind_consistent_p (action_kind p)

bool	action_kind_defined_p (action_kind p)

list	gen_action_kind_cons (action_kind p, list l)

void	action_kind_assign_contents (action_kind r, action_kind v)

void	action_kind_non_recursive_free (action_kind p)

void	write_action_kind (FILE *f, action_kind p)

action_kind	read_action_kind (FILE *f)

string	action_kind_tag_as_string (enum action_kind_utype tag)

action_kind	make_action_kind (enum action_kind_utype tag, void *val)

action_kind	make_action_kind_store (void)

action_kind	make_action_kind_environment (void)

action_kind	make_action_kind_type_declaration (void)

action	copy_action (action p)
	ACTION. More...

void	free_action (action p)

action	check_action (action p)

bool	action_consistent_p (action p)

bool	action_defined_p (action p)

list	gen_action_cons (action p, list l)

void	action_assign_contents (action r, action v)

void	action_non_recursive_free (action p)

void	write_action (FILE *f, action p)

action	read_action (FILE *f)

string	action_tag_as_string (enum action_utype tag)

action	make_action (enum action_utype tag, void *val)

action	make_action_read (action_kind _field_)

action	make_action_write (action_kind _field_)

approximation	copy_approximation (approximation p)
	APPROXIMATION. More...

void	free_approximation (approximation p)

approximation	check_approximation (approximation p)

bool	approximation_consistent_p (approximation p)

bool	approximation_defined_p (approximation p)

list	gen_approximation_cons (approximation p, list l)

void	approximation_assign_contents (approximation r, approximation v)

void	approximation_non_recursive_free (approximation p)

void	write_approximation (FILE *f, approximation p)

approximation	read_approximation (FILE *f)

string	approximation_tag_as_string (enum approximation_utype tag)

approximation	make_approximation (enum approximation_utype tag, void *val)

approximation	make_approximation_may (void)

approximation	make_approximation_must (void)

approximation	make_approximation_exact (void)

cell_interpretation	copy_cell_interpretation (cell_interpretation p)
	CELL_INTERPRETATION. More...

void	free_cell_interpretation (cell_interpretation p)

cell_interpretation	check_cell_interpretation (cell_interpretation p)

bool	cell_interpretation_consistent_p (cell_interpretation p)

bool	cell_interpretation_defined_p (cell_interpretation p)

list	gen_cell_interpretation_cons (cell_interpretation p, list l)

void	cell_interpretation_assign_contents (cell_interpretation r, cell_interpretation v)

void	cell_interpretation_non_recursive_free (cell_interpretation p)

void	write_cell_interpretation (FILE *f, cell_interpretation p)

cell_interpretation	read_cell_interpretation (FILE *f)

string	cell_interpretation_tag_as_string (enum cell_interpretation_utype tag)

cell_interpretation	make_cell_interpretation (enum cell_interpretation_utype tag, void *val)

cell_interpretation	make_cell_interpretation_value_of (void)

cell_interpretation	make_cell_interpretation_address_of (void)

cell	copy_cell (cell p)
	CELL. More...

void	free_cell (cell p)

cell	check_cell (cell p)

bool	cell_consistent_p (cell p)

bool	cell_defined_p (cell p)

list	gen_cell_cons (cell p, list l)

void	cell_assign_contents (cell r, cell v)

void	cell_non_recursive_free (cell p)

void	write_cell (FILE *f, cell p)

cell	read_cell (FILE *f)

string	cell_tag_as_string (enum cell_utype tag)

cell	make_cell (enum cell_utype tag, void *val)

cell	make_cell_reference (reference _field_)

cell	make_cell_preference (preference _field_)

cell	make_cell_gap (gap _field_)

cell_relation	copy_cell_relation (cell_relation p)
	CELL_RELATION. More...

void	free_cell_relation (cell_relation p)

cell_relation	check_cell_relation (cell_relation p)

bool	cell_relation_consistent_p (cell_relation p)

bool	cell_relation_defined_p (cell_relation p)

list	gen_cell_relation_cons (cell_relation p, list l)

void	cell_relation_assign_contents (cell_relation r, cell_relation v)

void	cell_relation_non_recursive_free (cell_relation p)

void	write_cell_relation (FILE *f, cell_relation p)

cell_relation	read_cell_relation (FILE *f)

cell_relation	make_cell_relation (interpreted_cell a1, interpreted_cell a2, approximation a3, descriptor a4)

cell_relations	copy_cell_relations (cell_relations p)
	CELL_RELATIONS. More...

void	free_cell_relations (cell_relations p)

cell_relations	check_cell_relations (cell_relations p)

bool	cell_relations_consistent_p (cell_relations p)

bool	cell_relations_defined_p (cell_relations p)

list	gen_cell_relations_cons (cell_relations p, list l)

void	cell_relations_assign_contents (cell_relations r, cell_relations v)

void	cell_relations_non_recursive_free (cell_relations p)

void	write_cell_relations (FILE *f, cell_relations p)

cell_relations	read_cell_relations (FILE *f)

cell_relations	make_cell_relations (list a)

descriptor	copy_descriptor (descriptor p)
	DESCRIPTOR. More...

void	free_descriptor (descriptor p)

descriptor	check_descriptor (descriptor p)

bool	descriptor_consistent_p (descriptor p)

bool	descriptor_defined_p (descriptor p)

list	gen_descriptor_cons (descriptor p, list l)

void	descriptor_assign_contents (descriptor r, descriptor v)

void	descriptor_non_recursive_free (descriptor p)

void	write_descriptor (FILE *f, descriptor p)

descriptor	read_descriptor (FILE *f)

string	descriptor_tag_as_string (enum descriptor_utype tag)

descriptor	make_descriptor (enum descriptor_utype tag, void *val)

descriptor	make_descriptor_convexunion (list _field_)

descriptor	make_descriptor_convex (Psysteme _field_)

descriptor	make_descriptor_none (void)

effect	copy_effect (effect p)
	EFFECT. More...

void	free_effect (effect p)

effect	check_effect (effect p)

bool	effect_consistent_p (effect p)

bool	effect_defined_p (effect p)

list	gen_effect_cons (effect p, list l)

void	effect_assign_contents (effect r, effect v)

void	effect_non_recursive_free (effect p)

void	write_effect (FILE *f, effect p)

effect	read_effect (FILE *f)

effect	make_effect (cell a1, action a2, approximation a3, descriptor a4)

effects_classes	copy_effects_classes (effects_classes p)
	EFFECTS_CLASSES. More...

void	free_effects_classes (effects_classes p)

effects_classes	check_effects_classes (effects_classes p)

bool	effects_classes_consistent_p (effects_classes p)

bool	effects_classes_defined_p (effects_classes p)

list	gen_effects_classes_cons (effects_classes p, list l)

void	effects_classes_assign_contents (effects_classes r, effects_classes v)

void	effects_classes_non_recursive_free (effects_classes p)

void	write_effects_classes (FILE *f, effects_classes p)

effects_classes	read_effects_classes (FILE *f)

effects_classes	make_effects_classes (list a)

effects	copy_effects (effects p)
	EFFECTS. More...

void	free_effects (effects p)

effects	check_effects (effects p)

bool	effects_consistent_p (effects p)

bool	effects_defined_p (effects p)

list	gen_effects_cons (effects p, list l)

void	effects_assign_contents (effects r, effects v)

void	effects_non_recursive_free (effects p)

void	write_effects (FILE *f, effects p)

effects	read_effects (FILE *f)

effects	make_effects (list a)

entity_effects	copy_entity_effects (entity_effects p)
	ENTITY_EFFECTS. More...

void	free_entity_effects (entity_effects p)

entity_effects	check_entity_effects (entity_effects p)

bool	entity_effects_consistent_p (entity_effects p)

bool	entity_effects_defined_p (entity_effects p)

list	gen_entity_effects_cons (entity_effects p, list l)

void	entity_effects_assign_contents (entity_effects r, entity_effects v)

void	entity_effects_non_recursive_free (entity_effects p)

void	write_entity_effects (FILE *f, entity_effects p)

entity_effects	read_entity_effects (FILE *f)

entity_effects	make_entity_effects (void)

effects	apply_entity_effects (entity_effects f, entity k)

void	update_entity_effects (entity_effects f, entity k, effects v)

void	extend_entity_effects (entity_effects f, entity k, effects v)

effects	delete_entity_effects (entity_effects f, entity k)

bool	bound_entity_effects_p (entity_effects f, entity k)

gap	copy_gap (gap p)
	GAP. More...

void	free_gap (gap p)

gap	check_gap (gap p)

bool	gap_consistent_p (gap p)

bool	gap_defined_p (gap p)

list	gen_gap_cons (gap p, list l)

void	gap_assign_contents (gap r, gap v)

void	gap_non_recursive_free (gap p)

void	write_gap (FILE *f, gap p)

gap	read_gap (FILE *f)

gap	make_gap (entity a1, path_selectors a2)

interpreted_cell	copy_interpreted_cell (interpreted_cell p)
	INTERPRETED_CELL. More...

void	free_interpreted_cell (interpreted_cell p)

interpreted_cell	check_interpreted_cell (interpreted_cell p)

bool	interpreted_cell_consistent_p (interpreted_cell p)

bool	interpreted_cell_defined_p (interpreted_cell p)

list	gen_interpreted_cell_cons (interpreted_cell p, list l)

void	interpreted_cell_assign_contents (interpreted_cell r, interpreted_cell v)

void	interpreted_cell_non_recursive_free (interpreted_cell p)

void	write_interpreted_cell (FILE *f, interpreted_cell p)

interpreted_cell	read_interpreted_cell (FILE *f)

interpreted_cell	make_interpreted_cell (cell a1, cell_interpretation a2)

path_selector	copy_path_selector (path_selector p)
	PATH_SELECTOR. More...

void	free_path_selector (path_selector p)

path_selector	check_path_selector (path_selector p)

bool	path_selector_consistent_p (path_selector p)

bool	path_selector_defined_p (path_selector p)

list	gen_path_selector_cons (path_selector p, list l)

void	path_selector_assign_contents (path_selector r, path_selector v)

void	path_selector_non_recursive_free (path_selector p)

void	write_path_selector (FILE *f, path_selector p)

path_selector	read_path_selector (FILE *f)

string	path_selector_tag_as_string (enum path_selector_utype tag)

path_selector	make_path_selector (enum path_selector_utype tag, void *val)

path_selector	make_path_selector_expression (expression _field_)

path_selector	make_path_selector_recursive_selector (recursive_selector _field_)

path_selectors	copy_path_selectors (path_selectors p)
	PATH_SELECTORS. More...

void	free_path_selectors (path_selectors p)

path_selectors	check_path_selectors (path_selectors p)

bool	path_selectors_consistent_p (path_selectors p)

bool	path_selectors_defined_p (path_selectors p)

list	gen_path_selectors_cons (path_selectors p, list l)

void	path_selectors_assign_contents (path_selectors r, path_selectors v)

void	path_selectors_non_recursive_free (path_selectors p)

void	write_path_selectors (FILE *f, path_selectors p)

path_selectors	read_path_selectors (FILE *f)

path_selectors	make_path_selectors (list a)

persistant_expression_to_effects	copy_persistant_expression_to_effects (persistant_expression_to_effects p)
	PERSISTANT_EXPRESSION_TO_EFFECTS. More...

void	free_persistant_expression_to_effects (persistant_expression_to_effects p)

persistant_expression_to_effects	check_persistant_expression_to_effects (persistant_expression_to_effects p)

bool	persistant_expression_to_effects_consistent_p (persistant_expression_to_effects p)

bool	persistant_expression_to_effects_defined_p (persistant_expression_to_effects p)

list	gen_persistant_expression_to_effects_cons (persistant_expression_to_effects p, list l)

void	persistant_expression_to_effects_assign_contents (persistant_expression_to_effects r, persistant_expression_to_effects v)

void	persistant_expression_to_effects_non_recursive_free (persistant_expression_to_effects p)

void	write_persistant_expression_to_effects (FILE *f, persistant_expression_to_effects p)

persistant_expression_to_effects	read_persistant_expression_to_effects (FILE *f)

persistant_expression_to_effects	make_persistant_expression_to_effects (void)

effects	apply_persistant_expression_to_effects (persistant_expression_to_effects f, expression k)

void	update_persistant_expression_to_effects (persistant_expression_to_effects f, expression k, effects v)

void	extend_persistant_expression_to_effects (persistant_expression_to_effects f, expression k, effects v)

effects	delete_persistant_expression_to_effects (persistant_expression_to_effects f, expression k)

bool	bound_persistant_expression_to_effects_p (persistant_expression_to_effects f, expression k)

recursive_selector	copy_recursive_selector (recursive_selector p)
	RECURSIVE_SELECTOR. More...

void	free_recursive_selector (recursive_selector p)

recursive_selector	check_recursive_selector (recursive_selector p)

bool	recursive_selector_consistent_p (recursive_selector p)

bool	recursive_selector_defined_p (recursive_selector p)

list	gen_recursive_selector_cons (recursive_selector p, list l)

void	recursive_selector_assign_contents (recursive_selector r, recursive_selector v)

void	recursive_selector_non_recursive_free (recursive_selector p)

void	write_recursive_selector (FILE *f, recursive_selector p)

recursive_selector	read_recursive_selector (FILE *f)

recursive_selector	make_recursive_selector (list a1, expression a2)

statement_cell_relations	copy_statement_cell_relations (statement_cell_relations p)
	STATEMENT_CELL_RELATIONS. More...

void	free_statement_cell_relations (statement_cell_relations p)

statement_cell_relations	check_statement_cell_relations (statement_cell_relations p)

bool	statement_cell_relations_consistent_p (statement_cell_relations p)

bool	statement_cell_relations_defined_p (statement_cell_relations p)

list	gen_statement_cell_relations_cons (statement_cell_relations p, list l)

void	statement_cell_relations_assign_contents (statement_cell_relations r, statement_cell_relations v)

void	statement_cell_relations_non_recursive_free (statement_cell_relations p)

void	write_statement_cell_relations (FILE *f, statement_cell_relations p)

statement_cell_relations	read_statement_cell_relations (FILE *f)

statement_cell_relations	make_statement_cell_relations (void)

cell_relations	apply_statement_cell_relations (statement_cell_relations f, statement k)

void	update_statement_cell_relations (statement_cell_relations f, statement k, cell_relations v)

void	extend_statement_cell_relations (statement_cell_relations f, statement k, cell_relations v)

cell_relations	delete_statement_cell_relations (statement_cell_relations f, statement k)

bool	bound_statement_cell_relations_p (statement_cell_relations f, statement k)

statement_effects	copy_statement_effects (statement_effects p)
	STATEMENT_EFFECTS. More...

void	free_statement_effects (statement_effects p)

statement_effects	check_statement_effects (statement_effects p)

bool	statement_effects_consistent_p (statement_effects p)

bool	statement_effects_defined_p (statement_effects p)

list	gen_statement_effects_cons (statement_effects p, list l)

void	statement_effects_assign_contents (statement_effects r, statement_effects v)

void	statement_effects_non_recursive_free (statement_effects p)

void	write_statement_effects (FILE *f, statement_effects p)

statement_effects	read_statement_effects (FILE *f)

statement_effects	make_statement_effects (void)

effects	apply_statement_effects (statement_effects f, statement k)

void	update_statement_effects (statement_effects f, statement k, effects v)

void	extend_statement_effects (statement_effects f, statement k, effects v)

effects	delete_statement_effects (statement_effects f, statement k)

bool	bound_statement_effects_p (statement_effects f, statement k)

Typedef Documentation

◆ Psysteme

typedef void* Psysteme

Definition at line 7 of file effects.c.

Function Documentation

◆ action_assign_contents()

void action_assign_contents	(	action	r,
		action	v
	)

Definition at line 96 of file effects.c.

                                                 {
   check_action(r);
   check_action(v);
   message_assert("defined references to domain action",
                  action_defined_p(r) && action_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_action_));
 }

References action_defined_p(), check_action(), and message_assert.

Here is the call graph for this function:

◆ action_consistent_p()

bool action_consistent_p ( action p )

Definition at line 86 of file effects.c.

                                    {
   check_action(p);
   return gen_consistent_p((gen_chunk*) p);
 }

References check_action(), and gen_consistent_p().

Here is the call graph for this function:

◆ action_defined_p()

bool action_defined_p ( action p )

Definition at line 90 of file effects.c.

                                 {
   return gen_defined_p((gen_chunk*) p);
 }

References gen_defined_p().

Here is the call graph for this function:

◆ action_kind_assign_contents()

void action_kind_assign_contents	(	action_kind	r,
		action_kind	v
	)

Definition at line 37 of file effects.c.

                                                                {
   check_action_kind(r);
   check_action_kind(v);
   message_assert("defined references to domain action_kind",
                  action_kind_defined_p(r) && action_kind_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_action_kind_));
 }

References action_kind_defined_p(), check_action_kind(), and message_assert.

Here is the call graph for this function:

◆ action_kind_consistent_p()

bool action_kind_consistent_p ( action_kind p )

Definition at line 27 of file effects.c.

                                              {
   check_action_kind(p);
   return gen_consistent_p((gen_chunk*) p);
 }

References check_action_kind(), and gen_consistent_p().

Here is the call graph for this function:

◆ action_kind_defined_p()

bool action_kind_defined_p ( action_kind p )

Definition at line 31 of file effects.c.

                                           {
   return gen_defined_p((gen_chunk*) p);
 }

References gen_defined_p().

Here is the call graph for this function:

◆ action_kind_non_recursive_free()

void action_kind_non_recursive_free ( action_kind p )

Definition at line 44 of file effects.c.

                                                    {
   // should clear up contents...
   free(p);
 }

References free().

Here is the call graph for this function:

◆ action_kind_tag_as_string()

string action_kind_tag_as_string ( enum action_kind_utype tag )

Definition at line 54 of file effects.c.

                                                              {
   switch (tag) {
   case is_action_kind_store: return "store";
   case is_action_kind_environment: return "environment";
   case is_action_kind_type_declaration: return "type_declaration";
   default: return string_undefined;
   }
 }

References is_action_kind_environment, is_action_kind_store, is_action_kind_type_declaration, and string_undefined.

◆ action_non_recursive_free()

void action_non_recursive_free ( action p )

Definition at line 103 of file effects.c.

                                          {
   // should clear up contents...
   free(p);
 }

References free().

Here is the call graph for this function:

◆ action_tag_as_string()

string action_tag_as_string ( enum action_utype tag )

Definition at line 113 of file effects.c.

                                                    {
   switch (tag) {
   case is_action_read: return "read";
   case is_action_write: return "write";
   default: return string_undefined;
   }
 }

References is_action_read, is_action_write, and string_undefined.

◆ apply_entity_effects()

effects apply_entity_effects	(	entity_effects	f,
		entity	k
	)

Definition at line 613 of file effects.c.

                                                          {
   return (effects) (intptr_t)HASH_GET(p, p, entity_effects_hash_table(f), k);
 }

References entity_effects_hash_table, f(), HASH_GET, and intptr_t.

Here is the call graph for this function:

◆ apply_persistant_expression_to_effects()

effects apply_persistant_expression_to_effects	(	persistant_expression_to_effects	f,
		expression	k
	)

Definition at line 851 of file effects.c.

                                                                                                  {
   return (effects) (intptr_t)HASH_GET(p, p, persistant_expression_to_effects_hash_table(f), k);
 }

References f(), HASH_GET, intptr_t, and persistant_expression_to_effects_hash_table.

Here is the call graph for this function:

◆ apply_statement_cell_relations()

cell_relations apply_statement_cell_relations	(	statement_cell_relations	f,
		statement	k
	)

Definition at line 950 of file effects.c.

                                                                                        {
   return (cell_relations) (intptr_t)HASH_GET(p, p, statement_cell_relations_hash_table(f), k);
 }

References f(), HASH_GET, intptr_t, and statement_cell_relations_hash_table.

Here is the call graph for this function:

◆ apply_statement_effects()

effects apply_statement_effects	(	statement_effects	f,
		statement	k
	)

Definition at line 1007 of file effects.c.

                                                                   {
   return (effects) (intptr_t)HASH_GET(p, p, statement_effects_hash_table(f), k);
 }

References f(), HASH_GET, intptr_t, and statement_effects_hash_table.

Here is the call graph for this function:

◆ approximation_assign_contents()

void approximation_assign_contents	(	approximation	r,
		approximation	v
	)

Definition at line 151 of file effects.c.

                                                                      {
   check_approximation(r);
   check_approximation(v);
   message_assert("defined references to domain approximation",
                  approximation_defined_p(r) && approximation_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_approximation_));
 }

References approximation_defined_p(), check_approximation(), and message_assert.

Here is the call graph for this function:

◆ approximation_consistent_p()

bool approximation_consistent_p ( approximation p )

Definition at line 141 of file effects.c.

                                                  {
   check_approximation(p);
   return gen_consistent_p((gen_chunk*) p);
 }

References check_approximation(), and gen_consistent_p().

Here is the call graph for this function:

◆ approximation_defined_p()

bool approximation_defined_p ( approximation p )

Definition at line 145 of file effects.c.

                                               {
   return gen_defined_p((gen_chunk*) p);
 }

References gen_defined_p().

Here is the call graph for this function:

◆ approximation_non_recursive_free()

void approximation_non_recursive_free ( approximation p )

Definition at line 158 of file effects.c.

                                                        {
   // should clear up contents...
   free(p);
 }

References free().

Here is the call graph for this function:

◆ approximation_tag_as_string()

string approximation_tag_as_string ( enum approximation_utype tag )

Definition at line 168 of file effects.c.

                                                                  {
   switch (tag) {
   case is_approximation_may: return "may";
   case is_approximation_must: return "must";
   case is_approximation_exact: return "exact";
   default: return string_undefined;
   }
 }

References is_approximation_exact, is_approximation_may, is_approximation_must, and string_undefined.

◆ bound_entity_effects_p()

bool bound_entity_effects_p	(	entity_effects	f,
		entity	k
	)

Definition at line 625 of file effects.c.

                                                         {
   return (intptr_t)HASH_BOUND_P(p, p, entity_effects_hash_table(f), k);
 }

References entity_effects_hash_table, f(), HASH_BOUND_P, and intptr_t.

Here is the call graph for this function:

◆ bound_persistant_expression_to_effects_p()

bool bound_persistant_expression_to_effects_p	(	persistant_expression_to_effects	f,
		expression	k
	)

Definition at line 863 of file effects.c.

                                                                                                 {
   return (intptr_t)HASH_BOUND_P(p, p, persistant_expression_to_effects_hash_table(f), k);
 }

References f(), HASH_BOUND_P, intptr_t, and persistant_expression_to_effects_hash_table.

Here is the call graph for this function:

◆ bound_statement_cell_relations_p()

bool bound_statement_cell_relations_p	(	statement_cell_relations	f,
		statement	k
	)

Definition at line 962 of file effects.c.

                                                                                {
   return (intptr_t)HASH_BOUND_P(p, p, statement_cell_relations_hash_table(f), k);
 }

References f(), HASH_BOUND_P, intptr_t, and statement_cell_relations_hash_table.

Here is the call graph for this function:

◆ bound_statement_effects_p()

bool bound_statement_effects_p	(	statement_effects	f,
		statement	k
	)

Definition at line 1019 of file effects.c.

                                                                  {
   return (intptr_t)HASH_BOUND_P(p, p, statement_effects_hash_table(f), k);
 }

References f(), HASH_BOUND_P, intptr_t, and statement_effects_hash_table.

Here is the call graph for this function:

◆ cell_assign_contents()

void cell_assign_contents	(	cell	r,
		cell	v
	)

Definition at line 265 of file effects.c.

                                           {
   check_cell(r);
   check_cell(v);
   message_assert("defined references to domain cell",
                  cell_defined_p(r) && cell_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_cell_));
 }

References cell_defined_p(), check_cell(), and message_assert.

Here is the call graph for this function:

◆ cell_consistent_p()

bool cell_consistent_p ( cell p )

Definition at line 255 of file effects.c.

                                {
   check_cell(p);
   return gen_consistent_p((gen_chunk*) p);
 }

References check_cell(), and gen_consistent_p().

Here is the call graph for this function:

◆ cell_defined_p()

bool cell_defined_p ( cell p )

Definition at line 259 of file effects.c.

                             {
   return gen_defined_p((gen_chunk*) p);
 }

References gen_defined_p().

Here is the call graph for this function:

◆ cell_interpretation_assign_contents()

void cell_interpretation_assign_contents	(	cell_interpretation	r,
		cell_interpretation	v
	)

Definition at line 210 of file effects.c.

                                                                                        {
   check_cell_interpretation(r);
   check_cell_interpretation(v);
   message_assert("defined references to domain cell_interpretation",
                  cell_interpretation_defined_p(r) && cell_interpretation_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_cell_interpretation_));
 }

References cell_interpretation_defined_p(), check_cell_interpretation(), and message_assert.

Here is the call graph for this function:

◆ cell_interpretation_consistent_p()

bool cell_interpretation_consistent_p ( cell_interpretation p )

Definition at line 200 of file effects.c.

                                                              {
   check_cell_interpretation(p);
   return gen_consistent_p((gen_chunk*) p);
 }

References check_cell_interpretation(), and gen_consistent_p().

Here is the call graph for this function:

◆ cell_interpretation_defined_p()

bool cell_interpretation_defined_p ( cell_interpretation p )

Definition at line 204 of file effects.c.

                                                           {
   return gen_defined_p((gen_chunk*) p);
 }

References gen_defined_p().

Here is the call graph for this function:

◆ cell_interpretation_non_recursive_free()

void cell_interpretation_non_recursive_free ( cell_interpretation p )

Definition at line 217 of file effects.c.

                                                                    {
   // should clear up contents...
   free(p);
 }

References free().

Here is the call graph for this function:

◆ cell_interpretation_tag_as_string()

string cell_interpretation_tag_as_string ( enum cell_interpretation_utype tag )

Definition at line 227 of file effects.c.

                                                                              {
   switch (tag) {
   case is_cell_interpretation_value_of: return "value_of";
   case is_cell_interpretation_address_of: return "address_of";
   default: return string_undefined;
   }
 }

References is_cell_interpretation_address_of, is_cell_interpretation_value_of, and string_undefined.

◆ cell_non_recursive_free()

void cell_non_recursive_free ( cell p )

Definition at line 272 of file effects.c.

                                      {
   // should clear up contents...
   free(p);
 }

References free().

Here is the call graph for this function:

◆ cell_relation_assign_contents()

void cell_relation_assign_contents	(	cell_relation	r,
		cell_relation	v
	)

Definition at line 324 of file effects.c.

                                                                      {
   check_cell_relation(r);
   check_cell_relation(v);
   message_assert("defined references to domain cell_relation",
                  cell_relation_defined_p(r) && cell_relation_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_cell_relation_));
 }

References cell_relation_defined_p(), check_cell_relation(), and message_assert.

Here is the call graph for this function:

◆ cell_relation_consistent_p()

bool cell_relation_consistent_p ( cell_relation p )

Definition at line 314 of file effects.c.

                                                  {
   check_cell_relation(p);
   return gen_consistent_p((gen_chunk*) p);
 }

References check_cell_relation(), and gen_consistent_p().

Here is the call graph for this function:

◆ cell_relation_defined_p()

bool cell_relation_defined_p ( cell_relation p )

Definition at line 318 of file effects.c.

                                               {
   return gen_defined_p((gen_chunk*) p);
 }

References gen_defined_p().

Here is the call graph for this function:

◆ cell_relation_non_recursive_free()

void cell_relation_non_recursive_free ( cell_relation p )

Definition at line 331 of file effects.c.

                                                        {
   // should clear up contents...
   free(p);
 }

References free().

Here is the call graph for this function:

◆ cell_relations_assign_contents()

void cell_relations_assign_contents	(	cell_relations	r,
		cell_relations	v
	)

Definition at line 366 of file effects.c.

                                                                         {
   check_cell_relations(r);
   check_cell_relations(v);
   message_assert("defined references to domain cell_relations",
                  cell_relations_defined_p(r) && cell_relations_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_cell_relations_));
 }

References cell_relations_defined_p(), check_cell_relations(), and message_assert.

Here is the call graph for this function:

◆ cell_relations_consistent_p()

bool cell_relations_consistent_p ( cell_relations p )

Definition at line 356 of file effects.c.

                                                    {
   check_cell_relations(p);
   return gen_consistent_p((gen_chunk*) p);
 }

References check_cell_relations(), and gen_consistent_p().

Here is the call graph for this function:

◆ cell_relations_defined_p()

bool cell_relations_defined_p ( cell_relations p )

Definition at line 360 of file effects.c.

                                                 {
   return gen_defined_p((gen_chunk*) p);
 }

References gen_defined_p().

Here is the call graph for this function:

◆ cell_relations_non_recursive_free()

void cell_relations_non_recursive_free ( cell_relations p )

Definition at line 373 of file effects.c.

                                                          {
   // should clear up contents...
   free(p);
 }

References free().

Here is the call graph for this function:

◆ cell_tag_as_string()

string cell_tag_as_string ( enum cell_utype tag )

Definition at line 282 of file effects.c.

                                                {
   switch (tag) {
   case is_cell_reference: return "reference";
   case is_cell_preference: return "preference";
   case is_cell_gap: return "gap";
   default: return string_undefined;
   }
 }

References is_cell_gap, is_cell_preference, is_cell_reference, and string_undefined.

◆ check_action()

action check_action ( action p )

Definition at line 83 of file effects.c.

                               {
   return (action) gen_check((gen_chunk*) p, action_domain);
 }

References action_domain, and gen_check().

Here is the call graph for this function:

◆ check_action_kind()

action_kind check_action_kind ( action_kind p )

Definition at line 24 of file effects.c.

                                              {
   return (action_kind) gen_check((gen_chunk*) p, action_kind_domain);
 }

References action_kind_domain, and gen_check().

Here is the call graph for this function:

◆ check_approximation()

approximation check_approximation ( approximation p )

Definition at line 138 of file effects.c.

                                                    {
   return (approximation) gen_check((gen_chunk*) p, approximation_domain);
 }

References approximation_domain, and gen_check().

Here is the call graph for this function:

◆ check_cell()

cell check_cell ( cell p )

Definition at line 252 of file effects.c.

                         {
   return (cell) gen_check((gen_chunk*) p, cell_domain);
 }

References cell_domain, and gen_check().

Here is the call graph for this function:

◆ check_cell_interpretation()

cell_interpretation check_cell_interpretation ( cell_interpretation p )

Definition at line 197 of file effects.c.

                                                                      {
   return (cell_interpretation) gen_check((gen_chunk*) p, cell_interpretation_domain);
 }

References cell_interpretation_domain, and gen_check().

Here is the call graph for this function:

◆ check_cell_relation()

cell_relation check_cell_relation ( cell_relation p )

Definition at line 311 of file effects.c.

                                                    {
   return (cell_relation) gen_check((gen_chunk*) p, cell_relation_domain);
 }

References cell_relation_domain, and gen_check().

Here is the call graph for this function:

◆ check_cell_relations()

cell_relations check_cell_relations ( cell_relations p )

Definition at line 353 of file effects.c.

                                                       {
   return (cell_relations) gen_check((gen_chunk*) p, cell_relations_domain);
 }

References cell_relations_domain, and gen_check().

Here is the call graph for this function:

◆ check_descriptor()

descriptor check_descriptor ( descriptor p )

Definition at line 395 of file effects.c.

                                           {
   return (descriptor) gen_check((gen_chunk*) p, descriptor_domain);
 }

References descriptor_domain, and gen_check().

Here is the call graph for this function:

◆ check_effect()

effect check_effect ( effect p )

Definition at line 454 of file effects.c.

                               {
   return (effect) gen_check((gen_chunk*) p, effect_domain);
 }

References effect_domain, and gen_check().

Here is the call graph for this function:

◆ check_effects()

effects check_effects ( effects p )

Definition at line 538 of file effects.c.

                                  {
   return (effects) gen_check((gen_chunk*) p, effects_domain);
 }

References effects_domain, and gen_check().

Here is the call graph for this function:

◆ check_effects_classes()

effects_classes check_effects_classes ( effects_classes p )

Definition at line 496 of file effects.c.

                                                          {
   return (effects_classes) gen_check((gen_chunk*) p, effects_classes_domain);
 }

References effects_classes_domain, and gen_check().

Here is the call graph for this function:

◆ check_entity_effects()

entity_effects check_entity_effects ( entity_effects p )

Definition at line 580 of file effects.c.

                                                       {
   return (entity_effects) gen_check((gen_chunk*) p, entity_effects_domain);
 }

References entity_effects_domain, and gen_check().

Here is the call graph for this function:

◆ check_gap()

gap check_gap ( gap p )

Definition at line 637 of file effects.c.

                      {
   return (gap) gen_check((gen_chunk*) p, gap_domain);
 }

References gap_domain, and gen_check().

Here is the call graph for this function:

◆ check_interpreted_cell()

interpreted_cell check_interpreted_cell ( interpreted_cell p )

Definition at line 679 of file effects.c.

                                                             {
   return (interpreted_cell) gen_check((gen_chunk*) p, interpreted_cell_domain);
 }

References gen_check(), and interpreted_cell_domain.

Here is the call graph for this function:

◆ check_path_selector()

path_selector check_path_selector ( path_selector p )

Definition at line 721 of file effects.c.

                                                    {
   return (path_selector) gen_check((gen_chunk*) p, path_selector_domain);
 }

References gen_check(), and path_selector_domain.

Here is the call graph for this function:

◆ check_path_selectors()

path_selectors check_path_selectors ( path_selectors p )

Definition at line 776 of file effects.c.

                                                       {
   return (path_selectors) gen_check((gen_chunk*) p, path_selectors_domain);
 }

References gen_check(), and path_selectors_domain.

Here is the call graph for this function:

◆ check_persistant_expression_to_effects()

persistant_expression_to_effects check_persistant_expression_to_effects ( persistant_expression_to_effects p )

Definition at line 818 of file effects.c.

                                                                                                             {
   return (persistant_expression_to_effects) gen_check((gen_chunk*) p, persistant_expression_to_effects_domain);
 }

References gen_check(), and persistant_expression_to_effects_domain.

Here is the call graph for this function:

◆ check_recursive_selector()

recursive_selector check_recursive_selector ( recursive_selector p )

Definition at line 875 of file effects.c.

                                                                   {
   return (recursive_selector) gen_check((gen_chunk*) p, recursive_selector_domain);
 }

References gen_check(), and recursive_selector_domain.

Here is the call graph for this function:

◆ check_statement_cell_relations()

statement_cell_relations check_statement_cell_relations ( statement_cell_relations p )

Definition at line 917 of file effects.c.

                                                                                     {
   return (statement_cell_relations) gen_check((gen_chunk*) p, statement_cell_relations_domain);
 }

References gen_check(), and statement_cell_relations_domain.

Here is the call graph for this function:

◆ check_statement_effects()

statement_effects check_statement_effects ( statement_effects p )

Definition at line 974 of file effects.c.

                                                                {
   return (statement_effects) gen_check((gen_chunk*) p, statement_effects_domain);
 }

References gen_check(), and statement_effects_domain.

Here is the call graph for this function:

◆ copy_action()

action copy_action ( action p )

ACTION.

Definition at line 77 of file effects.c.

                              {
   return (action) gen_copy_tree((gen_chunk*) p);
 }

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_action_kind()

action_kind copy_action_kind ( action_kind p )

ACTION_KIND.

Definition at line 18 of file effects.c.

                                             {
   return (action_kind) gen_copy_tree((gen_chunk*) p);
 }

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_approximation()

approximation copy_approximation ( approximation p )

APPROXIMATION.

Definition at line 132 of file effects.c.

                                                   {
   return (approximation) gen_copy_tree((gen_chunk*) p);
 }

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_cell()

cell copy_cell ( cell p )

CELL.

Definition at line 246 of file effects.c.

                        {
   return (cell) gen_copy_tree((gen_chunk*) p);
 }

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_cell_interpretation()

cell_interpretation copy_cell_interpretation ( cell_interpretation p )

CELL_INTERPRETATION.

Definition at line 191 of file effects.c.

                                                                     {
   return (cell_interpretation) gen_copy_tree((gen_chunk*) p);
 }

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_cell_relation()

cell_relation copy_cell_relation ( cell_relation p )

CELL_RELATION.

Definition at line 305 of file effects.c.

                                                   {
   return (cell_relation) gen_copy_tree((gen_chunk*) p);
 }

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_cell_relations()

cell_relations copy_cell_relations ( cell_relations p )

CELL_RELATIONS.

Definition at line 347 of file effects.c.

                                                      {
   return (cell_relations) gen_copy_tree((gen_chunk*) p);
 }

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_descriptor()

descriptor copy_descriptor ( descriptor p )

DESCRIPTOR.

Definition at line 389 of file effects.c.

                                          {
   return (descriptor) gen_copy_tree((gen_chunk*) p);
 }

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_effect()

effect copy_effect ( effect p )

EFFECT.

Definition at line 448 of file effects.c.

                              {
   return (effect) gen_copy_tree((gen_chunk*) p);
 }

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_effects()

effects copy_effects ( effects p )

EFFECTS.

Definition at line 532 of file effects.c.

                                 {
   return (effects) gen_copy_tree((gen_chunk*) p);
 }

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_effects_classes()

effects_classes copy_effects_classes ( effects_classes p )

EFFECTS_CLASSES.

Definition at line 490 of file effects.c.

                                                         {
   return (effects_classes) gen_copy_tree((gen_chunk*) p);
 }

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_entity_effects()

entity_effects copy_entity_effects ( entity_effects p )

ENTITY_EFFECTS.

Definition at line 574 of file effects.c.

                                                      {
   return (entity_effects) gen_copy_tree((gen_chunk*) p);
 }

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_gap()

gap copy_gap ( gap p )

GAP.

Definition at line 631 of file effects.c.

                     {
   return (gap) gen_copy_tree((gen_chunk*) p);
 }

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_interpreted_cell()

interpreted_cell copy_interpreted_cell ( interpreted_cell p )

INTERPRETED_CELL.

Definition at line 673 of file effects.c.

                                                            {
   return (interpreted_cell) gen_copy_tree((gen_chunk*) p);
 }

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_path_selector()

path_selector copy_path_selector ( path_selector p )

PATH_SELECTOR.

Definition at line 715 of file effects.c.

                                                   {
   return (path_selector) gen_copy_tree((gen_chunk*) p);
 }

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_path_selectors()

path_selectors copy_path_selectors ( path_selectors p )

PATH_SELECTORS.

Definition at line 770 of file effects.c.

                                                      {
   return (path_selectors) gen_copy_tree((gen_chunk*) p);
 }

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_persistant_expression_to_effects()

persistant_expression_to_effects copy_persistant_expression_to_effects ( persistant_expression_to_effects p )

PERSISTANT_EXPRESSION_TO_EFFECTS.

Definition at line 812 of file effects.c.

                                                                                                            {
   return (persistant_expression_to_effects) gen_copy_tree((gen_chunk*) p);
 }

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_recursive_selector()

recursive_selector copy_recursive_selector ( recursive_selector p )

RECURSIVE_SELECTOR.

Definition at line 869 of file effects.c.

                                                                  {
   return (recursive_selector) gen_copy_tree((gen_chunk*) p);
 }

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_statement_cell_relations()

statement_cell_relations copy_statement_cell_relations ( statement_cell_relations p )

STATEMENT_CELL_RELATIONS.

Definition at line 911 of file effects.c.

                                                                                    {
   return (statement_cell_relations) gen_copy_tree((gen_chunk*) p);
 }

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_statement_effects()

statement_effects copy_statement_effects ( statement_effects p )

STATEMENT_EFFECTS.

Definition at line 968 of file effects.c.

                                                               {
   return (statement_effects) gen_copy_tree((gen_chunk*) p);
 }

References gen_copy_tree().

Here is the call graph for this function:

◆ delete_entity_effects()

effects delete_entity_effects	(	entity_effects	f,
		entity	k
	)

Definition at line 622 of file effects.c.

                                                           {
   return (effects)(intptr_t) HASH_DELETE(p, p, entity_effects_hash_table(f), k);
 }

References entity_effects_hash_table, f(), HASH_DELETE, and intptr_t.

Here is the call graph for this function:

◆ delete_persistant_expression_to_effects()

effects delete_persistant_expression_to_effects	(	persistant_expression_to_effects	f,
		expression	k
	)

Definition at line 860 of file effects.c.

                                                                                                   {
   return (effects)(intptr_t) HASH_DELETE(p, p, persistant_expression_to_effects_hash_table(f), k);
 }

References f(), HASH_DELETE, intptr_t, and persistant_expression_to_effects_hash_table.

Here is the call graph for this function:

◆ delete_statement_cell_relations()

cell_relations delete_statement_cell_relations	(	statement_cell_relations	f,
		statement	k
	)

Definition at line 959 of file effects.c.

                                                                                         {
   return (cell_relations)(intptr_t) HASH_DELETE(p, p, statement_cell_relations_hash_table(f), k);
 }

References f(), HASH_DELETE, intptr_t, and statement_cell_relations_hash_table.

Here is the call graph for this function:

◆ delete_statement_effects()

effects delete_statement_effects	(	statement_effects	f,
		statement	k
	)

Definition at line 1016 of file effects.c.

                                                                    {
   return (effects)(intptr_t) HASH_DELETE(p, p, statement_effects_hash_table(f), k);
 }

References f(), HASH_DELETE, intptr_t, and statement_effects_hash_table.

Here is the call graph for this function:

◆ descriptor_assign_contents()

void descriptor_assign_contents	(	descriptor	r,
		descriptor	v
	)

Definition at line 408 of file effects.c.

                                                             {
   check_descriptor(r);
   check_descriptor(v);
   message_assert("defined references to domain descriptor",
                  descriptor_defined_p(r) && descriptor_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_descriptor_));
 }

References check_descriptor(), descriptor_defined_p(), and message_assert.

Here is the call graph for this function:

◆ descriptor_consistent_p()

bool descriptor_consistent_p ( descriptor p )

Definition at line 398 of file effects.c.

                                            {
   check_descriptor(p);
   return gen_consistent_p((gen_chunk*) p);
 }

References check_descriptor(), and gen_consistent_p().

Here is the call graph for this function:

◆ descriptor_defined_p()

bool descriptor_defined_p ( descriptor p )

Definition at line 402 of file effects.c.

                                         {
   return gen_defined_p((gen_chunk*) p);
 }

References gen_defined_p().

Here is the call graph for this function:

◆ descriptor_non_recursive_free()

void descriptor_non_recursive_free ( descriptor p )

Definition at line 415 of file effects.c.

                                                  {
   // should clear up contents...
   free(p);
 }

References free().

Here is the call graph for this function:

◆ descriptor_tag_as_string()

string descriptor_tag_as_string ( enum descriptor_utype tag )

Definition at line 425 of file effects.c.

                                                            {
   switch (tag) {
   case is_descriptor_convexunion: return "convexunion";
   case is_descriptor_convex: return "convex";
   case is_descriptor_none: return "none";
   default: return string_undefined;
   }
 }

References is_descriptor_convex, is_descriptor_convexunion, is_descriptor_none, and string_undefined.

◆ effect_assign_contents()

void effect_assign_contents	(	effect	r,
		effect	v
	)

Definition at line 467 of file effects.c.

                                                 {
   check_effect(r);
   check_effect(v);
   message_assert("defined references to domain effect",
                  effect_defined_p(r) && effect_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_effect_));
 }

References check_effect(), effect_defined_p(), and message_assert.

Here is the call graph for this function:

◆ effect_consistent_p()

bool effect_consistent_p ( effect p )

Definition at line 457 of file effects.c.

                                    {
   check_effect(p);
   return gen_consistent_p((gen_chunk*) p);
 }

References check_effect(), and gen_consistent_p().

Here is the call graph for this function:

◆ effect_defined_p()

bool effect_defined_p ( effect p )

Definition at line 461 of file effects.c.

                                 {
   return gen_defined_p((gen_chunk*) p);
 }

References gen_defined_p().

Here is the call graph for this function:

◆ effect_non_recursive_free()

void effect_non_recursive_free ( effect p )

Definition at line 474 of file effects.c.

                                          {
   // should clear up contents...
   free(p);
 }

References free().

Here is the call graph for this function:

◆ effects_assign_contents()

void effects_assign_contents	(	effects	r,
		effects	v
	)

Definition at line 551 of file effects.c.

                                                    {
   check_effects(r);
   check_effects(v);
   message_assert("defined references to domain effects",
                  effects_defined_p(r) && effects_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_effects_));
 }

References check_effects(), effects_defined_p(), and message_assert.

Here is the call graph for this function:

◆ effects_classes_assign_contents()

void effects_classes_assign_contents	(	effects_classes	r,
		effects_classes	v
	)

Definition at line 509 of file effects.c.

                                                                            {
   check_effects_classes(r);
   check_effects_classes(v);
   message_assert("defined references to domain effects_classes",
                  effects_classes_defined_p(r) && effects_classes_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_effects_classes_));
 }

References check_effects_classes(), effects_classes_defined_p(), and message_assert.

Here is the call graph for this function:

◆ effects_classes_consistent_p()

bool effects_classes_consistent_p ( effects_classes p )

Definition at line 499 of file effects.c.

                                                      {
   check_effects_classes(p);
   return gen_consistent_p((gen_chunk*) p);
 }

References check_effects_classes(), and gen_consistent_p().

Here is the call graph for this function:

◆ effects_classes_defined_p()

bool effects_classes_defined_p ( effects_classes p )

Definition at line 503 of file effects.c.

                                                   {
   return gen_defined_p((gen_chunk*) p);
 }

References gen_defined_p().

Here is the call graph for this function:

◆ effects_classes_non_recursive_free()

void effects_classes_non_recursive_free ( effects_classes p )

Definition at line 516 of file effects.c.

                                                            {
   // should clear up contents...
   free(p);
 }

References free().

Here is the call graph for this function:

◆ effects_consistent_p()

bool effects_consistent_p ( effects p )

Definition at line 541 of file effects.c.

                                      {
   check_effects(p);
   return gen_consistent_p((gen_chunk*) p);
 }

References check_effects(), and gen_consistent_p().

Here is the call graph for this function:

◆ effects_defined_p()

bool effects_defined_p ( effects p )

Definition at line 545 of file effects.c.

                                   {
   return gen_defined_p((gen_chunk*) p);
 }

References gen_defined_p().

Here is the call graph for this function:

◆ effects_non_recursive_free()

void effects_non_recursive_free ( effects p )

Definition at line 558 of file effects.c.

                                            {
   // should clear up contents...
   free(p);
 }

References free().

Here is the call graph for this function:

◆ entity_effects_assign_contents()

void entity_effects_assign_contents	(	entity_effects	r,
		entity_effects	v
	)

Definition at line 593 of file effects.c.

                                                                         {
   check_entity_effects(r);
   check_entity_effects(v);
   message_assert("defined references to domain entity_effects",
                  entity_effects_defined_p(r) && entity_effects_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_entity_effects_));
 }

References check_entity_effects(), entity_effects_defined_p(), and message_assert.

Here is the call graph for this function:

◆ entity_effects_consistent_p()

bool entity_effects_consistent_p ( entity_effects p )

Definition at line 583 of file effects.c.

                                                    {
   check_entity_effects(p);
   return gen_consistent_p((gen_chunk*) p);
 }

References check_entity_effects(), and gen_consistent_p().

Here is the call graph for this function:

◆ entity_effects_defined_p()

bool entity_effects_defined_p ( entity_effects p )

Definition at line 587 of file effects.c.

                                                 {
   return gen_defined_p((gen_chunk*) p);
 }

References gen_defined_p().

Here is the call graph for this function:

◆ entity_effects_non_recursive_free()

void entity_effects_non_recursive_free ( entity_effects p )

Definition at line 600 of file effects.c.

                                                          {
   // should clear up contents...
   free(p);
 }

References free().

Here is the call graph for this function:

◆ extend_entity_effects()

void extend_entity_effects	(	entity_effects	f,
		entity	k,
		effects	v
	)

Definition at line 619 of file effects.c.

                                                                   {
   HASH_EXTEND(p, p, entity_effects_hash_table(f), k, (intptr_t)v);
 }

References entity_effects_hash_table, f(), HASH_EXTEND, and intptr_t.

Here is the call graph for this function:

◆ extend_persistant_expression_to_effects()

void extend_persistant_expression_to_effects	(	persistant_expression_to_effects	f,
		expression	k,
		effects	v
	)

Definition at line 857 of file effects.c.

                                                                                                           {
   HASH_EXTEND(p, p, persistant_expression_to_effects_hash_table(f), k, (intptr_t)v);
 }

References f(), HASH_EXTEND, intptr_t, and persistant_expression_to_effects_hash_table.

Here is the call graph for this function:

◆ extend_statement_cell_relations()

void extend_statement_cell_relations	(	statement_cell_relations	f,
		statement	k,
		cell_relations	v
	)

Definition at line 956 of file effects.c.

                                                                                                 {
   HASH_EXTEND(p, p, statement_cell_relations_hash_table(f), k, (intptr_t)v);
 }

References f(), HASH_EXTEND, intptr_t, and statement_cell_relations_hash_table.

Here is the call graph for this function:

◆ extend_statement_effects()

void extend_statement_effects	(	statement_effects	f,
		statement	k,
		effects	v
	)

Definition at line 1013 of file effects.c.

                                                                            {
   HASH_EXTEND(p, p, statement_effects_hash_table(f), k, (intptr_t)v);
 }

References f(), HASH_EXTEND, intptr_t, and statement_effects_hash_table.

Here is the call graph for this function:

◆ free_action()

void free_action ( action p )

Definition at line 80 of file effects.c.

                            {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_action_kind()

void free_action_kind ( action_kind p )

Definition at line 21 of file effects.c.

                                      {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_approximation()

void free_approximation ( approximation p )

Definition at line 135 of file effects.c.

                                          {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_cell()

void free_cell ( cell p )

Definition at line 249 of file effects.c.

                        {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_cell_interpretation()

void free_cell_interpretation ( cell_interpretation p )

Definition at line 194 of file effects.c.

                                                      {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_cell_relation()

void free_cell_relation ( cell_relation p )

Definition at line 308 of file effects.c.

                                          {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_cell_relations()

void free_cell_relations ( cell_relations p )

Definition at line 350 of file effects.c.

                                            {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_descriptor()

void free_descriptor ( descriptor p )

Definition at line 392 of file effects.c.

                                    {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_effect()

void free_effect ( effect p )

Definition at line 451 of file effects.c.

                            {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_effects()

void free_effects ( effects p )

Definition at line 535 of file effects.c.

                              {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_effects_classes()

void free_effects_classes ( effects_classes p )

Definition at line 493 of file effects.c.

                                              {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_entity_effects()

void free_entity_effects ( entity_effects p )

Definition at line 577 of file effects.c.

                                            {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_gap()

void free_gap ( gap p )

Definition at line 634 of file effects.c.

                      {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_interpreted_cell()

void free_interpreted_cell ( interpreted_cell p )

Definition at line 676 of file effects.c.

                                                {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_path_selector()

void free_path_selector ( path_selector p )

Definition at line 718 of file effects.c.

                                          {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_path_selectors()

void free_path_selectors ( path_selectors p )

Definition at line 773 of file effects.c.

                                            {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_persistant_expression_to_effects()

void free_persistant_expression_to_effects ( persistant_expression_to_effects p )

Definition at line 815 of file effects.c.

                                                                                {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_recursive_selector()

void free_recursive_selector ( recursive_selector p )

Definition at line 872 of file effects.c.

                                                    {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_statement_cell_relations()

void free_statement_cell_relations ( statement_cell_relations p )

Definition at line 914 of file effects.c.

                                                                {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_statement_effects()

void free_statement_effects ( statement_effects p )

Definition at line 971 of file effects.c.

                                                  {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ gap_assign_contents()

void gap_assign_contents	(	gap	r,
		gap	v
	)

Definition at line 650 of file effects.c.

                                        {
   check_gap(r);
   check_gap(v);
   message_assert("defined references to domain gap",
                  gap_defined_p(r) && gap_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_gap_));
 }

References check_gap(), gap_defined_p(), and message_assert.

Here is the call graph for this function:

◆ gap_consistent_p()

bool gap_consistent_p ( gap p )

Definition at line 640 of file effects.c.

                              {
   check_gap(p);
   return gen_consistent_p((gen_chunk*) p);
 }

References check_gap(), and gen_consistent_p().

Here is the call graph for this function:

◆ gap_defined_p()

bool gap_defined_p ( gap p )

Definition at line 644 of file effects.c.

                           {
   return gen_defined_p((gen_chunk*) p);
 }

References gen_defined_p().

Here is the call graph for this function:

◆ gap_non_recursive_free()

void gap_non_recursive_free ( gap p )

Definition at line 657 of file effects.c.

                                    {
   // should clear up contents...
   free(p);
 }

References free().

Here is the call graph for this function:

◆ gen_action_cons()

list gen_action_cons	(	action	p,
		list	l
	)

Definition at line 93 of file effects.c.

                                        {
   return gen_typed_cons(ACTION_NEWGEN_DOMAIN, p, l);
 }

References ACTION_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_action_kind_cons()

list gen_action_kind_cons	(	action_kind	p,
		list	l
	)

Definition at line 34 of file effects.c.

                                                  {
   return gen_typed_cons(ACTION_KIND_NEWGEN_DOMAIN, p, l);
 }

References ACTION_KIND_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_approximation_cons()

list gen_approximation_cons	(	approximation	p,
		list	l
	)

Definition at line 148 of file effects.c.

                                                      {
   return gen_typed_cons(APPROXIMATION_NEWGEN_DOMAIN, p, l);
 }

References APPROXIMATION_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_cell_cons()

list gen_cell_cons	(	cell	p,
		list	l
	)

Definition at line 262 of file effects.c.

                                    {
   return gen_typed_cons(CELL_NEWGEN_DOMAIN, p, l);
 }

References CELL_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_cell_interpretation_cons()

list gen_cell_interpretation_cons	(	cell_interpretation	p,
		list	l
	)

Definition at line 207 of file effects.c.

                                                                  {
   return gen_typed_cons(CELL_INTERPRETATION_NEWGEN_DOMAIN, p, l);
 }

References CELL_INTERPRETATION_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_cell_relation_cons()

list gen_cell_relation_cons	(	cell_relation	p,
		list	l
	)

Definition at line 321 of file effects.c.

                                                      {
   return gen_typed_cons(CELL_RELATION_NEWGEN_DOMAIN, p, l);
 }

References CELL_RELATION_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_cell_relations_cons()

list gen_cell_relations_cons	(	cell_relations	p,
		list	l
	)

Definition at line 363 of file effects.c.

                                                        {
   return gen_typed_cons(CELL_RELATIONS_NEWGEN_DOMAIN, p, l);
 }

References CELL_RELATIONS_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_descriptor_cons()

list gen_descriptor_cons	(	descriptor	p,
		list	l
	)

Definition at line 405 of file effects.c.

                                                {
   return gen_typed_cons(DESCRIPTOR_NEWGEN_DOMAIN, p, l);
 }

References DESCRIPTOR_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_effect_cons()

list gen_effect_cons	(	effect	p,
		list	l
	)

Definition at line 464 of file effects.c.

                                        {
   return gen_typed_cons(EFFECT_NEWGEN_DOMAIN, p, l);
 }

References EFFECT_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_effects_classes_cons()

list gen_effects_classes_cons	(	effects_classes	p,
		list	l
	)

Definition at line 506 of file effects.c.

                                                          {
   return gen_typed_cons(EFFECTS_CLASSES_NEWGEN_DOMAIN, p, l);
 }

References EFFECTS_CLASSES_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_effects_cons()

list gen_effects_cons	(	effects	p,
		list	l
	)

Definition at line 548 of file effects.c.

                                          {
   return gen_typed_cons(EFFECTS_NEWGEN_DOMAIN, p, l);
 }

References EFFECTS_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_entity_effects_cons()

list gen_entity_effects_cons	(	entity_effects	p,
		list	l
	)

Definition at line 590 of file effects.c.

                                                        {
   return gen_typed_cons(ENTITY_EFFECTS_NEWGEN_DOMAIN, p, l);
 }

References ENTITY_EFFECTS_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_gap_cons()

list gen_gap_cons	(	gap	p,
		list	l
	)

Definition at line 647 of file effects.c.

                                  {
   return gen_typed_cons(GAP_NEWGEN_DOMAIN, p, l);
 }

References GAP_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_interpreted_cell_cons()

list gen_interpreted_cell_cons	(	interpreted_cell	p,
		list	l
	)

Definition at line 689 of file effects.c.

                                                            {
   return gen_typed_cons(INTERPRETED_CELL_NEWGEN_DOMAIN, p, l);
 }

References gen_typed_cons(), and INTERPRETED_CELL_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_path_selector_cons()

list gen_path_selector_cons	(	path_selector	p,
		list	l
	)

Definition at line 731 of file effects.c.

                                                      {
   return gen_typed_cons(PATH_SELECTOR_NEWGEN_DOMAIN, p, l);
 }

References gen_typed_cons(), and PATH_SELECTOR_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_path_selectors_cons()

list gen_path_selectors_cons	(	path_selectors	p,
		list	l
	)

Definition at line 786 of file effects.c.

                                                        {
   return gen_typed_cons(PATH_SELECTORS_NEWGEN_DOMAIN, p, l);
 }

References gen_typed_cons(), and PATH_SELECTORS_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_persistant_expression_to_effects_cons()

list gen_persistant_expression_to_effects_cons	(	persistant_expression_to_effects	p,
		list	l
	)

Definition at line 828 of file effects.c.

                                                                                            {
   return gen_typed_cons(PERSISTANT_EXPRESSION_TO_EFFECTS_NEWGEN_DOMAIN, p, l);
 }

References gen_typed_cons(), and PERSISTANT_EXPRESSION_TO_EFFECTS_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_recursive_selector_cons()

list gen_recursive_selector_cons	(	recursive_selector	p,
		list	l
	)

Definition at line 885 of file effects.c.

                                                                {
   return gen_typed_cons(RECURSIVE_SELECTOR_NEWGEN_DOMAIN, p, l);
 }

References gen_typed_cons(), and RECURSIVE_SELECTOR_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_statement_cell_relations_cons()

list gen_statement_cell_relations_cons	(	statement_cell_relations	p,
		list	l
	)

Definition at line 927 of file effects.c.

                                                                            {
   return gen_typed_cons(STATEMENT_CELL_RELATIONS_NEWGEN_DOMAIN, p, l);
 }

References gen_typed_cons(), and STATEMENT_CELL_RELATIONS_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_statement_effects_cons()

list gen_statement_effects_cons	(	statement_effects	p,
		list	l
	)

Definition at line 984 of file effects.c.

                                                              {
   return gen_typed_cons(STATEMENT_EFFECTS_NEWGEN_DOMAIN, p, l);
 }

References gen_typed_cons(), and STATEMENT_EFFECTS_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ interpreted_cell_assign_contents()

void interpreted_cell_assign_contents	(	interpreted_cell	r,
		interpreted_cell	v
	)

Definition at line 692 of file effects.c.

                                                                               {
   check_interpreted_cell(r);
   check_interpreted_cell(v);
   message_assert("defined references to domain interpreted_cell",
                  interpreted_cell_defined_p(r) && interpreted_cell_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_interpreted_cell_));
 }

References check_interpreted_cell(), interpreted_cell_defined_p(), and message_assert.

Here is the call graph for this function:

◆ interpreted_cell_consistent_p()

bool interpreted_cell_consistent_p ( interpreted_cell p )

Definition at line 682 of file effects.c.

                                                        {
   check_interpreted_cell(p);
   return gen_consistent_p((gen_chunk*) p);
 }

References check_interpreted_cell(), and gen_consistent_p().

Here is the call graph for this function:

◆ interpreted_cell_defined_p()

bool interpreted_cell_defined_p ( interpreted_cell p )

Definition at line 686 of file effects.c.

                                                     {
   return gen_defined_p((gen_chunk*) p);
 }

References gen_defined_p().

Here is the call graph for this function:

◆ interpreted_cell_non_recursive_free()

void interpreted_cell_non_recursive_free ( interpreted_cell p )

Definition at line 699 of file effects.c.

                                                              {
   // should clear up contents...
   free(p);
 }

References free().

Here is the call graph for this function:

◆ make_action()

action make_action	(	enum action_utype	tag,
		void *	val
	)

Definition at line 120 of file effects.c.

                                                       {
   return (action) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, action_domain, tag, val);
 }

References action_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_action_kind()

action_kind make_action_kind	(	enum action_kind_utype	tag,
		void *	val
	)

Definition at line 62 of file effects.c.

                                                                      {
   return (action_kind) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, action_kind_domain, tag, val);
 }

References action_kind_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_action_kind_environment()

action_kind make_action_kind_environment ( void )

Definition at line 68 of file effects.c.

                                                {
   return make_action_kind(is_action_kind_environment, UU);
 }

References is_action_kind_environment, make_action_kind(), and UU.

Here is the call graph for this function:

◆ make_action_kind_store()

action_kind make_action_kind_store ( void )

Definition at line 65 of file effects.c.

                                          {
   return make_action_kind(is_action_kind_store, UU);
 }

References is_action_kind_store, make_action_kind(), and UU.

Here is the call graph for this function:

◆ make_action_kind_type_declaration()

action_kind make_action_kind_type_declaration ( void )

Definition at line 71 of file effects.c.

                                                     {
   return make_action_kind(is_action_kind_type_declaration, UU);
 }

References is_action_kind_type_declaration, make_action_kind(), and UU.

Here is the call graph for this function:

◆ make_action_read()

action make_action_read ( action_kind _field_ )

Definition at line 123 of file effects.c.

                                              {
   return make_action(is_action_read, (void*)(intptr_t) _field_);
 }

References intptr_t, is_action_read, and make_action().

Here is the call graph for this function:

◆ make_action_write()

action make_action_write ( action_kind _field_ )

Definition at line 126 of file effects.c.

                                               {
   return make_action(is_action_write, (void*)(intptr_t) _field_);
 }

References intptr_t, is_action_write, and make_action().

Here is the call graph for this function:

◆ make_approximation()

approximation make_approximation	(	enum approximation_utype	tag,
		void *	val
	)

Definition at line 176 of file effects.c.

                                                                            {
   return (approximation) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, approximation_domain, tag, val);
 }

References approximation_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_approximation_exact()

approximation make_approximation_exact ( void )

Definition at line 185 of file effects.c.

                                              {
   return make_approximation(is_approximation_exact, UU);
 }

References is_approximation_exact, make_approximation(), and UU.

Here is the call graph for this function:

◆ make_approximation_may()

approximation make_approximation_may ( void )

Definition at line 179 of file effects.c.

                                            {
   return make_approximation(is_approximation_may, UU);
 }

References is_approximation_may, make_approximation(), and UU.

Here is the call graph for this function:

◆ make_approximation_must()

approximation make_approximation_must ( void )

Definition at line 182 of file effects.c.

                                             {
   return make_approximation(is_approximation_must, UU);
 }

References is_approximation_must, make_approximation(), and UU.

Here is the call graph for this function:

◆ make_cell()

cell make_cell	(	enum cell_utype	tag,
		void *	val
	)

Definition at line 290 of file effects.c.

                                                 {
   return (cell) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, cell_domain, tag, val);
 }

References cell_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_cell_gap()

cell make_cell_gap ( gap _field_ )

Definition at line 299 of file effects.c.

                                 {
   return make_cell(is_cell_gap, (void*)(intptr_t) _field_);
 }

References intptr_t, is_cell_gap, and make_cell().

Here is the call graph for this function:

◆ make_cell_interpretation()

cell_interpretation make_cell_interpretation	(	enum cell_interpretation_utype	tag,
		void *	val
	)

Definition at line 234 of file effects.c.

                                                                                              {
   return (cell_interpretation) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, cell_interpretation_domain, tag, val);
 }

References cell_interpretation_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_cell_interpretation_address_of()

cell_interpretation make_cell_interpretation_address_of ( void )

Definition at line 240 of file effects.c.

                                                               {
   return make_cell_interpretation(is_cell_interpretation_address_of, UU);
 }

References is_cell_interpretation_address_of, make_cell_interpretation(), and UU.

Here is the call graph for this function:

◆ make_cell_interpretation_value_of()

cell_interpretation make_cell_interpretation_value_of ( void )

Definition at line 237 of file effects.c.

                                                             {
   return make_cell_interpretation(is_cell_interpretation_value_of, UU);
 }

References is_cell_interpretation_value_of, make_cell_interpretation(), and UU.

Here is the call graph for this function:

◆ make_cell_preference()

cell make_cell_preference ( preference _field_ )

Definition at line 296 of file effects.c.

                                               {
   return make_cell(is_cell_preference, (void*)(intptr_t) _field_);
 }

References intptr_t, is_cell_preference, and make_cell().

Here is the call graph for this function:

◆ make_cell_reference()

cell make_cell_reference ( reference _field_ )

Definition at line 293 of file effects.c.

                                             {
   return make_cell(is_cell_reference, (void*)(intptr_t) _field_);
 }

References intptr_t, is_cell_reference, and make_cell().

Here is the call graph for this function:

◆ make_cell_relation()

cell_relation make_cell_relation	(	interpreted_cell	a1,
		interpreted_cell	a2,
		approximation	a3,
		descriptor	a4
	)

Definition at line 341 of file effects.c.

                                                                                                             {
   return (cell_relation) gen_alloc(5*sizeof(gen_chunk), GEN_CHECK_ALLOC, cell_relation_domain, a1, a2, a3, a4);
 }

References cell_relation_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_cell_relations()

cell_relations make_cell_relations ( list a )

Definition at line 383 of file effects.c.

                                            {
   return (cell_relations) gen_alloc(2*sizeof(gen_chunk), GEN_CHECK_ALLOC, cell_relations_domain, a);
 }

References cell_relations_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_descriptor()

descriptor make_descriptor	(	enum descriptor_utype	tag,
		void *	val
	)

Definition at line 433 of file effects.c.

                                                                   {
   return (descriptor) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, descriptor_domain, tag, val);
 }

References descriptor_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_descriptor_convex()

descriptor make_descriptor_convex ( Psysteme _field_ )

Definition at line 439 of file effects.c.

                                                     {
   return make_descriptor(is_descriptor_convex, (void*)(intptr_t) _field_);
 }

References intptr_t, is_descriptor_convex, and make_descriptor().

Here is the call graph for this function:

◆ make_descriptor_convexunion()

descriptor make_descriptor_convexunion ( list _field_ )

Definition at line 436 of file effects.c.

                                                      {
   return make_descriptor(is_descriptor_convexunion, (void*)(intptr_t) _field_);
 }

References intptr_t, is_descriptor_convexunion, and make_descriptor().

Here is the call graph for this function:

◆ make_descriptor_none()

descriptor make_descriptor_none ( void )

Definition at line 442 of file effects.c.

                                       {
   return make_descriptor(is_descriptor_none, UU);
 }

References is_descriptor_none, make_descriptor(), and UU.

Here is the call graph for this function:

◆ make_effect()

effect make_effect	(	cell	a1,
		action	a2,
		approximation	a3,
		descriptor	a4
	)

Definition at line 484 of file effects.c.

                                                                         {
   return (effect) gen_alloc(5*sizeof(gen_chunk), GEN_CHECK_ALLOC, effect_domain, a1, a2, a3, a4);
 }

References effect_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_effects()

effects make_effects ( list a )

Definition at line 568 of file effects.c.

                              {
   return (effects) gen_alloc(2*sizeof(gen_chunk), GEN_CHECK_ALLOC, effects_domain, a);
 }

References effects_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_effects_classes()

effects_classes make_effects_classes ( list a )

Definition at line 526 of file effects.c.

                                              {
   return (effects_classes) gen_alloc(2*sizeof(gen_chunk), GEN_CHECK_ALLOC, effects_classes_domain, a);
 }

References effects_classes_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_entity_effects()

entity_effects make_entity_effects ( void )

Definition at line 610 of file effects.c.

                                          {
   return (entity_effects) gen_alloc(2*sizeof(gen_chunk), GEN_CHECK_ALLOC, entity_effects_domain);
 }

References entity_effects_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_gap()

gap make_gap	(	entity	a1,
		path_selectors	a2
	)

Definition at line 667 of file effects.c.

                                            {
   return (gap) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, gap_domain, a1, a2);
 }

References gap_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_interpreted_cell()

interpreted_cell make_interpreted_cell	(	cell	a1,
		cell_interpretation	a2
	)

Definition at line 709 of file effects.c.

                                                                         {
   return (interpreted_cell) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, interpreted_cell_domain, a1, a2);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and interpreted_cell_domain.

Here is the call graph for this function:

◆ make_path_selector()

path_selector make_path_selector	(	enum path_selector_utype	tag,
		void *	val
	)

Definition at line 758 of file effects.c.

                                                                            {
   return (path_selector) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, path_selector_domain, tag, val);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and path_selector_domain.

Here is the call graph for this function:

◆ make_path_selector_expression()

path_selector make_path_selector_expression ( expression _field_ )

Definition at line 761 of file effects.c.

                                                                 {
   return make_path_selector(is_path_selector_expression, (void*)(intptr_t) _field_);
 }

References intptr_t, is_path_selector_expression, and make_path_selector().

Here is the call graph for this function:

◆ make_path_selector_recursive_selector()

path_selector make_path_selector_recursive_selector ( recursive_selector _field_ )

Definition at line 764 of file effects.c.

                                                                                 {
   return make_path_selector(is_path_selector_recursive_selector, (void*)(intptr_t) _field_);
 }

References intptr_t, is_path_selector_recursive_selector, and make_path_selector().

Here is the call graph for this function:

◆ make_path_selectors()

path_selectors make_path_selectors ( list a )

Definition at line 806 of file effects.c.

                                            {
   return (path_selectors) gen_alloc(2*sizeof(gen_chunk), GEN_CHECK_ALLOC, path_selectors_domain, a);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and path_selectors_domain.

Here is the call graph for this function:

◆ make_persistant_expression_to_effects()

persistant_expression_to_effects make_persistant_expression_to_effects ( void )

Definition at line 848 of file effects.c.

                                                                              {
   return (persistant_expression_to_effects) gen_alloc(2*sizeof(gen_chunk), GEN_CHECK_ALLOC, persistant_expression_to_effects_domain);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and persistant_expression_to_effects_domain.

Here is the call graph for this function:

◆ make_recursive_selector()

recursive_selector make_recursive_selector	(	list	a1,
		expression	a2
	)

Definition at line 905 of file effects.c.

                                                                    {
   return (recursive_selector) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, recursive_selector_domain, a1, a2);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and recursive_selector_domain.

Here is the call graph for this function:

◆ make_statement_cell_relations()

statement_cell_relations make_statement_cell_relations ( void )

Definition at line 947 of file effects.c.

                                                              {
   return (statement_cell_relations) gen_alloc(2*sizeof(gen_chunk), GEN_CHECK_ALLOC, statement_cell_relations_domain);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and statement_cell_relations_domain.

Here is the call graph for this function:

◆ make_statement_effects()

statement_effects make_statement_effects ( void )

Definition at line 1004 of file effects.c.

                                                {
   return (statement_effects) gen_alloc(2*sizeof(gen_chunk), GEN_CHECK_ALLOC, statement_effects_domain);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and statement_effects_domain.

Here is the call graph for this function:

◆ path_selector_assign_contents()

void path_selector_assign_contents	(	path_selector	r,
		path_selector	v
	)

Definition at line 734 of file effects.c.

                                                                      {
   check_path_selector(r);
   check_path_selector(v);
   message_assert("defined references to domain path_selector",
                  path_selector_defined_p(r) && path_selector_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_path_selector_));
 }

References check_path_selector(), message_assert, and path_selector_defined_p().

Here is the call graph for this function:

◆ path_selector_consistent_p()

bool path_selector_consistent_p ( path_selector p )

Definition at line 724 of file effects.c.

                                                  {
   check_path_selector(p);
   return gen_consistent_p((gen_chunk*) p);
 }

References check_path_selector(), and gen_consistent_p().

Here is the call graph for this function:

◆ path_selector_defined_p()

bool path_selector_defined_p ( path_selector p )

Definition at line 728 of file effects.c.

                                               {
   return gen_defined_p((gen_chunk*) p);
 }

References gen_defined_p().

Here is the call graph for this function:

◆ path_selector_non_recursive_free()

void path_selector_non_recursive_free ( path_selector p )

Definition at line 741 of file effects.c.

                                                        {
   // should clear up contents...
   free(p);
 }

References free().

Here is the call graph for this function:

◆ path_selector_tag_as_string()

string path_selector_tag_as_string ( enum path_selector_utype tag )

Definition at line 751 of file effects.c.

                                                                  {
   switch (tag) {
   case is_path_selector_expression: return "expression";
   case is_path_selector_recursive_selector: return "recursive_selector";
   default: return string_undefined;
   }
 }

References is_path_selector_expression, is_path_selector_recursive_selector, and string_undefined.

◆ path_selectors_assign_contents()

void path_selectors_assign_contents	(	path_selectors	r,
		path_selectors	v
	)

Definition at line 789 of file effects.c.

                                                                         {
   check_path_selectors(r);
   check_path_selectors(v);
   message_assert("defined references to domain path_selectors",
                  path_selectors_defined_p(r) && path_selectors_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_path_selectors_));
 }

References check_path_selectors(), message_assert, and path_selectors_defined_p().

Here is the call graph for this function:

◆ path_selectors_consistent_p()

bool path_selectors_consistent_p ( path_selectors p )

Definition at line 779 of file effects.c.

                                                    {
   check_path_selectors(p);
   return gen_consistent_p((gen_chunk*) p);
 }

References check_path_selectors(), and gen_consistent_p().

Here is the call graph for this function:

◆ path_selectors_defined_p()

bool path_selectors_defined_p ( path_selectors p )

Definition at line 783 of file effects.c.

                                                 {
   return gen_defined_p((gen_chunk*) p);
 }

References gen_defined_p().

Here is the call graph for this function:

◆ path_selectors_non_recursive_free()

void path_selectors_non_recursive_free ( path_selectors p )

Definition at line 796 of file effects.c.

                                                          {
   // should clear up contents...
   free(p);
 }

References free().

Here is the call graph for this function:

◆ persistant_expression_to_effects_assign_contents()

void persistant_expression_to_effects_assign_contents	(	persistant_expression_to_effects	r,
		persistant_expression_to_effects	v
	)

Definition at line 831 of file effects.c.

                                                                                                                               {
   check_persistant_expression_to_effects(r);
   check_persistant_expression_to_effects(v);
   message_assert("defined references to domain persistant_expression_to_effects",
                  persistant_expression_to_effects_defined_p(r) && persistant_expression_to_effects_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_persistant_expression_to_effects_));
 }

References check_persistant_expression_to_effects(), message_assert, and persistant_expression_to_effects_defined_p().

Here is the call graph for this function:

◆ persistant_expression_to_effects_consistent_p()

bool persistant_expression_to_effects_consistent_p ( persistant_expression_to_effects p )

Definition at line 821 of file effects.c.

                                                                                        {
   check_persistant_expression_to_effects(p);
   return gen_consistent_p((gen_chunk*) p);
 }

References check_persistant_expression_to_effects(), and gen_consistent_p().

Here is the call graph for this function:

◆ persistant_expression_to_effects_defined_p()

bool persistant_expression_to_effects_defined_p ( persistant_expression_to_effects p )

Definition at line 825 of file effects.c.

                                                                                     {
   return gen_defined_p((gen_chunk*) p);
 }

References gen_defined_p().

Here is the call graph for this function:

◆ persistant_expression_to_effects_non_recursive_free()

void persistant_expression_to_effects_non_recursive_free ( persistant_expression_to_effects p )

Definition at line 838 of file effects.c.

                                                                                              {
   // should clear up contents...
   free(p);
 }

References free().

Here is the call graph for this function:

◆ read_action()

action read_action ( FILE * f )

Definition at line 110 of file effects.c.

                             {
   return (action) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_action_kind()

action_kind read_action_kind ( FILE * f )

Definition at line 51 of file effects.c.

                                       {
   return (action_kind) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_approximation()

approximation read_approximation ( FILE * f )

Definition at line 165 of file effects.c.

                                           {
   return (approximation) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_cell()

cell read_cell ( FILE * f )

Definition at line 279 of file effects.c.

                         {
   return (cell) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_cell_interpretation()

cell_interpretation read_cell_interpretation ( FILE * f )

Definition at line 224 of file effects.c.

                                                       {
   return (cell_interpretation) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_cell_relation()

cell_relation read_cell_relation ( FILE * f )

Definition at line 338 of file effects.c.

                                           {
   return (cell_relation) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_cell_relations()

cell_relations read_cell_relations ( FILE * f )

Definition at line 380 of file effects.c.

                                             {
   return (cell_relations) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_descriptor()

descriptor read_descriptor ( FILE * f )

Definition at line 422 of file effects.c.

                                     {
   return (descriptor) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_effect()

effect read_effect ( FILE * f )

Definition at line 481 of file effects.c.

                             {
   return (effect) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_effects()

effects read_effects ( FILE * f )

Definition at line 565 of file effects.c.

                               {
   return (effects) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_effects_classes()

effects_classes read_effects_classes ( FILE * f )

Definition at line 523 of file effects.c.

                                               {
   return (effects_classes) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_entity_effects()

entity_effects read_entity_effects ( FILE * f )

Definition at line 607 of file effects.c.

                                             {
   return (entity_effects) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_gap()

gap read_gap ( FILE * f )

Definition at line 664 of file effects.c.

                       {
   return (gap) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_interpreted_cell()

interpreted_cell read_interpreted_cell ( FILE * f )

Definition at line 706 of file effects.c.

                                                 {
   return (interpreted_cell) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_path_selector()

path_selector read_path_selector ( FILE * f )

Definition at line 748 of file effects.c.

                                           {
   return (path_selector) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_path_selectors()

path_selectors read_path_selectors ( FILE * f )

Definition at line 803 of file effects.c.

                                             {
   return (path_selectors) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_persistant_expression_to_effects()

persistant_expression_to_effects read_persistant_expression_to_effects ( FILE * f )

Definition at line 845 of file effects.c.

                                                                                 {
   return (persistant_expression_to_effects) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_recursive_selector()

recursive_selector read_recursive_selector ( FILE * f )

Definition at line 902 of file effects.c.

                                                     {
   return (recursive_selector) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_statement_cell_relations()

statement_cell_relations read_statement_cell_relations ( FILE * f )

Definition at line 944 of file effects.c.

                                                                 {
   return (statement_cell_relations) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_statement_effects()

statement_effects read_statement_effects ( FILE * f )

Definition at line 1001 of file effects.c.

                                                   {
   return (statement_effects) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ recursive_selector_assign_contents()

void recursive_selector_assign_contents	(	recursive_selector	r,
		recursive_selector	v
	)

Definition at line 888 of file effects.c.

                                                                                     {
   check_recursive_selector(r);
   check_recursive_selector(v);
   message_assert("defined references to domain recursive_selector",
                  recursive_selector_defined_p(r) && recursive_selector_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_recursive_selector_));
 }

References check_recursive_selector(), message_assert, and recursive_selector_defined_p().

Here is the call graph for this function:

◆ recursive_selector_consistent_p()

bool recursive_selector_consistent_p ( recursive_selector p )

Definition at line 878 of file effects.c.

                                                            {
   check_recursive_selector(p);
   return gen_consistent_p((gen_chunk*) p);
 }

References check_recursive_selector(), and gen_consistent_p().

Here is the call graph for this function:

◆ recursive_selector_defined_p()

bool recursive_selector_defined_p ( recursive_selector p )

Definition at line 882 of file effects.c.

                                                         {
   return gen_defined_p((gen_chunk*) p);
 }

References gen_defined_p().

Here is the call graph for this function:

◆ recursive_selector_non_recursive_free()

void recursive_selector_non_recursive_free ( recursive_selector p )

Definition at line 895 of file effects.c.

                                                                  {
   // should clear up contents...
   free(p);
 }

References free().

Here is the call graph for this function:

◆ statement_cell_relations_assign_contents()

void statement_cell_relations_assign_contents	(	statement_cell_relations	r,
		statement_cell_relations	v
	)

Definition at line 930 of file effects.c.

                                                                                                       {
   check_statement_cell_relations(r);
   check_statement_cell_relations(v);
   message_assert("defined references to domain statement_cell_relations",
                  statement_cell_relations_defined_p(r) && statement_cell_relations_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_statement_cell_relations_));
 }

References check_statement_cell_relations(), message_assert, and statement_cell_relations_defined_p().

Here is the call graph for this function:

◆ statement_cell_relations_consistent_p()

bool statement_cell_relations_consistent_p ( statement_cell_relations p )

Definition at line 920 of file effects.c.

                                                                        {
   check_statement_cell_relations(p);
   return gen_consistent_p((gen_chunk*) p);
 }

References check_statement_cell_relations(), and gen_consistent_p().

Here is the call graph for this function:

◆ statement_cell_relations_defined_p()

bool statement_cell_relations_defined_p ( statement_cell_relations p )

Definition at line 924 of file effects.c.

                                                                     {
   return gen_defined_p((gen_chunk*) p);
 }

References gen_defined_p().

Here is the call graph for this function:

◆ statement_cell_relations_non_recursive_free()

void statement_cell_relations_non_recursive_free ( statement_cell_relations p )

Definition at line 937 of file effects.c.

                                                                              {
   // should clear up contents...
   free(p);
 }

References free().

Here is the call graph for this function:

◆ statement_effects_assign_contents()

void statement_effects_assign_contents	(	statement_effects	r,
		statement_effects	v
	)

Definition at line 987 of file effects.c.

                                                                                  {
   check_statement_effects(r);
   check_statement_effects(v);
   message_assert("defined references to domain statement_effects",
                  statement_effects_defined_p(r) && statement_effects_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_statement_effects_));
 }

References check_statement_effects(), message_assert, and statement_effects_defined_p().

Here is the call graph for this function:

◆ statement_effects_consistent_p()

bool statement_effects_consistent_p ( statement_effects p )

Definition at line 977 of file effects.c.

                                                          {
   check_statement_effects(p);
   return gen_consistent_p((gen_chunk*) p);
 }

References check_statement_effects(), and gen_consistent_p().

Here is the call graph for this function:

◆ statement_effects_defined_p()

bool statement_effects_defined_p ( statement_effects p )

Definition at line 981 of file effects.c.

                                                       {
   return gen_defined_p((gen_chunk*) p);
 }

References gen_defined_p().

Here is the call graph for this function:

◆ statement_effects_non_recursive_free()

void statement_effects_non_recursive_free ( statement_effects p )

Definition at line 994 of file effects.c.

                                                                {
   // should clear up contents...
   free(p);
 }

References free().

Here is the call graph for this function:

◆ update_entity_effects()

void update_entity_effects	(	entity_effects	f,
		entity	k,
		effects	v
	)

Definition at line 616 of file effects.c.

                                                                   {
   HASH_UPDATE(p, p, entity_effects_hash_table(f), k, (intptr_t)v);
 }

References entity_effects_hash_table, f(), HASH_UPDATE, and intptr_t.

Here is the call graph for this function:

◆ update_persistant_expression_to_effects()

void update_persistant_expression_to_effects	(	persistant_expression_to_effects	f,
		expression	k,
		effects	v
	)

Definition at line 854 of file effects.c.

                                                                                                           {
   HASH_UPDATE(p, p, persistant_expression_to_effects_hash_table(f), k, (intptr_t)v);
 }

References f(), HASH_UPDATE, intptr_t, and persistant_expression_to_effects_hash_table.

Here is the call graph for this function:

◆ update_statement_cell_relations()

void update_statement_cell_relations	(	statement_cell_relations	f,
		statement	k,
		cell_relations	v
	)

Definition at line 953 of file effects.c.

                                                                                                 {
   HASH_UPDATE(p, p, statement_cell_relations_hash_table(f), k, (intptr_t)v);
 }

References f(), HASH_UPDATE, intptr_t, and statement_cell_relations_hash_table.

Here is the call graph for this function:

◆ update_statement_effects()

void update_statement_effects	(	statement_effects	f,
		statement	k,
		effects	v
	)

Definition at line 1010 of file effects.c.

                                                                            {
   HASH_UPDATE(p, p, statement_effects_hash_table(f), k, (intptr_t)v);
 }

References f(), HASH_UPDATE, intptr_t, and statement_effects_hash_table.

Here is the call graph for this function:

◆ write_action()

void write_action	(	FILE *	f,
		action	p
	)

Definition at line 107 of file effects.c.

                                      {
   gen_write(f, (gen_chunk*) p);
 }

References f(), and gen_write().

Here is the call graph for this function:

◆ write_action_kind()

void write_action_kind	(	FILE *	f,
		action_kind	p
	)

Definition at line 48 of file effects.c.

                                                {
   gen_write(f, (gen_chunk*) p);
 }

References f(), and gen_write().

Here is the call graph for this function:

◆ write_approximation()

void write_approximation	(	FILE *	f,
		approximation	p
	)

Definition at line 162 of file effects.c.

                                                    {
   gen_write(f, (gen_chunk*) p);
 }

References f(), and gen_write().

Here is the call graph for this function:

◆ write_cell()

void write_cell	(	FILE *	f,
		cell	p
	)

Definition at line 276 of file effects.c.

                                  {
   gen_write(f, (gen_chunk*) p);
 }

References f(), and gen_write().

Here is the call graph for this function:

◆ write_cell_interpretation()

void write_cell_interpretation	(	FILE *	f,
		cell_interpretation	p
	)

Definition at line 221 of file effects.c.

                                                                {
   gen_write(f, (gen_chunk*) p);
 }

References f(), and gen_write().

Here is the call graph for this function:

◆ write_cell_relation()

void write_cell_relation	(	FILE *	f,
		cell_relation	p
	)

Definition at line 335 of file effects.c.

                                                    {
   gen_write(f, (gen_chunk*) p);
 }

References f(), and gen_write().

Here is the call graph for this function:

◆ write_cell_relations()

void write_cell_relations	(	FILE *	f,
		cell_relations	p
	)

Definition at line 377 of file effects.c.

                                                      {
   gen_write(f, (gen_chunk*) p);
 }

References f(), and gen_write().

Here is the call graph for this function:

◆ write_descriptor()

void write_descriptor	(	FILE *	f,
		descriptor	p
	)

Definition at line 419 of file effects.c.

                                              {
   gen_write(f, (gen_chunk*) p);
 }

References f(), and gen_write().

Here is the call graph for this function:

◆ write_effect()

void write_effect	(	FILE *	f,
		effect	p
	)

Definition at line 478 of file effects.c.

                                      {
   gen_write(f, (gen_chunk*) p);
 }

References f(), and gen_write().

Here is the call graph for this function:

◆ write_effects()

void write_effects	(	FILE *	f,
		effects	p
	)

Definition at line 562 of file effects.c.

                                        {
   gen_write(f, (gen_chunk*) p);
 }

References f(), and gen_write().

Here is the call graph for this function:

◆ write_effects_classes()

void write_effects_classes	(	FILE *	f,
		effects_classes	p
	)

Definition at line 520 of file effects.c.

                                                        {
   gen_write(f, (gen_chunk*) p);
 }

References f(), and gen_write().

Here is the call graph for this function:

◆ write_entity_effects()

void write_entity_effects	(	FILE *	f,
		entity_effects	p
	)

Definition at line 604 of file effects.c.

                                                      {
   gen_write(f, (gen_chunk*) p);
 }

References f(), and gen_write().

Here is the call graph for this function:

◆ write_gap()

void write_gap	(	FILE *	f,
		gap	p
	)

Definition at line 661 of file effects.c.

                                {
   gen_write(f, (gen_chunk*) p);
 }

References f(), and gen_write().

Here is the call graph for this function:

◆ write_interpreted_cell()

void write_interpreted_cell	(	FILE *	f,
		interpreted_cell	p
	)

Definition at line 703 of file effects.c.

                                                          {
   gen_write(f, (gen_chunk*) p);
 }

References f(), and gen_write().

Here is the call graph for this function:

◆ write_path_selector()

void write_path_selector	(	FILE *	f,
		path_selector	p
	)

Definition at line 745 of file effects.c.

                                                    {
   gen_write(f, (gen_chunk*) p);
 }

References f(), and gen_write().

Here is the call graph for this function:

◆ write_path_selectors()

void write_path_selectors	(	FILE *	f,
		path_selectors	p
	)

Definition at line 800 of file effects.c.

                                                      {
   gen_write(f, (gen_chunk*) p);
 }

References f(), and gen_write().

Here is the call graph for this function:

◆ write_persistant_expression_to_effects()

void write_persistant_expression_to_effects	(	FILE *	f,
		persistant_expression_to_effects	p
	)

Definition at line 842 of file effects.c.

                                                                                          {
   gen_write(f, (gen_chunk*) p);
 }

References f(), and gen_write().

Here is the call graph for this function:

◆ write_recursive_selector()

void write_recursive_selector	(	FILE *	f,
		recursive_selector	p
	)

Definition at line 899 of file effects.c.

                                                              {
   gen_write(f, (gen_chunk*) p);
 }

References f(), and gen_write().

Here is the call graph for this function:

◆ write_statement_cell_relations()

void write_statement_cell_relations	(	FILE *	f,
		statement_cell_relations	p
	)

Definition at line 941 of file effects.c.

                                                                          {
   gen_write(f, (gen_chunk*) p);
 }

References f(), and gen_write().

Here is the call graph for this function:

◆ write_statement_effects()

void write_statement_effects	(	FILE *	f,
		statement_effects	p
	)

Definition at line 998 of file effects.c.

                                                            {
   gen_write(f, (gen_chunk*) p);
 }

References f(), and gen_write().

Here is the call graph for this function:

Typedefs

Functions

Typedef Documentation

◆ Psysteme

Function Documentation

◆ action_assign_contents()

◆ action_consistent_p()

◆ action_defined_p()

◆ action_kind_assign_contents()

◆ action_kind_consistent_p()

◆ action_kind_defined_p()

◆ action_kind_non_recursive_free()

◆ action_kind_tag_as_string()

◆ action_non_recursive_free()

◆ action_tag_as_string()

◆ apply_entity_effects()

◆ apply_persistant_expression_to_effects()

◆ apply_statement_cell_relations()

◆ apply_statement_effects()

◆ approximation_assign_contents()

◆ approximation_consistent_p()

◆ approximation_defined_p()

◆ approximation_non_recursive_free()

◆ approximation_tag_as_string()

◆ bound_entity_effects_p()

◆ bound_persistant_expression_to_effects_p()

◆ bound_statement_cell_relations_p()

◆ bound_statement_effects_p()

◆ cell_assign_contents()

◆ cell_consistent_p()

◆ cell_defined_p()

◆ cell_interpretation_assign_contents()

◆ cell_interpretation_consistent_p()

◆ cell_interpretation_defined_p()

◆ cell_interpretation_non_recursive_free()

◆ cell_interpretation_tag_as_string()

◆ cell_non_recursive_free()

◆ cell_relation_assign_contents()

◆ cell_relation_consistent_p()

◆ cell_relation_defined_p()

◆ cell_relation_non_recursive_free()

◆ cell_relations_assign_contents()

◆ cell_relations_consistent_p()

◆ cell_relations_defined_p()

◆ cell_relations_non_recursive_free()

◆ cell_tag_as_string()

◆ check_action()

◆ check_action_kind()

◆ check_approximation()

◆ check_cell()

◆ check_cell_interpretation()

◆ check_cell_relation()

◆ check_cell_relations()

◆ check_descriptor()

◆ check_effect()

◆ check_effects()

◆ check_effects_classes()

◆ check_entity_effects()

◆ check_gap()

◆ check_interpreted_cell()

◆ check_path_selector()

◆ check_path_selectors()

◆ check_persistant_expression_to_effects()

◆ check_recursive_selector()

◆ check_statement_cell_relations()

◆ check_statement_effects()

◆ copy_action()

◆ copy_action_kind()

◆ copy_approximation()

◆ copy_cell()

◆ copy_cell_interpretation()

◆ copy_cell_relation()

◆ copy_cell_relations()

◆ copy_descriptor()

◆ copy_effect()

◆ copy_effects()

◆ copy_effects_classes()

◆ copy_entity_effects()

◆ copy_gap()

◆ copy_interpreted_cell()