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

Include dependency graph for ri.c:

Typedefs
typedef void *	Pvecteur

typedef void *	Psysteme

Functions
application	copy_application (application p)
	APPLICATION. More...

void	free_application (application p)

application	check_application (application p)

bool	application_consistent_p (application p)

bool	application_defined_p (application p)

list	gen_application_cons (application p, list l)

void	application_assign_contents (application r, application v)

void	application_non_recursive_free (application p)

void	write_application (FILE *f, application p)

application	read_application (FILE *f)

application	make_application (expression a1, list a2)

area	copy_area (area p)
	AREA. More...

void	free_area (area p)

area	check_area (area p)

bool	area_consistent_p (area p)

bool	area_defined_p (area p)

list	gen_area_cons (area p, list l)

void	area_assign_contents (area r, area v)

void	area_non_recursive_free (area p)

void	write_area (FILE *f, area p)

area	read_area (FILE *f)

area	make_area (intptr_t a1, list a2)

basic	copy_basic (basic p)
	BASIC. More...

void	free_basic (basic p)

basic	check_basic (basic p)

bool	basic_consistent_p (basic p)

bool	basic_defined_p (basic p)

list	gen_basic_cons (basic p, list l)

void	basic_assign_contents (basic r, basic v)

void	basic_non_recursive_free (basic p)

void	write_basic (FILE *f, basic p)

basic	read_basic (FILE *f)

string	basic_tag_as_string (enum basic_utype tag)

basic	make_basic (enum basic_utype tag, void *val)

basic	make_basic_int (intptr_t _field_)

basic	make_basic_float (intptr_t _field_)

basic	make_basic_logical (intptr_t _field_)

basic	make_basic_overloaded (void)

basic	make_basic_complex (intptr_t _field_)

basic	make_basic_string (value _field_)

basic	make_basic_bit (symbolic _field_)

basic	make_basic_pointer (type _field_)

basic	make_basic_derived (entity _field_)

basic	make_basic_typedef (entity _field_)

callees	copy_callees (callees p)
	CALLEES. More...

void	free_callees (callees p)

callees	check_callees (callees p)

bool	callees_consistent_p (callees p)

bool	callees_defined_p (callees p)

list	gen_callees_cons (callees p, list l)

void	callees_assign_contents (callees r, callees v)

void	callees_non_recursive_free (callees p)

void	write_callees (FILE *f, callees p)

callees	read_callees (FILE *f)

callees	make_callees (list a)

call	copy_call (call p)
	CALL. More...

void	free_call (call p)

call	check_call (call p)

bool	call_consistent_p (call p)

bool	call_defined_p (call p)

list	gen_call_cons (call p, list l)

void	call_assign_contents (call r, call v)

void	call_non_recursive_free (call p)

void	write_call (FILE *f, call p)

call	read_call (FILE *f)

call	make_call (entity a1, list a2)

cast	copy_cast (cast p)
	CAST. More...

void	free_cast (cast p)

cast	check_cast (cast p)

bool	cast_consistent_p (cast p)

bool	cast_defined_p (cast p)

list	gen_cast_cons (cast p, list l)

void	cast_assign_contents (cast r, cast v)

void	cast_non_recursive_free (cast p)

void	write_cast (FILE *f, cast p)

cast	read_cast (FILE *f)

cast	make_cast (type a1, expression a2)

code	copy_code (code p)
	CODE. More...

void	free_code (code p)

code	check_code (code p)

bool	code_consistent_p (code p)

bool	code_defined_p (code p)

list	gen_code_cons (code p, list l)

void	code_assign_contents (code r, code v)

void	code_non_recursive_free (code p)

void	write_code (FILE *f, code p)

code	read_code (FILE *f)

code	make_code (list a1, string a2, sequence a3, list a4, language a5)

constant	copy_constant (constant p)
	CONSTANT. More...

void	free_constant (constant p)

constant	check_constant (constant p)

bool	constant_consistent_p (constant p)

bool	constant_defined_p (constant p)

list	gen_constant_cons (constant p, list l)

void	constant_assign_contents (constant r, constant v)

void	constant_non_recursive_free (constant p)

void	write_constant (FILE *f, constant p)

constant	read_constant (FILE *f)

string	constant_tag_as_string (enum constant_utype tag)

constant	make_constant (enum constant_utype tag, void *val)

constant	make_constant_int (intptr_t _field_)

constant	make_constant_float (float _field_)

constant	make_constant_logical (intptr_t _field_)

constant	make_constant_litteral (void)

constant	make_constant_call (entity _field_)

constant	make_constant_unknown (void)

controlmap	copy_controlmap (controlmap p)
	CONTROLMAP. More...

void	free_controlmap (controlmap p)

controlmap	check_controlmap (controlmap p)

bool	controlmap_consistent_p (controlmap p)

bool	controlmap_defined_p (controlmap p)

list	gen_controlmap_cons (controlmap p, list l)

void	controlmap_assign_contents (controlmap r, controlmap v)

void	controlmap_non_recursive_free (controlmap p)

void	write_controlmap (FILE *f, controlmap p)

controlmap	read_controlmap (FILE *f)

controlmap	make_controlmap (void)

control	apply_controlmap (controlmap f, statement k)

void	update_controlmap (controlmap f, statement k, control v)

void	extend_controlmap (controlmap f, statement k, control v)

control	delete_controlmap (controlmap f, statement k)

bool	bound_controlmap_p (controlmap f, statement k)

control	copy_control (control p)
	CONTROL. More...

void	free_control (control p)

control	check_control (control p)

bool	control_consistent_p (control p)

bool	control_defined_p (control p)

list	gen_control_cons (control p, list l)

void	control_assign_contents (control r, control v)

void	control_non_recursive_free (control p)

void	write_control (FILE *f, control p)

control	read_control (FILE *f)

control	make_control (statement a1, list a2, list a3)

dimension	copy_dimension (dimension p)
	DIMENSION. More...

void	free_dimension (dimension p)

dimension	check_dimension (dimension p)

bool	dimension_consistent_p (dimension p)

bool	dimension_defined_p (dimension p)

list	gen_dimension_cons (dimension p, list l)

void	dimension_assign_contents (dimension r, dimension v)

void	dimension_non_recursive_free (dimension p)

void	write_dimension (FILE *f, dimension p)

dimension	read_dimension (FILE *f)

dimension	make_dimension (expression a1, expression a2, list a3)

dummy	copy_dummy (dummy p)
	DUMMY. More...

void	free_dummy (dummy p)

dummy	check_dummy (dummy p)

bool	dummy_consistent_p (dummy p)

bool	dummy_defined_p (dummy p)

list	gen_dummy_cons (dummy p, list l)

void	dummy_assign_contents (dummy r, dummy v)

void	dummy_non_recursive_free (dummy p)

void	write_dummy (FILE *f, dummy p)

dummy	read_dummy (FILE *f)

string	dummy_tag_as_string (enum dummy_utype tag)

dummy	make_dummy (enum dummy_utype tag, void *val)

dummy	make_dummy_unknown (void)

dummy	make_dummy_identifier (entity _field_)

entity_int	copy_entity_int (entity_int p)
	ENTITY_INT. More...

void	free_entity_int (entity_int p)

entity_int	check_entity_int (entity_int p)

bool	entity_int_consistent_p (entity_int p)

bool	entity_int_defined_p (entity_int p)

list	gen_entity_int_cons (entity_int p, list l)

void	entity_int_assign_contents (entity_int r, entity_int v)

void	entity_int_non_recursive_free (entity_int p)

void	write_entity_int (FILE *f, entity_int p)

entity_int	read_entity_int (FILE *f)

entity_int	make_entity_int (void)

intptr_t	apply_entity_int (entity_int f, entity k)

void	update_entity_int (entity_int f, entity k, intptr_t v)

void	extend_entity_int (entity_int f, entity k, intptr_t v)

intptr_t	delete_entity_int (entity_int f, entity k)

bool	bound_entity_int_p (entity_int f, entity k)

entity_to_entity	copy_entity_to_entity (entity_to_entity p)
	ENTITY_TO_ENTITY. More...

void	free_entity_to_entity (entity_to_entity p)

entity_to_entity	check_entity_to_entity (entity_to_entity p)

bool	entity_to_entity_consistent_p (entity_to_entity p)

bool	entity_to_entity_defined_p (entity_to_entity p)

list	gen_entity_to_entity_cons (entity_to_entity p, list l)

void	entity_to_entity_assign_contents (entity_to_entity r, entity_to_entity v)

void	entity_to_entity_non_recursive_free (entity_to_entity p)

void	write_entity_to_entity (FILE *f, entity_to_entity p)

entity_to_entity	read_entity_to_entity (FILE *f)

entity_to_entity	make_entity_to_entity (void)

entity	apply_entity_to_entity (entity_to_entity f, entity k)

void	update_entity_to_entity (entity_to_entity f, entity k, entity v)

void	extend_entity_to_entity (entity_to_entity f, entity k, entity v)

entity	delete_entity_to_entity (entity_to_entity f, entity k)

bool	bound_entity_to_entity_p (entity_to_entity f, entity k)

evaluation	copy_evaluation (evaluation p)
	EVALUATION. More...

void	free_evaluation (evaluation p)

evaluation	check_evaluation (evaluation p)

bool	evaluation_consistent_p (evaluation p)

bool	evaluation_defined_p (evaluation p)

list	gen_evaluation_cons (evaluation p, list l)

void	evaluation_assign_contents (evaluation r, evaluation v)

void	evaluation_non_recursive_free (evaluation p)

void	write_evaluation (FILE *f, evaluation p)

evaluation	read_evaluation (FILE *f)

string	evaluation_tag_as_string (enum evaluation_utype tag)

evaluation	make_evaluation (enum evaluation_utype tag, void *val)

evaluation	make_evaluation_before (void)

evaluation	make_evaluation_after (void)

execution	copy_execution (execution p)
	EXECUTION. More...

void	free_execution (execution p)

execution	check_execution (execution p)

bool	execution_consistent_p (execution p)

bool	execution_defined_p (execution p)

list	gen_execution_cons (execution p, list l)

void	execution_assign_contents (execution r, execution v)

void	execution_non_recursive_free (execution p)

void	write_execution (FILE *f, execution p)

execution	read_execution (FILE *f)

string	execution_tag_as_string (enum execution_utype tag)

execution	make_execution (enum execution_utype tag, void *val)

execution	make_execution_sequential (void)

execution	make_execution_parallel (void)

expression	copy_expression (expression p)
	EXPRESSION. More...

void	free_expression (expression p)

expression	check_expression (expression p)

bool	expression_consistent_p (expression p)

bool	expression_defined_p (expression p)

list	gen_expression_cons (expression p, list l)

void	expression_assign_contents (expression r, expression v)

void	expression_non_recursive_free (expression p)

void	write_expression (FILE *f, expression p)

expression	read_expression (FILE *f)

expression	make_expression (syntax a1, normalized a2)

extension	copy_extension (extension p)
	EXTENSION. More...

void	free_extension (extension p)

extension	check_extension (extension p)

bool	extension_consistent_p (extension p)

bool	extension_defined_p (extension p)

list	gen_extension_cons (extension p, list l)

void	extension_assign_contents (extension r, extension v)

void	extension_non_recursive_free (extension p)

void	write_extension (FILE *f, extension p)

extension	read_extension (FILE *f)

string	extension_tag_as_string (enum extension_utype tag)

extension	make_extension (enum extension_utype tag, void *val)

extension	make_extension_pragma (pragma _field_)

extension	make_extension_unknown (void)

extensions	copy_extensions (extensions p)
	EXTENSIONS. More...

void	free_extensions (extensions p)

extensions	check_extensions (extensions p)

bool	extensions_consistent_p (extensions p)

bool	extensions_defined_p (extensions p)

list	gen_extensions_cons (extensions p, list l)

void	extensions_assign_contents (extensions r, extensions v)

void	extensions_non_recursive_free (extensions p)

void	write_extensions (FILE *f, extensions p)

extensions	read_extensions (FILE *f)

extensions	make_extensions (list a)

forloop	copy_forloop (forloop p)
	FORLOOP. More...

void	free_forloop (forloop p)

forloop	check_forloop (forloop p)

bool	forloop_consistent_p (forloop p)

bool	forloop_defined_p (forloop p)

list	gen_forloop_cons (forloop p, list l)

void	forloop_assign_contents (forloop r, forloop v)

void	forloop_non_recursive_free (forloop p)

void	write_forloop (FILE *f, forloop p)

forloop	read_forloop (FILE *f)

forloop	make_forloop (expression a1, expression a2, expression a3, statement a4)

formal	copy_formal (formal p)
	FORMAL. More...

void	free_formal (formal p)

formal	check_formal (formal p)

bool	formal_consistent_p (formal p)

bool	formal_defined_p (formal p)

list	gen_formal_cons (formal p, list l)

void	formal_assign_contents (formal r, formal v)

void	formal_non_recursive_free (formal p)

void	write_formal (FILE *f, formal p)

formal	read_formal (FILE *f)

formal	make_formal (entity a1, intptr_t a2)

functional	copy_functional (functional p)
	FUNCTIONAL. More...

void	free_functional (functional p)

functional	check_functional (functional p)

bool	functional_consistent_p (functional p)

bool	functional_defined_p (functional p)

list	gen_functional_cons (functional p, list l)

void	functional_assign_contents (functional r, functional v)

void	functional_non_recursive_free (functional p)

void	write_functional (FILE *f, functional p)

functional	read_functional (FILE *f)

functional	make_functional (list a1, type a2)

instruction	copy_instruction (instruction p)
	INSTRUCTION. More...

void	free_instruction (instruction p)

instruction	check_instruction (instruction p)

bool	instruction_consistent_p (instruction p)

bool	instruction_defined_p (instruction p)

list	gen_instruction_cons (instruction p, list l)

void	instruction_assign_contents (instruction r, instruction v)

void	instruction_non_recursive_free (instruction p)

void	write_instruction (FILE *f, instruction p)

instruction	read_instruction (FILE *f)

string	instruction_tag_as_string (enum instruction_utype tag)

instruction	make_instruction (enum instruction_utype tag, void *val)

instruction	make_instruction_sequence (sequence _field_)

instruction	make_instruction_test (test _field_)

instruction	make_instruction_loop (loop _field_)

instruction	make_instruction_whileloop (whileloop _field_)

instruction	make_instruction_goto (statement _field_)

instruction	make_instruction_call (call _field_)

instruction	make_instruction_unstructured (unstructured _field_)

instruction	make_instruction_multitest (multitest _field_)

instruction	make_instruction_forloop (forloop _field_)

instruction	make_instruction_expression (expression _field_)

language	copy_language (language p)
	LANGUAGE. More...

void	free_language (language p)

language	check_language (language p)

bool	language_consistent_p (language p)

bool	language_defined_p (language p)

list	gen_language_cons (language p, list l)

void	language_assign_contents (language r, language v)

void	language_non_recursive_free (language p)

void	write_language (FILE *f, language p)

language	read_language (FILE *f)

string	language_tag_as_string (enum language_utype tag)

language	make_language (enum language_utype tag, void *val)

language	make_language_fortran (void)

language	make_language_c (void)

language	make_language_fortran95 (void)

language	make_language_unknown (void)

loop	copy_loop (loop p)
	LOOP. More...

void	free_loop (loop p)

loop	check_loop (loop p)

bool	loop_consistent_p (loop p)

bool	loop_defined_p (loop p)

list	gen_loop_cons (loop p, list l)

void	loop_assign_contents (loop r, loop v)

void	loop_non_recursive_free (loop p)

void	write_loop (FILE *f, loop p)

loop	read_loop (FILE *f)

loop	make_loop (entity a1, range a2, statement a3, entity a4, execution a5, list a6)

mode	copy_mode (mode p)
	MODE. More...

void	free_mode (mode p)

mode	check_mode (mode p)

bool	mode_consistent_p (mode p)

bool	mode_defined_p (mode p)

list	gen_mode_cons (mode p, list l)

void	mode_assign_contents (mode r, mode v)

void	mode_non_recursive_free (mode p)

void	write_mode (FILE *f, mode p)

mode	read_mode (FILE *f)

string	mode_tag_as_string (enum mode_utype tag)

mode	make_mode (enum mode_utype tag, void *val)

mode	make_mode_value (void)

mode	make_mode_reference (void)

multitest	copy_multitest (multitest p)
	MULTITEST. More...

void	free_multitest (multitest p)

multitest	check_multitest (multitest p)

bool	multitest_consistent_p (multitest p)

bool	multitest_defined_p (multitest p)

list	gen_multitest_cons (multitest p, list l)

void	multitest_assign_contents (multitest r, multitest v)

void	multitest_non_recursive_free (multitest p)

void	write_multitest (FILE *f, multitest p)

multitest	read_multitest (FILE *f)

multitest	make_multitest (expression a1, statement a2)

normalized	copy_normalized (normalized p)
	NORMALIZED. More...

void	free_normalized (normalized p)

normalized	check_normalized (normalized p)

bool	normalized_consistent_p (normalized p)

bool	normalized_defined_p (normalized p)

list	gen_normalized_cons (normalized p, list l)

void	normalized_assign_contents (normalized r, normalized v)

void	normalized_non_recursive_free (normalized p)

void	write_normalized (FILE *f, normalized p)

normalized	read_normalized (FILE *f)

string	normalized_tag_as_string (enum normalized_utype tag)

normalized	make_normalized (enum normalized_utype tag, void *val)

normalized	make_normalized_linear (Pvecteur _field_)

normalized	make_normalized_complex (void)

parameter	copy_parameter (parameter p)
	PARAMETER. More...

void	free_parameter (parameter p)

parameter	check_parameter (parameter p)

bool	parameter_consistent_p (parameter p)

bool	parameter_defined_p (parameter p)

list	gen_parameter_cons (parameter p, list l)

void	parameter_assign_contents (parameter r, parameter v)

void	parameter_non_recursive_free (parameter p)

void	write_parameter (FILE *f, parameter p)

parameter	read_parameter (FILE *f)

parameter	make_parameter (type a1, mode a2, dummy a3)

persistant_statement_to_cluster	copy_persistant_statement_to_cluster (persistant_statement_to_cluster p)
	PERSISTANT_STATEMENT_TO_CLUSTER. More...

void	free_persistant_statement_to_cluster (persistant_statement_to_cluster p)

persistant_statement_to_cluster	check_persistant_statement_to_cluster (persistant_statement_to_cluster p)

bool	persistant_statement_to_cluster_consistent_p (persistant_statement_to_cluster p)

bool	persistant_statement_to_cluster_defined_p (persistant_statement_to_cluster p)

list	gen_persistant_statement_to_cluster_cons (persistant_statement_to_cluster p, list l)

void	persistant_statement_to_cluster_assign_contents (persistant_statement_to_cluster r, persistant_statement_to_cluster v)

void	persistant_statement_to_cluster_non_recursive_free (persistant_statement_to_cluster p)

void	write_persistant_statement_to_cluster (FILE *f, persistant_statement_to_cluster p)

persistant_statement_to_cluster	read_persistant_statement_to_cluster (FILE *f)

persistant_statement_to_cluster	make_persistant_statement_to_cluster (void)

intptr_t	apply_persistant_statement_to_cluster (persistant_statement_to_cluster f, intptr_t k)

void	update_persistant_statement_to_cluster (persistant_statement_to_cluster f, intptr_t k, intptr_t v)

void	extend_persistant_statement_to_cluster (persistant_statement_to_cluster f, intptr_t k, intptr_t v)

intptr_t	delete_persistant_statement_to_cluster (persistant_statement_to_cluster f, intptr_t k)

bool	bound_persistant_statement_to_cluster_p (persistant_statement_to_cluster f, intptr_t k)

persistant_statement_to_control	copy_persistant_statement_to_control (persistant_statement_to_control p)
	PERSISTANT_STATEMENT_TO_CONTROL. More...

void	free_persistant_statement_to_control (persistant_statement_to_control p)

persistant_statement_to_control	check_persistant_statement_to_control (persistant_statement_to_control p)

bool	persistant_statement_to_control_consistent_p (persistant_statement_to_control p)

bool	persistant_statement_to_control_defined_p (persistant_statement_to_control p)

list	gen_persistant_statement_to_control_cons (persistant_statement_to_control p, list l)

void	persistant_statement_to_control_assign_contents (persistant_statement_to_control r, persistant_statement_to_control v)

void	persistant_statement_to_control_non_recursive_free (persistant_statement_to_control p)

void	write_persistant_statement_to_control (FILE *f, persistant_statement_to_control p)

persistant_statement_to_control	read_persistant_statement_to_control (FILE *f)

persistant_statement_to_control	make_persistant_statement_to_control (void)

control	apply_persistant_statement_to_control (persistant_statement_to_control f, statement k)

void	update_persistant_statement_to_control (persistant_statement_to_control f, statement k, control v)

void	extend_persistant_statement_to_control (persistant_statement_to_control f, statement k, control v)

control	delete_persistant_statement_to_control (persistant_statement_to_control f, statement k)

bool	bound_persistant_statement_to_control_p (persistant_statement_to_control f, statement k)

persistant_statement_to_int	copy_persistant_statement_to_int (persistant_statement_to_int p)
	PERSISTANT_STATEMENT_TO_INT. More...

void	free_persistant_statement_to_int (persistant_statement_to_int p)

persistant_statement_to_int	check_persistant_statement_to_int (persistant_statement_to_int p)

bool	persistant_statement_to_int_consistent_p (persistant_statement_to_int p)

bool	persistant_statement_to_int_defined_p (persistant_statement_to_int p)

list	gen_persistant_statement_to_int_cons (persistant_statement_to_int p, list l)

void	persistant_statement_to_int_assign_contents (persistant_statement_to_int r, persistant_statement_to_int v)

void	persistant_statement_to_int_non_recursive_free (persistant_statement_to_int p)

void	write_persistant_statement_to_int (FILE *f, persistant_statement_to_int p)

persistant_statement_to_int	read_persistant_statement_to_int (FILE *f)

persistant_statement_to_int	make_persistant_statement_to_int (void)

intptr_t	apply_persistant_statement_to_int (persistant_statement_to_int f, statement k)

void	update_persistant_statement_to_int (persistant_statement_to_int f, statement k, intptr_t v)

void	extend_persistant_statement_to_int (persistant_statement_to_int f, statement k, intptr_t v)

intptr_t	delete_persistant_statement_to_int (persistant_statement_to_int f, statement k)

bool	bound_persistant_statement_to_int_p (persistant_statement_to_int f, statement k)

persistant_statement_to_statement	copy_persistant_statement_to_statement (persistant_statement_to_statement p)
	PERSISTANT_STATEMENT_TO_STATEMENT. More...

void	free_persistant_statement_to_statement (persistant_statement_to_statement p)

persistant_statement_to_statement	check_persistant_statement_to_statement (persistant_statement_to_statement p)

bool	persistant_statement_to_statement_consistent_p (persistant_statement_to_statement p)

bool	persistant_statement_to_statement_defined_p (persistant_statement_to_statement p)

list	gen_persistant_statement_to_statement_cons (persistant_statement_to_statement p, list l)

void	persistant_statement_to_statement_assign_contents (persistant_statement_to_statement r, persistant_statement_to_statement v)

void	persistant_statement_to_statement_non_recursive_free (persistant_statement_to_statement p)

void	write_persistant_statement_to_statement (FILE *f, persistant_statement_to_statement p)

persistant_statement_to_statement	read_persistant_statement_to_statement (FILE *f)

persistant_statement_to_statement	make_persistant_statement_to_statement (void)

statement	apply_persistant_statement_to_statement (persistant_statement_to_statement f, statement k)

void	update_persistant_statement_to_statement (persistant_statement_to_statement f, statement k, statement v)

void	extend_persistant_statement_to_statement (persistant_statement_to_statement f, statement k, statement v)

statement	delete_persistant_statement_to_statement (persistant_statement_to_statement f, statement k)

bool	bound_persistant_statement_to_statement_p (persistant_statement_to_statement f, statement k)

pragma	copy_pragma (pragma p)
	PRAGMA. More...

void	free_pragma (pragma p)

pragma	check_pragma (pragma p)

bool	pragma_consistent_p (pragma p)

bool	pragma_defined_p (pragma p)

list	gen_pragma_cons (pragma p, list l)

void	pragma_assign_contents (pragma r, pragma v)

void	pragma_non_recursive_free (pragma p)

void	write_pragma (FILE *f, pragma p)

pragma	read_pragma (FILE *f)

string	pragma_tag_as_string (enum pragma_utype tag)

pragma	make_pragma (enum pragma_utype tag, void *val)

pragma	make_pragma_string (string _field_)

pragma	make_pragma_expression (list _field_)

predicate	copy_predicate (predicate p)
	PREDICATE. More...

void	free_predicate (predicate p)

predicate	check_predicate (predicate p)

bool	predicate_consistent_p (predicate p)

bool	predicate_defined_p (predicate p)

list	gen_predicate_cons (predicate p, list l)

void	predicate_assign_contents (predicate r, predicate v)

void	predicate_non_recursive_free (predicate p)

void	write_predicate (FILE *f, predicate p)

predicate	read_predicate (FILE *f)

predicate	make_predicate (Psysteme a1)

preference	copy_preference (preference p)
	PREFERENCE. More...

void	free_preference (preference p)

preference	check_preference (preference p)

bool	preference_consistent_p (preference p)

bool	preference_defined_p (preference p)

list	gen_preference_cons (preference p, list l)

void	preference_assign_contents (preference r, preference v)

void	preference_non_recursive_free (preference p)

void	write_preference (FILE *f, preference p)

preference	read_preference (FILE *f)

preference	make_preference (reference a1)

qualifier	copy_qualifier (qualifier p)
	QUALIFIER. More...

void	free_qualifier (qualifier p)

qualifier	check_qualifier (qualifier p)

bool	qualifier_consistent_p (qualifier p)

bool	qualifier_defined_p (qualifier p)

list	gen_qualifier_cons (qualifier p, list l)

void	qualifier_assign_contents (qualifier r, qualifier v)

void	qualifier_non_recursive_free (qualifier p)

void	write_qualifier (FILE *f, qualifier p)

qualifier	read_qualifier (FILE *f)

string	qualifier_tag_as_string (enum qualifier_utype tag)

qualifier	make_qualifier (enum qualifier_utype tag, void *val)

qualifier	make_qualifier_const (void)

qualifier	make_qualifier_restrict (void)

qualifier	make_qualifier_volatile (void)

qualifier	make_qualifier_register (void)

qualifier	make_qualifier_auto (void)

qualifier	make_qualifier_thread (void)

qualifier	make_qualifier_asm (string _field_)

qualifier	make_qualifier_static_dimension (void)

qualifier	make_qualifier_local (void)

qualifier	make_qualifier_global (void)

qualifier	make_qualifier_constant (void)

qualifier	make_qualifier_private (void)

ram	copy_ram (ram p)
	RAM. More...

void	free_ram (ram p)

ram	check_ram (ram p)

bool	ram_consistent_p (ram p)

bool	ram_defined_p (ram p)

list	gen_ram_cons (ram p, list l)

void	ram_assign_contents (ram r, ram v)

void	ram_non_recursive_free (ram p)

void	write_ram (FILE *f, ram p)

ram	read_ram (FILE *f)

ram	make_ram (entity a1, entity a2, intptr_t a3, list a4)

range	copy_range (range p)
	RANGE. More...

void	free_range (range p)

range	check_range (range p)

bool	range_consistent_p (range p)

bool	range_defined_p (range p)

list	gen_range_cons (range p, list l)

void	range_assign_contents (range r, range v)

void	range_non_recursive_free (range p)

void	write_range (FILE *f, range p)

range	read_range (FILE *f)

range	make_range (expression a1, expression a2, expression a3)

reference	copy_reference (reference p)
	REFERENCE. More...

void	free_reference (reference p)

reference	check_reference (reference p)

bool	reference_consistent_p (reference p)

bool	reference_defined_p (reference p)

list	gen_reference_cons (reference p, list l)

void	reference_assign_contents (reference r, reference v)

void	reference_non_recursive_free (reference p)

void	write_reference (FILE *f, reference p)

reference	read_reference (FILE *f)

reference	make_reference (entity a1, list a2)

sequence	copy_sequence (sequence p)
	SEQUENCE. More...

void	free_sequence (sequence p)

sequence	check_sequence (sequence p)

bool	sequence_consistent_p (sequence p)

bool	sequence_defined_p (sequence p)

list	gen_sequence_cons (sequence p, list l)

void	sequence_assign_contents (sequence r, sequence v)

void	sequence_non_recursive_free (sequence p)

void	write_sequence (FILE *f, sequence p)

sequence	read_sequence (FILE *f)

sequence	make_sequence (list a)

sizeofexpression	copy_sizeofexpression (sizeofexpression p)
	SIZEOFEXPRESSION. More...

void	free_sizeofexpression (sizeofexpression p)

sizeofexpression	check_sizeofexpression (sizeofexpression p)

bool	sizeofexpression_consistent_p (sizeofexpression p)

bool	sizeofexpression_defined_p (sizeofexpression p)

list	gen_sizeofexpression_cons (sizeofexpression p, list l)

void	sizeofexpression_assign_contents (sizeofexpression r, sizeofexpression v)

void	sizeofexpression_non_recursive_free (sizeofexpression p)

void	write_sizeofexpression (FILE *f, sizeofexpression p)

sizeofexpression	read_sizeofexpression (FILE *f)

string	sizeofexpression_tag_as_string (enum sizeofexpression_utype tag)

sizeofexpression	make_sizeofexpression (enum sizeofexpression_utype tag, void *val)

sizeofexpression	make_sizeofexpression_type (type _field_)

sizeofexpression	make_sizeofexpression_expression (expression _field_)

statement	copy_statement (statement p)
	STATEMENT. More...

void	free_statement (statement p)

statement	check_statement (statement p)

bool	statement_consistent_p (statement p)

bool	statement_defined_p (statement p)

list	gen_statement_cons (statement p, list l)

void	statement_assign_contents (statement r, statement v)

void	statement_non_recursive_free (statement p)

void	write_statement (FILE *f, statement p)

statement	read_statement (FILE *f)

statement	make_statement (entity a1, intptr_t a2, intptr_t a3, string a4, instruction a5, list a6, string a7, extensions a8, synchronization a9)

storage	copy_storage (storage p)
	STORAGE. More...

void	free_storage (storage p)

storage	check_storage (storage p)

bool	storage_consistent_p (storage p)

bool	storage_defined_p (storage p)

list	gen_storage_cons (storage p, list l)

void	storage_assign_contents (storage r, storage v)

void	storage_non_recursive_free (storage p)

void	write_storage (FILE *f, storage p)

storage	read_storage (FILE *f)

string	storage_tag_as_string (enum storage_utype tag)

storage	make_storage (enum storage_utype tag, void *val)

storage	make_storage_return (entity _field_)

storage	make_storage_ram (ram _field_)

storage	make_storage_formal (formal _field_)

storage	make_storage_rom (void)

subscript	copy_subscript (subscript p)
	SUBSCRIPT. More...

void	free_subscript (subscript p)

subscript	check_subscript (subscript p)

bool	subscript_consistent_p (subscript p)

bool	subscript_defined_p (subscript p)

list	gen_subscript_cons (subscript p, list l)

void	subscript_assign_contents (subscript r, subscript v)

void	subscript_non_recursive_free (subscript p)

void	write_subscript (FILE *f, subscript p)

subscript	read_subscript (FILE *f)

subscript	make_subscript (expression a1, list a2)

symbolic	copy_symbolic (symbolic p)
	SYMBOLIC. More...

void	free_symbolic (symbolic p)

symbolic	check_symbolic (symbolic p)

bool	symbolic_consistent_p (symbolic p)

bool	symbolic_defined_p (symbolic p)

list	gen_symbolic_cons (symbolic p, list l)

void	symbolic_assign_contents (symbolic r, symbolic v)

void	symbolic_non_recursive_free (symbolic p)

void	write_symbolic (FILE *f, symbolic p)

symbolic	read_symbolic (FILE *f)

symbolic	make_symbolic (expression a1, constant a2)

synchronization	copy_synchronization (synchronization p)
	SYNCHRONIZATION. More...

void	free_synchronization (synchronization p)

synchronization	check_synchronization (synchronization p)

bool	synchronization_consistent_p (synchronization p)

bool	synchronization_defined_p (synchronization p)

list	gen_synchronization_cons (synchronization p, list l)

void	synchronization_assign_contents (synchronization r, synchronization v)

void	synchronization_non_recursive_free (synchronization p)

void	write_synchronization (FILE *f, synchronization p)

synchronization	read_synchronization (FILE *f)

string	synchronization_tag_as_string (enum synchronization_utype tag)

synchronization	make_synchronization (enum synchronization_utype tag, void *val)

synchronization	make_synchronization_none (void)

synchronization	make_synchronization_spawn (entity _field_)

synchronization	make_synchronization_barrier (void)

synchronization	make_synchronization_single (bool _field_)

synchronization	make_synchronization_critical (reference _field_)

syntax	copy_syntax (syntax p)
	SYNTAX. More...

void	free_syntax (syntax p)

syntax	check_syntax (syntax p)

bool	syntax_consistent_p (syntax p)

bool	syntax_defined_p (syntax p)

list	gen_syntax_cons (syntax p, list l)

void	syntax_assign_contents (syntax r, syntax v)

void	syntax_non_recursive_free (syntax p)

void	write_syntax (FILE *f, syntax p)

syntax	read_syntax (FILE *f)

string	syntax_tag_as_string (enum syntax_utype tag)

syntax	make_syntax (enum syntax_utype tag, void *val)

syntax	make_syntax_reference (reference _field_)

syntax	make_syntax_range (range _field_)

syntax	make_syntax_call (call _field_)

syntax	make_syntax_cast (cast _field_)

syntax	make_syntax_sizeofexpression (sizeofexpression _field_)

syntax	make_syntax_subscript (subscript _field_)

syntax	make_syntax_application (application _field_)

syntax	make_syntax_va_arg (list _field_)

entity	copy_entity (entity p)
	ENTITY. More...

void	free_entity (entity p)

entity	check_entity (entity p)

bool	entity_consistent_p (entity p)

bool	entity_defined_p (entity p)

list	gen_entity_cons (entity p, list l)

void	entity_assign_contents (entity r, entity v)

void	entity_non_recursive_free (entity p)

entity	gen_find_entity (char *s)

void	write_tabulated_entity (FILE *f)

void	read_tabulated_entity (FILE *f)

entity	make_entity (string a1, type a2, storage a3, value a4, intptr_t a5)

test	copy_test (test p)
	TEST. More...

void	free_test (test p)

test	check_test (test p)

bool	test_consistent_p (test p)

bool	test_defined_p (test p)

list	gen_test_cons (test p, list l)

void	test_assign_contents (test r, test v)

void	test_non_recursive_free (test p)

void	write_test (FILE *f, test p)

test	read_test (FILE *f)

test	make_test (expression a1, statement a2, statement a3)

transformer	copy_transformer (transformer p)
	TRANSFORMER. More...

void	free_transformer (transformer p)

transformer	check_transformer (transformer p)

bool	transformer_consistent_p (transformer p)

bool	transformer_defined_p (transformer p)

list	gen_transformer_cons (transformer p, list l)

void	transformer_assign_contents (transformer r, transformer v)

void	transformer_non_recursive_free (transformer p)

void	write_transformer (FILE *f, transformer p)

transformer	read_transformer (FILE *f)

transformer	make_transformer (list a1, predicate a2)

type	copy_type (type p)
	TYPE. More...

void	free_type (type p)

type	check_type (type p)

bool	type_consistent_p (type p)

bool	type_defined_p (type p)

list	gen_type_cons (type p, list l)

void	type_assign_contents (type r, type v)

void	type_non_recursive_free (type p)

void	write_type (FILE *f, type p)

type	read_type (FILE *f)

string	type_tag_as_string (enum type_utype tag)

type	make_type (enum type_utype tag, void *val)

type	make_type_statement (void)

type	make_type_area (area _field_)

type	make_type_variable (variable _field_)

type	make_type_functional (functional _field_)

type	make_type_varargs (type _field_)

type	make_type_unknown (void)

type	make_type_void (list _field_)

type	make_type_struct (list _field_)

type	make_type_union (list _field_)

type	make_type_enum (list _field_)

unstructured	copy_unstructured (unstructured p)
	UNSTRUCTURED. More...

void	free_unstructured (unstructured p)

unstructured	check_unstructured (unstructured p)

bool	unstructured_consistent_p (unstructured p)

bool	unstructured_defined_p (unstructured p)

list	gen_unstructured_cons (unstructured p, list l)

void	unstructured_assign_contents (unstructured r, unstructured v)

void	unstructured_non_recursive_free (unstructured p)

void	write_unstructured (FILE *f, unstructured p)

unstructured	read_unstructured (FILE *f)

unstructured	make_unstructured (control a1, control a2)

value	copy_value (value p)
	VALUE. More...

void	free_value (value p)

value	check_value (value p)

bool	value_consistent_p (value p)

bool	value_defined_p (value p)

list	gen_value_cons (value p, list l)

void	value_assign_contents (value r, value v)

void	value_non_recursive_free (value p)

void	write_value (FILE *f, value p)

value	read_value (FILE *f)

string	value_tag_as_string (enum value_utype tag)

value	make_value (enum value_utype tag, void *val)

value	make_value_code (code _field_)

value	make_value_symbolic (symbolic _field_)

value	make_value_constant (constant _field_)

value	make_value_intrinsic (void)

value	make_value_unknown (void)

value	make_value_expression (expression _field_)

value	make_value_reference (reference _field_)

variable	copy_variable (variable p)
	VARIABLE. More...

void	free_variable (variable p)

variable	check_variable (variable p)

bool	variable_consistent_p (variable p)

bool	variable_defined_p (variable p)

list	gen_variable_cons (variable p, list l)

void	variable_assign_contents (variable r, variable v)

void	variable_non_recursive_free (variable p)

void	write_variable (FILE *f, variable p)

variable	read_variable (FILE *f)

variable	make_variable (basic a1, list a2, list a3)

whileloop	copy_whileloop (whileloop p)
	WHILELOOP. More...

void	free_whileloop (whileloop p)

whileloop	check_whileloop (whileloop p)

bool	whileloop_consistent_p (whileloop p)

bool	whileloop_defined_p (whileloop p)

list	gen_whileloop_cons (whileloop p, list l)

void	whileloop_assign_contents (whileloop r, whileloop v)

void	whileloop_non_recursive_free (whileloop p)

void	write_whileloop (FILE *f, whileloop p)

whileloop	read_whileloop (FILE *f)

whileloop	make_whileloop (expression a1, statement a2, entity a3, evaluation a4)

Typedef Documentation

◆ Psysteme

typedef void* Psysteme

Definition at line 8 of file ri.c.

◆ Pvecteur

typedef void* Pvecteur

Definition at line 7 of file ri.c.

Function Documentation

◆ application_assign_contents()

void application_assign_contents	(	application	r,
		application	v
	)

Definition at line 39 of file ri.c.

                                                                {
   check_application(r);
   check_application(v);
   message_assert("defined references to domain application",
                  application_defined_p(r) && application_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_application_));
 }

References application_defined_p(), check_application(), and message_assert.

Here is the call graph for this function:

◆ application_consistent_p()

bool application_consistent_p ( application p )

Definition at line 29 of file ri.c.

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

References check_application(), and gen_consistent_p().

Here is the call graph for this function:

◆ application_defined_p()

bool application_defined_p ( application p )

Definition at line 33 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ application_non_recursive_free()

void application_non_recursive_free ( application p )

Definition at line 46 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ apply_controlmap()

control apply_controlmap	(	controlmap	f,
		statement	k
	)

Definition at line 469 of file ri.c.

                                                     {
   return (control) (intptr_t)HASH_GET(p, p, controlmap_hash_table(f), k);
 }

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

Here is the call graph for this function:

◆ apply_entity_int()

intptr_t apply_entity_int	(	entity_int	f,
		entity	k
	)

Definition at line 665 of file ri.c.

                                                   {
   return (intptr_t) (intptr_t)HASH_GET(p, i, entity_int_hash_table(f), k);
 }

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

Here is the call graph for this function:

◆ apply_entity_to_entity()

entity apply_entity_to_entity	(	entity_to_entity	f,
		entity	k
	)

Definition at line 722 of file ri.c.

                                                             {
   return (entity) (intptr_t)HASH_GET(p, p, entity_to_entity_hash_table(f), k);
 }

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

Here is the call graph for this function:

◆ apply_persistant_statement_to_cluster()

intptr_t apply_persistant_statement_to_cluster	(	persistant_statement_to_cluster	f,
		intptr_t	k
	)

Definition at line 1540 of file ri.c.

                                                                                               {
   return (intptr_t) (intptr_t)HASH_GET(i, i, persistant_statement_to_cluster_hash_table(f), k);
 }

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

Here is the call graph for this function:

◆ apply_persistant_statement_to_control()

control apply_persistant_statement_to_control	(	persistant_statement_to_control	f,
		statement	k
	)

Definition at line 1597 of file ri.c.

                                                                                               {
   return (control) (intptr_t)HASH_GET(p, p, persistant_statement_to_control_hash_table(f), k);
 }

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

Here is the call graph for this function:

◆ apply_persistant_statement_to_int()

intptr_t apply_persistant_statement_to_int	(	persistant_statement_to_int	f,
		statement	k
	)

Definition at line 1654 of file ri.c.

                                                                                        {
   return (intptr_t) (intptr_t)HASH_GET(p, i, persistant_statement_to_int_hash_table(f), k);
 }

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

Here is the call graph for this function:

◆ apply_persistant_statement_to_statement()

statement apply_persistant_statement_to_statement	(	persistant_statement_to_statement	f,
		statement	k
	)

Definition at line 1711 of file ri.c.

                                                                                                     {
   return (statement) (intptr_t)HASH_GET(p, p, persistant_statement_to_statement_hash_table(f), k);
 }

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

Here is the call graph for this function:

◆ area_assign_contents()

void area_assign_contents	(	area	r,
		area	v
	)

Definition at line 81 of file ri.c.

                                           {
   check_area(r);
   check_area(v);
   message_assert("defined references to domain area",
                  area_defined_p(r) && area_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_area_));
 }

References area_defined_p(), check_area(), and message_assert.

Here is the call graph for this function:

◆ area_consistent_p()

bool area_consistent_p ( area p )

Definition at line 71 of file ri.c.

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

References check_area(), and gen_consistent_p().

Here is the call graph for this function:

◆ area_defined_p()

bool area_defined_p ( area p )

Definition at line 75 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ area_non_recursive_free()

void area_non_recursive_free ( area p )

Definition at line 88 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ basic_assign_contents()

void basic_assign_contents	(	basic	r,
		basic	v
	)

Definition at line 123 of file ri.c.

                                              {
   check_basic(r);
   check_basic(v);
   message_assert("defined references to domain basic",
                  basic_defined_p(r) && basic_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_basic_));
 }

References basic_defined_p(), check_basic(), and message_assert.

Here is the call graph for this function:

◆ basic_consistent_p()

bool basic_consistent_p ( basic p )

Definition at line 113 of file ri.c.

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

References check_basic(), and gen_consistent_p().

Here is the call graph for this function:

◆ basic_defined_p()

bool basic_defined_p ( basic p )

Definition at line 117 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ basic_non_recursive_free()

void basic_non_recursive_free ( basic p )

Definition at line 130 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ basic_tag_as_string()

string basic_tag_as_string ( enum basic_utype tag )

Definition at line 140 of file ri.c.

                                                  {
   switch (tag) {
   case is_basic_int: return "int";
   case is_basic_float: return "float";
   case is_basic_logical: return "logical";
   case is_basic_overloaded: return "overloaded";
   case is_basic_complex: return "complex";
   case is_basic_string: return "string";
   case is_basic_bit: return "bit";
   case is_basic_pointer: return "pointer";
   case is_basic_derived: return "derived";
   case is_basic_typedef: return "typedef";
   default: return string_undefined;
   }
 }

References is_basic_bit, is_basic_complex, is_basic_derived, is_basic_float, is_basic_int, is_basic_logical, is_basic_overloaded, is_basic_pointer, is_basic_string, is_basic_typedef, and string_undefined.

◆ bound_controlmap_p()

bool bound_controlmap_p	(	controlmap	f,
		statement	k
	)

Definition at line 481 of file ri.c.

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

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

Here is the call graph for this function:

◆ bound_entity_int_p()

bool bound_entity_int_p	(	entity_int	f,
		entity	k
	)

Definition at line 677 of file ri.c.

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

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

Here is the call graph for this function:

◆ bound_entity_to_entity_p()

bool bound_entity_to_entity_p	(	entity_to_entity	f,
		entity	k
	)

Definition at line 734 of file ri.c.

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

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

Here is the call graph for this function:

◆ bound_persistant_statement_to_cluster_p()

bool bound_persistant_statement_to_cluster_p	(	persistant_statement_to_cluster	f,
		intptr_t	k
	)

Definition at line 1552 of file ri.c.

                                                                                             {
   return (intptr_t)HASH_BOUND_P(i, i, persistant_statement_to_cluster_hash_table(f), k);
 }

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

Here is the call graph for this function:

◆ bound_persistant_statement_to_control_p()

bool bound_persistant_statement_to_control_p	(	persistant_statement_to_control	f,
		statement	k
	)

Definition at line 1609 of file ri.c.

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

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

Here is the call graph for this function:

◆ bound_persistant_statement_to_int_p()

bool bound_persistant_statement_to_int_p	(	persistant_statement_to_int	f,
		statement	k
	)

Definition at line 1666 of file ri.c.

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

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

Here is the call graph for this function:

◆ bound_persistant_statement_to_statement_p()

bool bound_persistant_statement_to_statement_p	(	persistant_statement_to_statement	f,
		statement	k
	)

Definition at line 1723 of file ri.c.

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

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

Here is the call graph for this function:

◆ call_assign_contents()

void call_assign_contents	(	call	r,
		call	v
	)

Definition at line 252 of file ri.c.

                                           {
   check_call(r);
   check_call(v);
   message_assert("defined references to domain call",
                  call_defined_p(r) && call_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_call_));
 }

References call_defined_p(), check_call(), and message_assert.

Here is the call graph for this function:

◆ call_consistent_p()

bool call_consistent_p ( call p )

Definition at line 242 of file ri.c.

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

References check_call(), and gen_consistent_p().

Here is the call graph for this function:

◆ call_defined_p()

bool call_defined_p ( call p )

Definition at line 246 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ call_non_recursive_free()

void call_non_recursive_free ( call p )

Definition at line 259 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ callees_assign_contents()

void callees_assign_contents	(	callees	r,
		callees	v
	)

Definition at line 210 of file ri.c.

                                                    {
   check_callees(r);
   check_callees(v);
   message_assert("defined references to domain callees",
                  callees_defined_p(r) && callees_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_callees_));
 }

References callees_defined_p(), check_callees(), and message_assert.

Here is the call graph for this function:

◆ callees_consistent_p()

bool callees_consistent_p ( callees p )

Definition at line 200 of file ri.c.

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

References check_callees(), and gen_consistent_p().

Here is the call graph for this function:

◆ callees_defined_p()

bool callees_defined_p ( callees p )

Definition at line 204 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ callees_non_recursive_free()

void callees_non_recursive_free ( callees p )

Definition at line 217 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ cast_assign_contents()

void cast_assign_contents	(	cast	r,
		cast	v
	)

Definition at line 294 of file ri.c.

                                           {
   check_cast(r);
   check_cast(v);
   message_assert("defined references to domain cast",
                  cast_defined_p(r) && cast_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_cast_));
 }

References cast_defined_p(), check_cast(), and message_assert.

Here is the call graph for this function:

◆ cast_consistent_p()

bool cast_consistent_p ( cast p )

Definition at line 284 of file ri.c.

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

References check_cast(), and gen_consistent_p().

Here is the call graph for this function:

◆ cast_defined_p()

bool cast_defined_p ( cast p )

Definition at line 288 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ cast_non_recursive_free()

void cast_non_recursive_free ( cast p )

Definition at line 301 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ check_application()

application check_application ( application p )

Definition at line 26 of file ri.c.

                                              {
   return (application) gen_check((gen_chunk*) p, application_domain);
 }

References application_domain, and gen_check().

Here is the call graph for this function:

◆ check_area()

area check_area ( area p )

Definition at line 68 of file ri.c.

                         {
   return (area) gen_check((gen_chunk*) p, area_domain);
 }

References area_domain, and gen_check().

Here is the call graph for this function:

◆ check_basic()

basic check_basic ( basic p )

Definition at line 110 of file ri.c.

                            {
   return (basic) gen_check((gen_chunk*) p, basic_domain);
 }

References basic_domain, and gen_check().

Here is the call graph for this function:

◆ check_call()

call check_call ( call p )

Definition at line 239 of file ri.c.

                         {
   return (call) gen_check((gen_chunk*) p, call_domain);
 }

References call_domain, and gen_check().

Here is the call graph for this function:

◆ check_callees()

callees check_callees ( callees p )

Definition at line 197 of file ri.c.

                                  {
   return (callees) gen_check((gen_chunk*) p, callees_domain);
 }

References callees_domain, and gen_check().

Here is the call graph for this function:

◆ check_cast()

cast check_cast ( cast p )

Definition at line 281 of file ri.c.

                         {
   return (cast) gen_check((gen_chunk*) p, cast_domain);
 }

References cast_domain, and gen_check().

Here is the call graph for this function:

◆ check_code()

code check_code ( code p )

Definition at line 323 of file ri.c.

                         {
   return (code) gen_check((gen_chunk*) p, code_domain);
 }

References code_domain, and gen_check().

Here is the call graph for this function:

◆ check_constant()

constant check_constant ( constant p )

Definition at line 365 of file ri.c.

                                     {
   return (constant) gen_check((gen_chunk*) p, constant_domain);
 }

References constant_domain, and gen_check().

Here is the call graph for this function:

◆ check_control()

control check_control ( control p )

Definition at line 493 of file ri.c.

                                  {
   return (control) gen_check((gen_chunk*) p, control_domain);
 }

References control_domain, and gen_check().

Here is the call graph for this function:

◆ check_controlmap()

controlmap check_controlmap ( controlmap p )

Definition at line 436 of file ri.c.

                                           {
   return (controlmap) gen_check((gen_chunk*) p, controlmap_domain);
 }

References controlmap_domain, and gen_check().

Here is the call graph for this function:

◆ check_dimension()

dimension check_dimension ( dimension p )

Definition at line 535 of file ri.c.

                                        {
   return (dimension) gen_check((gen_chunk*) p, dimension_domain);
 }

References dimension_domain, and gen_check().

Here is the call graph for this function:

◆ check_dummy()

dummy check_dummy ( dummy p )

Definition at line 577 of file ri.c.

                            {
   return (dummy) gen_check((gen_chunk*) p, dummy_domain);
 }

References dummy_domain, and gen_check().

Here is the call graph for this function:

◆ check_entity()

entity check_entity ( entity p )

Definition at line 2527 of file ri.c.

                               {
   return (entity) gen_check((gen_chunk*) p, entity_domain);
 }

References entity_domain, and gen_check().

Here is the call graph for this function:

◆ check_entity_int()

entity_int check_entity_int ( entity_int p )

Definition at line 632 of file ri.c.

                                           {
   return (entity_int) gen_check((gen_chunk*) p, entity_int_domain);
 }

References entity_int_domain, and gen_check().

Here is the call graph for this function:

◆ check_entity_to_entity()

entity_to_entity check_entity_to_entity ( entity_to_entity p )

Definition at line 689 of file ri.c.

                                                             {
   return (entity_to_entity) gen_check((gen_chunk*) p, entity_to_entity_domain);
 }

References entity_to_entity_domain, and gen_check().

Here is the call graph for this function:

◆ check_evaluation()

evaluation check_evaluation ( evaluation p )

Definition at line 746 of file ri.c.

                                           {
   return (evaluation) gen_check((gen_chunk*) p, evaluation_domain);
 }

References evaluation_domain, and gen_check().

Here is the call graph for this function:

◆ check_execution()

execution check_execution ( execution p )

Definition at line 801 of file ri.c.

                                        {
   return (execution) gen_check((gen_chunk*) p, execution_domain);
 }

References execution_domain, and gen_check().

Here is the call graph for this function:

◆ check_expression()

expression check_expression ( expression p )

Definition at line 856 of file ri.c.

                                           {
   return (expression) gen_check((gen_chunk*) p, expression_domain);
 }

References expression_domain, and gen_check().

Here is the call graph for this function:

◆ check_extension()

extension check_extension ( extension p )

Definition at line 898 of file ri.c.

                                        {
   return (extension) gen_check((gen_chunk*) p, extension_domain);
 }

References extension_domain, and gen_check().

Here is the call graph for this function:

◆ check_extensions()

extensions check_extensions ( extensions p )

Definition at line 953 of file ri.c.

                                           {
   return (extensions) gen_check((gen_chunk*) p, extensions_domain);
 }

References extensions_domain, and gen_check().

Here is the call graph for this function:

◆ check_forloop()

forloop check_forloop ( forloop p )

Definition at line 995 of file ri.c.

                                  {
   return (forloop) gen_check((gen_chunk*) p, forloop_domain);
 }

References forloop_domain, and gen_check().

Here is the call graph for this function:

◆ check_formal()

formal check_formal ( formal p )

Definition at line 1037 of file ri.c.

                               {
   return (formal) gen_check((gen_chunk*) p, formal_domain);
 }

References formal_domain, and gen_check().

Here is the call graph for this function:

◆ check_functional()

functional check_functional ( functional p )

Definition at line 1079 of file ri.c.

                                           {
   return (functional) gen_check((gen_chunk*) p, functional_domain);
 }

References functional_domain, and gen_check().

Here is the call graph for this function:

◆ check_instruction()

instruction check_instruction ( instruction p )

Definition at line 1121 of file ri.c.

                                              {
   return (instruction) gen_check((gen_chunk*) p, instruction_domain);
 }

References gen_check(), and instruction_domain.

Here is the call graph for this function:

◆ check_language()

language check_language ( language p )

Definition at line 1208 of file ri.c.

                                     {
   return (language) gen_check((gen_chunk*) p, language_domain);
 }

References gen_check(), and language_domain.

Here is the call graph for this function:

◆ check_loop()

loop check_loop ( loop p )

Definition at line 1271 of file ri.c.

                         {
   return (loop) gen_check((gen_chunk*) p, loop_domain);
 }

References gen_check(), and loop_domain.

Here is the call graph for this function:

◆ check_mode()

mode check_mode ( mode p )

Definition at line 1313 of file ri.c.

                         {
   return (mode) gen_check((gen_chunk*) p, mode_domain);
 }

References gen_check(), and mode_domain.

Here is the call graph for this function:

◆ check_multitest()

multitest check_multitest ( multitest p )

Definition at line 1368 of file ri.c.

                                        {
   return (multitest) gen_check((gen_chunk*) p, multitest_domain);
 }

References gen_check(), and multitest_domain.

Here is the call graph for this function:

◆ check_normalized()

normalized check_normalized ( normalized p )

Definition at line 1410 of file ri.c.

                                           {
   return (normalized) gen_check((gen_chunk*) p, normalized_domain);
 }

References gen_check(), and normalized_domain.

Here is the call graph for this function:

◆ check_parameter()

parameter check_parameter ( parameter p )

Definition at line 1465 of file ri.c.

                                        {
   return (parameter) gen_check((gen_chunk*) p, parameter_domain);
 }

References gen_check(), and parameter_domain.

Here is the call graph for this function:

◆ check_persistant_statement_to_cluster()

persistant_statement_to_cluster check_persistant_statement_to_cluster ( persistant_statement_to_cluster p )

Definition at line 1507 of file ri.c.

                                                                                                          {
   return (persistant_statement_to_cluster) gen_check((gen_chunk*) p, persistant_statement_to_cluster_domain);
 }

References gen_check(), and persistant_statement_to_cluster_domain.

Here is the call graph for this function:

◆ check_persistant_statement_to_control()

persistant_statement_to_control check_persistant_statement_to_control ( persistant_statement_to_control p )

Definition at line 1564 of file ri.c.

                                                                                                          {
   return (persistant_statement_to_control) gen_check((gen_chunk*) p, persistant_statement_to_control_domain);
 }

References gen_check(), and persistant_statement_to_control_domain.

Here is the call graph for this function:

◆ check_persistant_statement_to_int()

persistant_statement_to_int check_persistant_statement_to_int ( persistant_statement_to_int p )

Definition at line 1621 of file ri.c.

                                                                                              {
   return (persistant_statement_to_int) gen_check((gen_chunk*) p, persistant_statement_to_int_domain);
 }

References gen_check(), and persistant_statement_to_int_domain.

Here is the call graph for this function:

◆ check_persistant_statement_to_statement()

persistant_statement_to_statement check_persistant_statement_to_statement ( persistant_statement_to_statement p )

Definition at line 1678 of file ri.c.

                                                                                                                {
   return (persistant_statement_to_statement) gen_check((gen_chunk*) p, persistant_statement_to_statement_domain);
 }

References gen_check(), and persistant_statement_to_statement_domain.

Here is the call graph for this function:

◆ check_pragma()

pragma check_pragma ( pragma p )

Definition at line 1735 of file ri.c.

                               {
   return (pragma) gen_check((gen_chunk*) p, pragma_domain);
 }

References gen_check(), and pragma_domain.

Here is the call graph for this function:

◆ check_predicate()

predicate check_predicate ( predicate p )

Definition at line 1790 of file ri.c.

                                        {
   return (predicate) gen_check((gen_chunk*) p, predicate_domain);
 }

References gen_check(), and predicate_domain.

Here is the call graph for this function:

◆ check_preference()

preference check_preference ( preference p )

Definition at line 1832 of file ri.c.

                                           {
   return (preference) gen_check((gen_chunk*) p, preference_domain);
 }

References gen_check(), and preference_domain.

Here is the call graph for this function:

◆ check_qualifier()

qualifier check_qualifier ( qualifier p )

Definition at line 1874 of file ri.c.

                                        {
   return (qualifier) gen_check((gen_chunk*) p, qualifier_domain);
 }

References gen_check(), and qualifier_domain.

Here is the call graph for this function:

◆ check_ram()

ram check_ram ( ram p )

Definition at line 1969 of file ri.c.

                      {
   return (ram) gen_check((gen_chunk*) p, ram_domain);
 }

References gen_check(), and ram_domain.

Here is the call graph for this function:

◆ check_range()

range check_range ( range p )

Definition at line 2011 of file ri.c.

                            {
   return (range) gen_check((gen_chunk*) p, range_domain);
 }

References gen_check(), and range_domain.

Here is the call graph for this function:

◆ check_reference()

reference check_reference ( reference p )

Definition at line 2053 of file ri.c.

                                        {
   return (reference) gen_check((gen_chunk*) p, reference_domain);
 }

References gen_check(), and reference_domain.

Here is the call graph for this function:

◆ check_sequence()

sequence check_sequence ( sequence p )

Definition at line 2095 of file ri.c.

                                     {
   return (sequence) gen_check((gen_chunk*) p, sequence_domain);
 }

References gen_check(), and sequence_domain.

Here is the call graph for this function:

◆ check_sizeofexpression()

sizeofexpression check_sizeofexpression ( sizeofexpression p )

Definition at line 2137 of file ri.c.

                                                             {
   return (sizeofexpression) gen_check((gen_chunk*) p, sizeofexpression_domain);
 }

References gen_check(), and sizeofexpression_domain.

Here is the call graph for this function:

◆ check_statement()

statement check_statement ( statement p )

Definition at line 2192 of file ri.c.

                                        {
   return (statement) gen_check((gen_chunk*) p, statement_domain);
 }

References gen_check(), and statement_domain.

Here is the call graph for this function:

◆ check_storage()

storage check_storage ( storage p )

Definition at line 2234 of file ri.c.

                                  {
   return (storage) gen_check((gen_chunk*) p, storage_domain);
 }

References gen_check(), and storage_domain.

Here is the call graph for this function:

◆ check_subscript()

subscript check_subscript ( subscript p )

Definition at line 2297 of file ri.c.

                                        {
   return (subscript) gen_check((gen_chunk*) p, subscript_domain);
 }

References gen_check(), and subscript_domain.

Here is the call graph for this function:

◆ check_symbolic()

symbolic check_symbolic ( symbolic p )

Definition at line 2339 of file ri.c.

                                     {
   return (symbolic) gen_check((gen_chunk*) p, symbolic_domain);
 }

References gen_check(), and symbolic_domain.

Here is the call graph for this function:

◆ check_synchronization()

synchronization check_synchronization ( synchronization p )

Definition at line 2381 of file ri.c.

                                                          {
   return (synchronization) gen_check((gen_chunk*) p, synchronization_domain);
 }

References gen_check(), and synchronization_domain.

Here is the call graph for this function:

◆ check_syntax()

syntax check_syntax ( syntax p )

Definition at line 2448 of file ri.c.

                               {
   return (syntax) gen_check((gen_chunk*) p, syntax_domain);
 }

References gen_check(), and syntax_domain.

Here is the call graph for this function:

◆ check_test()

test check_test ( test p )

Definition at line 2577 of file ri.c.

                         {
   return (test) gen_check((gen_chunk*) p, test_domain);
 }

References gen_check(), and test_domain.

Here is the call graph for this function:

◆ check_transformer()

transformer check_transformer ( transformer p )

Definition at line 2619 of file ri.c.

                                              {
   return (transformer) gen_check((gen_chunk*) p, transformer_domain);
 }

References gen_check(), and transformer_domain.

Here is the call graph for this function:

◆ check_type()

type check_type ( type p )

Definition at line 2661 of file ri.c.

                         {
   return (type) gen_check((gen_chunk*) p, type_domain);
 }

References gen_check(), and type_domain.

Here is the call graph for this function:

◆ check_unstructured()

unstructured check_unstructured ( unstructured p )

Definition at line 2748 of file ri.c.

                                                 {
   return (unstructured) gen_check((gen_chunk*) p, unstructured_domain);
 }

References gen_check(), and unstructured_domain.

Here is the call graph for this function:

◆ check_value()

value check_value ( value p )

Definition at line 2790 of file ri.c.

                            {
   return (value) gen_check((gen_chunk*) p, value_domain);
 }

References gen_check(), and value_domain.

Here is the call graph for this function:

◆ check_variable()

variable check_variable ( variable p )

Definition at line 2865 of file ri.c.

                                     {
   return (variable) gen_check((gen_chunk*) p, variable_domain);
 }

References gen_check(), and variable_domain.

Here is the call graph for this function:

◆ check_whileloop()

whileloop check_whileloop ( whileloop p )

Definition at line 2907 of file ri.c.

                                        {
   return (whileloop) gen_check((gen_chunk*) p, whileloop_domain);
 }

References gen_check(), and whileloop_domain.

Here is the call graph for this function:

◆ code_assign_contents()

void code_assign_contents	(	code	r,
		code	v
	)

Definition at line 336 of file ri.c.

                                           {
   check_code(r);
   check_code(v);
   message_assert("defined references to domain code",
                  code_defined_p(r) && code_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_code_));
 }

References check_code(), code_defined_p(), and message_assert.

Here is the call graph for this function:

◆ code_consistent_p()

bool code_consistent_p ( code p )

Definition at line 326 of file ri.c.

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

References check_code(), and gen_consistent_p().

Here is the call graph for this function:

◆ code_defined_p()

bool code_defined_p ( code p )

Definition at line 330 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ code_non_recursive_free()

void code_non_recursive_free ( code p )

Definition at line 343 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ constant_assign_contents()

void constant_assign_contents	(	constant	r,
		constant	v
	)

Definition at line 378 of file ri.c.

                                                       {
   check_constant(r);
   check_constant(v);
   message_assert("defined references to domain constant",
                  constant_defined_p(r) && constant_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_constant_));
 }

References check_constant(), constant_defined_p(), and message_assert.

Here is the call graph for this function:

◆ constant_consistent_p()

bool constant_consistent_p ( constant p )

Definition at line 368 of file ri.c.

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

References check_constant(), and gen_consistent_p().

Here is the call graph for this function:

◆ constant_defined_p()

bool constant_defined_p ( constant p )

Definition at line 372 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ constant_non_recursive_free()

void constant_non_recursive_free ( constant p )

Definition at line 385 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ constant_tag_as_string()

string constant_tag_as_string ( enum constant_utype tag )

Definition at line 395 of file ri.c.

                                                        {
   switch (tag) {
   case is_constant_int: return "int";
   case is_constant_float: return "float";
   case is_constant_logical: return "logical";
   case is_constant_litteral: return "litteral";
   case is_constant_call: return "call";
   case is_constant_unknown: return "unknown";
   default: return string_undefined;
   }
 }

References is_constant_call, is_constant_float, is_constant_int, is_constant_litteral, is_constant_logical, is_constant_unknown, and string_undefined.

◆ control_assign_contents()

void control_assign_contents	(	control	r,
		control	v
	)

Definition at line 506 of file ri.c.

                                                    {
   check_control(r);
   check_control(v);
   message_assert("defined references to domain control",
                  control_defined_p(r) && control_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_control_));
 }

References check_control(), control_defined_p(), and message_assert.

Here is the call graph for this function:

◆ control_consistent_p()

bool control_consistent_p ( control p )

Definition at line 496 of file ri.c.

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

References check_control(), and gen_consistent_p().

Here is the call graph for this function:

◆ control_defined_p()

bool control_defined_p ( control p )

Definition at line 500 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ control_non_recursive_free()

void control_non_recursive_free ( control p )

Definition at line 513 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ controlmap_assign_contents()

void controlmap_assign_contents	(	controlmap	r,
		controlmap	v
	)

Definition at line 449 of file ri.c.

                                                             {
   check_controlmap(r);
   check_controlmap(v);
   message_assert("defined references to domain controlmap",
                  controlmap_defined_p(r) && controlmap_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_controlmap_));
 }

References check_controlmap(), controlmap_defined_p(), and message_assert.

Here is the call graph for this function:

◆ controlmap_consistent_p()

bool controlmap_consistent_p ( controlmap p )

Definition at line 439 of file ri.c.

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

References check_controlmap(), and gen_consistent_p().

Here is the call graph for this function:

◆ controlmap_defined_p()

bool controlmap_defined_p ( controlmap p )

Definition at line 443 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ controlmap_non_recursive_free()

void controlmap_non_recursive_free ( controlmap p )

Definition at line 456 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ copy_application()

application copy_application ( application p )

APPLICATION.

Definition at line 20 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_area()

area copy_area ( area p )

AREA.

Definition at line 62 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_basic()

basic copy_basic ( basic p )

BASIC.

Definition at line 104 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_call()

call copy_call ( call p )

CALL.

Definition at line 233 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_callees()

callees copy_callees ( callees p )

CALLEES.

Definition at line 191 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_cast()

cast copy_cast ( cast p )

CAST.

Definition at line 275 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_code()

code copy_code ( code p )

CODE.

Definition at line 317 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_constant()

constant copy_constant ( constant p )

CONSTANT.

Definition at line 359 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_control()

control copy_control ( control p )

CONTROL.

Definition at line 487 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_controlmap()

controlmap copy_controlmap ( controlmap p )

CONTROLMAP.

Definition at line 430 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_dimension()

dimension copy_dimension ( dimension p )

DIMENSION.

Definition at line 529 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_dummy()

dummy copy_dummy ( dummy p )

DUMMY.

Definition at line 571 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_entity()

entity copy_entity ( entity p )

ENTITY.

Definition at line 2521 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_entity_int()

entity_int copy_entity_int ( entity_int p )

ENTITY_INT.

Definition at line 626 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_entity_to_entity()

entity_to_entity copy_entity_to_entity ( entity_to_entity p )

ENTITY_TO_ENTITY.

Definition at line 683 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_evaluation()

evaluation copy_evaluation ( evaluation p )

EVALUATION.

Definition at line 740 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_execution()

execution copy_execution ( execution p )

EXECUTION.

Definition at line 795 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_expression()

expression copy_expression ( expression p )

EXPRESSION.

Definition at line 850 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_extension()

extension copy_extension ( extension p )

EXTENSION.

Definition at line 892 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_extensions()

extensions copy_extensions ( extensions p )

EXTENSIONS.

Definition at line 947 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_forloop()

forloop copy_forloop ( forloop p )

FORLOOP.

Definition at line 989 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_formal()

formal copy_formal ( formal p )

FORMAL.

Definition at line 1031 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_functional()

functional copy_functional ( functional p )

FUNCTIONAL.

Definition at line 1073 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_instruction()

instruction copy_instruction ( instruction p )

INSTRUCTION.

Definition at line 1115 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_language()

language copy_language ( language p )

LANGUAGE.

Definition at line 1202 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_loop()

loop copy_loop ( loop p )

LOOP.

Definition at line 1265 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_mode()

mode copy_mode ( mode p )

MODE.

Definition at line 1307 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_multitest()

multitest copy_multitest ( multitest p )

MULTITEST.

Definition at line 1362 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_normalized()

normalized copy_normalized ( normalized p )

NORMALIZED.

Definition at line 1404 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_parameter()

parameter copy_parameter ( parameter p )

PARAMETER.

Definition at line 1459 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_persistant_statement_to_cluster()

persistant_statement_to_cluster copy_persistant_statement_to_cluster ( persistant_statement_to_cluster p )

PERSISTANT_STATEMENT_TO_CLUSTER.

Definition at line 1501 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_persistant_statement_to_control()

persistant_statement_to_control copy_persistant_statement_to_control ( persistant_statement_to_control p )

PERSISTANT_STATEMENT_TO_CONTROL.

Definition at line 1558 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_persistant_statement_to_int()

persistant_statement_to_int copy_persistant_statement_to_int ( persistant_statement_to_int p )

PERSISTANT_STATEMENT_TO_INT.

Definition at line 1615 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_persistant_statement_to_statement()

persistant_statement_to_statement copy_persistant_statement_to_statement ( persistant_statement_to_statement p )

PERSISTANT_STATEMENT_TO_STATEMENT.

Definition at line 1672 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_pragma()

pragma copy_pragma ( pragma p )

PRAGMA.

Definition at line 1729 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_predicate()

predicate copy_predicate ( predicate p )

PREDICATE.

Definition at line 1784 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_preference()

preference copy_preference ( preference p )

PREFERENCE.

Definition at line 1826 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_qualifier()

qualifier copy_qualifier ( qualifier p )

QUALIFIER.

Definition at line 1868 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_ram()

ram copy_ram ( ram p )

RAM.

Definition at line 1963 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_range()

range copy_range ( range p )

RANGE.

Definition at line 2005 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_reference()

reference copy_reference ( reference p )

REFERENCE.

Definition at line 2047 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_sequence()

sequence copy_sequence ( sequence p )

SEQUENCE.

Definition at line 2089 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_sizeofexpression()

sizeofexpression copy_sizeofexpression ( sizeofexpression p )

SIZEOFEXPRESSION.

Definition at line 2131 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_statement()

statement copy_statement ( statement p )

STATEMENT.

Definition at line 2186 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_storage()

storage copy_storage ( storage p )

STORAGE.

Definition at line 2228 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_subscript()

subscript copy_subscript ( subscript p )

SUBSCRIPT.

Definition at line 2291 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_symbolic()

symbolic copy_symbolic ( symbolic p )

SYMBOLIC.

Definition at line 2333 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_synchronization()

synchronization copy_synchronization ( synchronization p )

SYNCHRONIZATION.

Definition at line 2375 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_syntax()

syntax copy_syntax ( syntax p )

SYNTAX.

Definition at line 2442 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_test()

test copy_test ( test p )

TEST.

Definition at line 2571 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_transformer()

transformer copy_transformer ( transformer p )

TRANSFORMER.

Definition at line 2613 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_type()

type copy_type ( type p )

TYPE.

Definition at line 2655 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_unstructured()

unstructured copy_unstructured ( unstructured p )

UNSTRUCTURED.

Definition at line 2742 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_value()

value copy_value ( value p )

VALUE.

Definition at line 2784 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_variable()

variable copy_variable ( variable p )

VARIABLE.

Definition at line 2859 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ copy_whileloop()

whileloop copy_whileloop ( whileloop p )

WHILELOOP.

Definition at line 2901 of file ri.c.

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

References gen_copy_tree().

Here is the call graph for this function:

◆ delete_controlmap()

control delete_controlmap	(	controlmap	f,
		statement	k
	)

Definition at line 478 of file ri.c.

                                                      {
   return (control)(intptr_t) HASH_DELETE(p, p, controlmap_hash_table(f), k);
 }

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

Here is the call graph for this function:

◆ delete_entity_int()

intptr_t delete_entity_int	(	entity_int	f,
		entity	k
	)

Definition at line 674 of file ri.c.

                                                    {
   return (intptr_t)(intptr_t) HASH_DELETE(p, i, entity_int_hash_table(f), k);
 }

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

Here is the call graph for this function:

◆ delete_entity_to_entity()

entity delete_entity_to_entity	(	entity_to_entity	f,
		entity	k
	)

Definition at line 731 of file ri.c.

                                                              {
   return (entity)(intptr_t) HASH_DELETE(p, p, entity_to_entity_hash_table(f), k);
 }

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

Here is the call graph for this function:

◆ delete_persistant_statement_to_cluster()

intptr_t delete_persistant_statement_to_cluster	(	persistant_statement_to_cluster	f,
		intptr_t	k
	)

Definition at line 1549 of file ri.c.

                                                                                                {
   return (intptr_t)(intptr_t) HASH_DELETE(i, i, persistant_statement_to_cluster_hash_table(f), k);
 }

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

Here is the call graph for this function:

◆ delete_persistant_statement_to_control()

control delete_persistant_statement_to_control	(	persistant_statement_to_control	f,
		statement	k
	)

Definition at line 1606 of file ri.c.

                                                                                                {
   return (control)(intptr_t) HASH_DELETE(p, p, persistant_statement_to_control_hash_table(f), k);
 }

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

Here is the call graph for this function:

◆ delete_persistant_statement_to_int()

intptr_t delete_persistant_statement_to_int	(	persistant_statement_to_int	f,
		statement	k
	)

Definition at line 1663 of file ri.c.

                                                                                         {
   return (intptr_t)(intptr_t) HASH_DELETE(p, i, persistant_statement_to_int_hash_table(f), k);
 }

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

Here is the call graph for this function:

◆ delete_persistant_statement_to_statement()

statement delete_persistant_statement_to_statement	(	persistant_statement_to_statement	f,
		statement	k
	)

Definition at line 1720 of file ri.c.

                                                                                                      {
   return (statement)(intptr_t) HASH_DELETE(p, p, persistant_statement_to_statement_hash_table(f), k);
 }

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

Here is the call graph for this function:

◆ dimension_assign_contents()

void dimension_assign_contents	(	dimension	r,
		dimension	v
	)

Definition at line 548 of file ri.c.

                                                          {
   check_dimension(r);
   check_dimension(v);
   message_assert("defined references to domain dimension",
                  dimension_defined_p(r) && dimension_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_dimension_));
 }

References check_dimension(), dimension_defined_p(), and message_assert.

Here is the call graph for this function:

◆ dimension_consistent_p()

bool dimension_consistent_p ( dimension p )

Definition at line 538 of file ri.c.

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

References check_dimension(), and gen_consistent_p().

Here is the call graph for this function:

◆ dimension_defined_p()

bool dimension_defined_p ( dimension p )

Definition at line 542 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ dimension_non_recursive_free()

void dimension_non_recursive_free ( dimension p )

Definition at line 555 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ dummy_assign_contents()

void dummy_assign_contents	(	dummy	r,
		dummy	v
	)

Definition at line 590 of file ri.c.

                                              {
   check_dummy(r);
   check_dummy(v);
   message_assert("defined references to domain dummy",
                  dummy_defined_p(r) && dummy_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_dummy_));
 }

References check_dummy(), dummy_defined_p(), and message_assert.

Here is the call graph for this function:

◆ dummy_consistent_p()

bool dummy_consistent_p ( dummy p )

Definition at line 580 of file ri.c.

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

References check_dummy(), and gen_consistent_p().

Here is the call graph for this function:

◆ dummy_defined_p()

bool dummy_defined_p ( dummy p )

Definition at line 584 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ dummy_non_recursive_free()

void dummy_non_recursive_free ( dummy p )

Definition at line 597 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ dummy_tag_as_string()

string dummy_tag_as_string ( enum dummy_utype tag )

Definition at line 607 of file ri.c.

                                                  {
   switch (tag) {
   case is_dummy_unknown: return "unknown";
   case is_dummy_identifier: return "identifier";
   default: return string_undefined;
   }
 }

References is_dummy_identifier, is_dummy_unknown, and string_undefined.

◆ entity_assign_contents()

void entity_assign_contents	(	entity	r,
		entity	v
	)

Definition at line 2540 of file ri.c.

                                                 {
   check_entity(r);
   check_entity(v);
   message_assert("defined references to domain entity",
                  entity_defined_p(r) && entity_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_entity_));
 }

References check_entity(), entity_defined_p(), and message_assert.

Here is the call graph for this function:

◆ entity_consistent_p()

bool entity_consistent_p ( entity p )

Definition at line 2530 of file ri.c.

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

References check_entity(), and gen_consistent_p().

Here is the call graph for this function:

◆ entity_defined_p()

bool entity_defined_p ( entity p )

Definition at line 2534 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ entity_int_assign_contents()

void entity_int_assign_contents	(	entity_int	r,
		entity_int	v
	)

Definition at line 645 of file ri.c.

                                                             {
   check_entity_int(r);
   check_entity_int(v);
   message_assert("defined references to domain entity_int",
                  entity_int_defined_p(r) && entity_int_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_entity_int_));
 }

References check_entity_int(), entity_int_defined_p(), and message_assert.

Here is the call graph for this function:

◆ entity_int_consistent_p()

bool entity_int_consistent_p ( entity_int p )

Definition at line 635 of file ri.c.

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

References check_entity_int(), and gen_consistent_p().

Here is the call graph for this function:

◆ entity_int_defined_p()

bool entity_int_defined_p ( entity_int p )

Definition at line 639 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ entity_int_non_recursive_free()

void entity_int_non_recursive_free ( entity_int p )

Definition at line 652 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ entity_non_recursive_free()

void entity_non_recursive_free ( entity p )

Definition at line 2547 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ entity_to_entity_assign_contents()

void entity_to_entity_assign_contents	(	entity_to_entity	r,
		entity_to_entity	v
	)

Definition at line 702 of file ri.c.

                                                                               {
   check_entity_to_entity(r);
   check_entity_to_entity(v);
   message_assert("defined references to domain entity_to_entity",
                  entity_to_entity_defined_p(r) && entity_to_entity_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_entity_to_entity_));
 }

References check_entity_to_entity(), entity_to_entity_defined_p(), and message_assert.

Here is the call graph for this function:

◆ entity_to_entity_consistent_p()

bool entity_to_entity_consistent_p ( entity_to_entity p )

Definition at line 692 of file ri.c.

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

References check_entity_to_entity(), and gen_consistent_p().

Here is the call graph for this function:

◆ entity_to_entity_defined_p()

bool entity_to_entity_defined_p ( entity_to_entity p )

Definition at line 696 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ entity_to_entity_non_recursive_free()

void entity_to_entity_non_recursive_free ( entity_to_entity p )

Definition at line 709 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ evaluation_assign_contents()

void evaluation_assign_contents	(	evaluation	r,
		evaluation	v
	)

Definition at line 759 of file ri.c.

                                                             {
   check_evaluation(r);
   check_evaluation(v);
   message_assert("defined references to domain evaluation",
                  evaluation_defined_p(r) && evaluation_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_evaluation_));
 }

References check_evaluation(), evaluation_defined_p(), and message_assert.

Here is the call graph for this function:

◆ evaluation_consistent_p()

bool evaluation_consistent_p ( evaluation p )

Definition at line 749 of file ri.c.

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

References check_evaluation(), and gen_consistent_p().

Here is the call graph for this function:

◆ evaluation_defined_p()

bool evaluation_defined_p ( evaluation p )

Definition at line 753 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ evaluation_non_recursive_free()

void evaluation_non_recursive_free ( evaluation p )

Definition at line 766 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ evaluation_tag_as_string()

string evaluation_tag_as_string ( enum evaluation_utype tag )

Definition at line 776 of file ri.c.

                                                            {
   switch (tag) {
   case is_evaluation_before: return "before";
   case is_evaluation_after: return "after";
   default: return string_undefined;
   }
 }

References is_evaluation_after, is_evaluation_before, and string_undefined.

◆ execution_assign_contents()

void execution_assign_contents	(	execution	r,
		execution	v
	)

Definition at line 814 of file ri.c.

                                                          {
   check_execution(r);
   check_execution(v);
   message_assert("defined references to domain execution",
                  execution_defined_p(r) && execution_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_execution_));
 }

References check_execution(), execution_defined_p(), and message_assert.

Here is the call graph for this function:

◆ execution_consistent_p()

bool execution_consistent_p ( execution p )

Definition at line 804 of file ri.c.

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

References check_execution(), and gen_consistent_p().

Here is the call graph for this function:

◆ execution_defined_p()

bool execution_defined_p ( execution p )

Definition at line 808 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ execution_non_recursive_free()

void execution_non_recursive_free ( execution p )

Definition at line 821 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ execution_tag_as_string()

string execution_tag_as_string ( enum execution_utype tag )

Definition at line 831 of file ri.c.

                                                          {
   switch (tag) {
   case is_execution_sequential: return "sequential";
   case is_execution_parallel: return "parallel";
   default: return string_undefined;
   }
 }

References is_execution_parallel, is_execution_sequential, and string_undefined.

◆ expression_assign_contents()

void expression_assign_contents	(	expression	r,
		expression	v
	)

Definition at line 869 of file ri.c.

                                                             {
   check_expression(r);
   check_expression(v);
   message_assert("defined references to domain expression",
                  expression_defined_p(r) && expression_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_expression_));
 }

References check_expression(), expression_defined_p(), and message_assert.

Here is the call graph for this function:

◆ expression_consistent_p()

bool expression_consistent_p ( expression p )

Definition at line 859 of file ri.c.

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

References check_expression(), and gen_consistent_p().

Here is the call graph for this function:

◆ expression_defined_p()

bool expression_defined_p ( expression p )

Definition at line 863 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ expression_non_recursive_free()

void expression_non_recursive_free ( expression p )

Definition at line 876 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ extend_controlmap()

void extend_controlmap	(	controlmap	f,
		statement	k,
		control	v
	)

Definition at line 475 of file ri.c.

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

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

Here is the call graph for this function:

◆ extend_entity_int()

void extend_entity_int	(	entity_int	f,
		entity	k,
		intptr_t	v
	)

Definition at line 671 of file ri.c.

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

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

Here is the call graph for this function:

◆ extend_entity_to_entity()

void extend_entity_to_entity	(	entity_to_entity	f,
		entity	k,
		entity	v
	)

Definition at line 728 of file ri.c.

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

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

Here is the call graph for this function:

◆ extend_persistant_statement_to_cluster()

void extend_persistant_statement_to_cluster	(	persistant_statement_to_cluster	f,
		intptr_t	k,
		intptr_t	v
	)

Definition at line 1546 of file ri.c.

                                                                                                        {
   HASH_EXTEND(i, i, persistant_statement_to_cluster_hash_table(f), k, (intptr_t)v);
 }

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

Here is the call graph for this function:

◆ extend_persistant_statement_to_control()

void extend_persistant_statement_to_control	(	persistant_statement_to_control	f,
		statement	k,
		control	v
	)

Definition at line 1603 of file ri.c.

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

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

Here is the call graph for this function:

◆ extend_persistant_statement_to_int()

void extend_persistant_statement_to_int	(	persistant_statement_to_int	f,
		statement	k,
		intptr_t	v
	)

Definition at line 1660 of file ri.c.

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

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

Here is the call graph for this function:

◆ extend_persistant_statement_to_statement()

void extend_persistant_statement_to_statement	(	persistant_statement_to_statement	f,
		statement	k,
		statement	v
	)

Definition at line 1717 of file ri.c.

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

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

Here is the call graph for this function:

◆ extension_assign_contents()

void extension_assign_contents	(	extension	r,
		extension	v
	)

Definition at line 911 of file ri.c.

                                                          {
   check_extension(r);
   check_extension(v);
   message_assert("defined references to domain extension",
                  extension_defined_p(r) && extension_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_extension_));
 }

References check_extension(), extension_defined_p(), and message_assert.

Here is the call graph for this function:

◆ extension_consistent_p()

bool extension_consistent_p ( extension p )

Definition at line 901 of file ri.c.

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

References check_extension(), and gen_consistent_p().

Here is the call graph for this function:

◆ extension_defined_p()

bool extension_defined_p ( extension p )

Definition at line 905 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ extension_non_recursive_free()

void extension_non_recursive_free ( extension p )

Definition at line 918 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ extension_tag_as_string()

string extension_tag_as_string ( enum extension_utype tag )

Definition at line 928 of file ri.c.

                                                          {
   switch (tag) {
   case is_extension_pragma: return "pragma";
   case is_extension_unknown: return "unknown";
   default: return string_undefined;
   }
 }

References is_extension_pragma, is_extension_unknown, and string_undefined.

◆ extensions_assign_contents()

void extensions_assign_contents	(	extensions	r,
		extensions	v
	)

Definition at line 966 of file ri.c.

                                                             {
   check_extensions(r);
   check_extensions(v);
   message_assert("defined references to domain extensions",
                  extensions_defined_p(r) && extensions_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_extensions_));
 }

References check_extensions(), extensions_defined_p(), and message_assert.

Here is the call graph for this function:

◆ extensions_consistent_p()

bool extensions_consistent_p ( extensions p )

Definition at line 956 of file ri.c.

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

References check_extensions(), and gen_consistent_p().

Here is the call graph for this function:

◆ extensions_defined_p()

bool extensions_defined_p ( extensions p )

Definition at line 960 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ extensions_non_recursive_free()

void extensions_non_recursive_free ( extensions p )

Definition at line 973 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ forloop_assign_contents()

void forloop_assign_contents	(	forloop	r,
		forloop	v
	)

Definition at line 1008 of file ri.c.

                                                    {
   check_forloop(r);
   check_forloop(v);
   message_assert("defined references to domain forloop",
                  forloop_defined_p(r) && forloop_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_forloop_));
 }

References check_forloop(), forloop_defined_p(), and message_assert.

Here is the call graph for this function:

◆ forloop_consistent_p()

bool forloop_consistent_p ( forloop p )

Definition at line 998 of file ri.c.

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

References check_forloop(), and gen_consistent_p().

Here is the call graph for this function:

◆ forloop_defined_p()

bool forloop_defined_p ( forloop p )

Definition at line 1002 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ forloop_non_recursive_free()

void forloop_non_recursive_free ( forloop p )

Definition at line 1015 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ formal_assign_contents()

void formal_assign_contents	(	formal	r,
		formal	v
	)

Definition at line 1050 of file ri.c.

                                                 {
   check_formal(r);
   check_formal(v);
   message_assert("defined references to domain formal",
                  formal_defined_p(r) && formal_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_formal_));
 }

References check_formal(), formal_defined_p(), and message_assert.

Here is the call graph for this function:

◆ formal_consistent_p()

bool formal_consistent_p ( formal p )

Definition at line 1040 of file ri.c.

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

References check_formal(), and gen_consistent_p().

Here is the call graph for this function:

◆ formal_defined_p()

bool formal_defined_p ( formal p )

Definition at line 1044 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ formal_non_recursive_free()

void formal_non_recursive_free ( formal p )

Definition at line 1057 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ free_application()

void free_application ( application p )

Definition at line 23 of file ri.c.

                                      {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_area()

void free_area ( area p )

Definition at line 65 of file ri.c.

                        {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_basic()

void free_basic ( basic p )

Definition at line 107 of file ri.c.

                          {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_call()

void free_call ( call p )

Definition at line 236 of file ri.c.

                        {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_callees()

void free_callees ( callees p )

Definition at line 194 of file ri.c.

                              {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_cast()

void free_cast ( cast p )

Definition at line 278 of file ri.c.

                        {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_code()

void free_code ( code p )

Definition at line 320 of file ri.c.

                        {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_constant()

void free_constant ( constant p )

Definition at line 362 of file ri.c.

                                {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_control()

void free_control ( control p )

Definition at line 490 of file ri.c.

                              {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_controlmap()

void free_controlmap ( controlmap p )

Definition at line 433 of file ri.c.

                                    {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_dimension()

void free_dimension ( dimension p )

Definition at line 532 of file ri.c.

                                  {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_dummy()

void free_dummy ( dummy p )

Definition at line 574 of file ri.c.

                          {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_entity()

void free_entity ( entity p )

Definition at line 2524 of file ri.c.

                            {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_entity_int()

void free_entity_int ( entity_int p )

Definition at line 629 of file ri.c.

                                    {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_entity_to_entity()

void free_entity_to_entity ( entity_to_entity p )

Definition at line 686 of file ri.c.

                                                {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_evaluation()

void free_evaluation ( evaluation p )

Definition at line 743 of file ri.c.

                                    {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_execution()

void free_execution ( execution p )

Definition at line 798 of file ri.c.

                                  {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_expression()

void free_expression ( expression p )

Definition at line 853 of file ri.c.

                                    {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_extension()

void free_extension ( extension p )

Definition at line 895 of file ri.c.

                                  {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_extensions()

void free_extensions ( extensions p )

Definition at line 950 of file ri.c.

                                    {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_forloop()

void free_forloop ( forloop p )

Definition at line 992 of file ri.c.

                              {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_formal()

void free_formal ( formal p )

Definition at line 1034 of file ri.c.

                            {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_functional()

void free_functional ( functional p )

Definition at line 1076 of file ri.c.

                                    {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_instruction()

void free_instruction ( instruction p )

Definition at line 1118 of file ri.c.

                                      {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_language()

void free_language ( language p )

Definition at line 1205 of file ri.c.

                                {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_loop()

void free_loop ( loop p )

Definition at line 1268 of file ri.c.

                        {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_mode()

void free_mode ( mode p )

Definition at line 1310 of file ri.c.

                        {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_multitest()

void free_multitest ( multitest p )

Definition at line 1365 of file ri.c.

                                  {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_normalized()

void free_normalized ( normalized p )

Definition at line 1407 of file ri.c.

                                    {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_parameter()

void free_parameter ( parameter p )

Definition at line 1462 of file ri.c.

                                  {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_persistant_statement_to_cluster()

void free_persistant_statement_to_cluster ( persistant_statement_to_cluster p )

Definition at line 1504 of file ri.c.

                                                                              {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_persistant_statement_to_control()

void free_persistant_statement_to_control ( persistant_statement_to_control p )

Definition at line 1561 of file ri.c.

                                                                              {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_persistant_statement_to_int()

void free_persistant_statement_to_int ( persistant_statement_to_int p )

Definition at line 1618 of file ri.c.

                                                                      {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_persistant_statement_to_statement()

void free_persistant_statement_to_statement ( persistant_statement_to_statement p )

Definition at line 1675 of file ri.c.

                                                                                  {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_pragma()

void free_pragma ( pragma p )

Definition at line 1732 of file ri.c.

                            {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_predicate()

void free_predicate ( predicate p )

Definition at line 1787 of file ri.c.

                                  {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_preference()

void free_preference ( preference p )

Definition at line 1829 of file ri.c.

                                    {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_qualifier()

void free_qualifier ( qualifier p )

Definition at line 1871 of file ri.c.

                                  {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_ram()

void free_ram ( ram p )

Definition at line 1966 of file ri.c.

                      {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_range()

void free_range ( range p )

Definition at line 2008 of file ri.c.

                          {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_reference()

void free_reference ( reference p )

Definition at line 2050 of file ri.c.

                                  {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_sequence()

void free_sequence ( sequence p )

Definition at line 2092 of file ri.c.

                                {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_sizeofexpression()

void free_sizeofexpression ( sizeofexpression p )

Definition at line 2134 of file ri.c.

                                                {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_statement()

void free_statement ( statement p )

Definition at line 2189 of file ri.c.

                                  {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_storage()

void free_storage ( storage p )

Definition at line 2231 of file ri.c.

                              {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_subscript()

void free_subscript ( subscript p )

Definition at line 2294 of file ri.c.

                                  {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_symbolic()

void free_symbolic ( symbolic p )

Definition at line 2336 of file ri.c.

                                {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_synchronization()

void free_synchronization ( synchronization p )

Definition at line 2378 of file ri.c.

                                              {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_syntax()

void free_syntax ( syntax p )

Definition at line 2445 of file ri.c.

                            {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_test()

void free_test ( test p )

Definition at line 2574 of file ri.c.

                        {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_transformer()

void free_transformer ( transformer p )

Definition at line 2616 of file ri.c.

                                      {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_type()

void free_type ( type p )

Definition at line 2658 of file ri.c.

                        {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_unstructured()

void free_unstructured ( unstructured p )

Definition at line 2745 of file ri.c.

                                        {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_value()

void free_value ( value p )

Definition at line 2787 of file ri.c.

                          {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_variable()

void free_variable ( variable p )

Definition at line 2862 of file ri.c.

                                {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ free_whileloop()

void free_whileloop ( whileloop p )

Definition at line 2904 of file ri.c.

                                  {
   gen_free((gen_chunk*) p);
 }

References gen_free().

Here is the call graph for this function:

◆ functional_assign_contents()

void functional_assign_contents	(	functional	r,
		functional	v
	)

Definition at line 1092 of file ri.c.

                                                             {
   check_functional(r);
   check_functional(v);
   message_assert("defined references to domain functional",
                  functional_defined_p(r) && functional_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_functional_));
 }

References check_functional(), functional_defined_p(), and message_assert.

Here is the call graph for this function:

◆ functional_consistent_p()

bool functional_consistent_p ( functional p )

Definition at line 1082 of file ri.c.

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

References check_functional(), and gen_consistent_p().

Here is the call graph for this function:

◆ functional_defined_p()

bool functional_defined_p ( functional p )

Definition at line 1086 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ functional_non_recursive_free()

void functional_non_recursive_free ( functional p )

Definition at line 1099 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ gen_application_cons()

list gen_application_cons	(	application	p,
		list	l
	)

Definition at line 36 of file ri.c.

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

References APPLICATION_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_area_cons()

list gen_area_cons	(	area	p,
		list	l
	)

Definition at line 78 of file ri.c.

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

References AREA_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_basic_cons()

list gen_basic_cons	(	basic	p,
		list	l
	)

Definition at line 120 of file ri.c.

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

References BASIC_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_call_cons()

list gen_call_cons	(	call	p,
		list	l
	)

Definition at line 249 of file ri.c.

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

References CALL_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_callees_cons()

list gen_callees_cons	(	callees	p,
		list	l
	)

Definition at line 207 of file ri.c.

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

References CALLEES_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_cast_cons()

list gen_cast_cons	(	cast	p,
		list	l
	)

Definition at line 291 of file ri.c.

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

References CAST_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_code_cons()

list gen_code_cons	(	code	p,
		list	l
	)

Definition at line 333 of file ri.c.

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

References CODE_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_constant_cons()

list gen_constant_cons	(	constant	p,
		list	l
	)

Definition at line 375 of file ri.c.

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

References CONSTANT_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_control_cons()

list gen_control_cons	(	control	p,
		list	l
	)

Definition at line 503 of file ri.c.

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

References CONTROL_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_controlmap_cons()

list gen_controlmap_cons	(	controlmap	p,
		list	l
	)

Definition at line 446 of file ri.c.

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

References CONTROLMAP_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_dimension_cons()

list gen_dimension_cons	(	dimension	p,
		list	l
	)

Definition at line 545 of file ri.c.

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

References DIMENSION_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_dummy_cons()

list gen_dummy_cons	(	dummy	p,
		list	l
	)

Definition at line 587 of file ri.c.

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

References DUMMY_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_entity_cons()

list gen_entity_cons	(	entity	p,
		list	l
	)

Definition at line 2537 of file ri.c.

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

References ENTITY_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_entity_int_cons()

list gen_entity_int_cons	(	entity_int	p,
		list	l
	)

Definition at line 642 of file ri.c.

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

References ENTITY_INT_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_entity_to_entity_cons()

list gen_entity_to_entity_cons	(	entity_to_entity	p,
		list	l
	)

Definition at line 699 of file ri.c.

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

References ENTITY_TO_ENTITY_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_evaluation_cons()

list gen_evaluation_cons	(	evaluation	p,
		list	l
	)

Definition at line 756 of file ri.c.

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

References EVALUATION_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_execution_cons()

list gen_execution_cons	(	execution	p,
		list	l
	)

Definition at line 811 of file ri.c.

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

References EXECUTION_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_expression_cons()

list gen_expression_cons	(	expression	p,
		list	l
	)

Definition at line 866 of file ri.c.

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

References EXPRESSION_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_extension_cons()

list gen_extension_cons	(	extension	p,
		list	l
	)

Definition at line 908 of file ri.c.

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

References EXTENSION_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_extensions_cons()

list gen_extensions_cons	(	extensions	p,
		list	l
	)

Definition at line 963 of file ri.c.

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

References EXTENSIONS_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_find_entity()

entity gen_find_entity ( char * s )

Definition at line 2551 of file ri.c.

                                 {
   return (entity) gen_find_tabulated(s, entity_domain);
 }

References entity_domain, and gen_find_tabulated().

Here is the call graph for this function:

◆ gen_forloop_cons()

list gen_forloop_cons	(	forloop	p,
		list	l
	)

Definition at line 1005 of file ri.c.

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

References FORLOOP_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_formal_cons()

list gen_formal_cons	(	formal	p,
		list	l
	)

Definition at line 1047 of file ri.c.

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

References FORMAL_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_functional_cons()

list gen_functional_cons	(	functional	p,
		list	l
	)

Definition at line 1089 of file ri.c.

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

References FUNCTIONAL_NEWGEN_DOMAIN, and gen_typed_cons().

Here is the call graph for this function:

◆ gen_instruction_cons()

list gen_instruction_cons	(	instruction	p,
		list	l
	)

Definition at line 1131 of file ri.c.

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

References gen_typed_cons(), and INSTRUCTION_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_language_cons()

list gen_language_cons	(	language	p,
		list	l
	)

Definition at line 1218 of file ri.c.

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

References gen_typed_cons(), and LANGUAGE_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_loop_cons()

list gen_loop_cons	(	loop	p,
		list	l
	)

Definition at line 1281 of file ri.c.

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

References gen_typed_cons(), and LOOP_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_mode_cons()

list gen_mode_cons	(	mode	p,
		list	l
	)

Definition at line 1323 of file ri.c.

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

References gen_typed_cons(), and MODE_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_multitest_cons()

list gen_multitest_cons	(	multitest	p,
		list	l
	)

Definition at line 1378 of file ri.c.

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

References gen_typed_cons(), and MULTITEST_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_normalized_cons()

list gen_normalized_cons	(	normalized	p,
		list	l
	)

Definition at line 1420 of file ri.c.

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

References gen_typed_cons(), and NORMALIZED_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_parameter_cons()

list gen_parameter_cons	(	parameter	p,
		list	l
	)

Definition at line 1475 of file ri.c.

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

References gen_typed_cons(), and PARAMETER_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_persistant_statement_to_cluster_cons()

list gen_persistant_statement_to_cluster_cons	(	persistant_statement_to_cluster	p,
		list	l
	)

Definition at line 1517 of file ri.c.

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

References gen_typed_cons(), and PERSISTANT_STATEMENT_TO_CLUSTER_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_persistant_statement_to_control_cons()

list gen_persistant_statement_to_control_cons	(	persistant_statement_to_control	p,
		list	l
	)

Definition at line 1574 of file ri.c.

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

References gen_typed_cons(), and PERSISTANT_STATEMENT_TO_CONTROL_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_persistant_statement_to_int_cons()

list gen_persistant_statement_to_int_cons	(	persistant_statement_to_int	p,
		list	l
	)

Definition at line 1631 of file ri.c.

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

References gen_typed_cons(), and PERSISTANT_STATEMENT_TO_INT_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_persistant_statement_to_statement_cons()

list gen_persistant_statement_to_statement_cons	(	persistant_statement_to_statement	p,
		list	l
	)

Definition at line 1688 of file ri.c.

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

References gen_typed_cons(), and PERSISTANT_STATEMENT_TO_STATEMENT_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_pragma_cons()

list gen_pragma_cons	(	pragma	p,
		list	l
	)

Definition at line 1745 of file ri.c.

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

References gen_typed_cons(), and PRAGMA_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_predicate_cons()

list gen_predicate_cons	(	predicate	p,
		list	l
	)

Definition at line 1800 of file ri.c.

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

References gen_typed_cons(), and PREDICATE_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_preference_cons()

list gen_preference_cons	(	preference	p,
		list	l
	)

Definition at line 1842 of file ri.c.

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

References gen_typed_cons(), and PREFERENCE_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_qualifier_cons()

list gen_qualifier_cons	(	qualifier	p,
		list	l
	)

Definition at line 1884 of file ri.c.

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

References gen_typed_cons(), and QUALIFIER_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_ram_cons()

list gen_ram_cons	(	ram	p,
		list	l
	)

Definition at line 1979 of file ri.c.

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

References gen_typed_cons(), and RAM_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_range_cons()

list gen_range_cons	(	range	p,
		list	l
	)

Definition at line 2021 of file ri.c.

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

References gen_typed_cons(), and RANGE_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_reference_cons()

list gen_reference_cons	(	reference	p,
		list	l
	)

Definition at line 2063 of file ri.c.

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

References gen_typed_cons(), and REFERENCE_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_sequence_cons()

list gen_sequence_cons	(	sequence	p,
		list	l
	)

Definition at line 2105 of file ri.c.

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

References gen_typed_cons(), and SEQUENCE_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_sizeofexpression_cons()

list gen_sizeofexpression_cons	(	sizeofexpression	p,
		list	l
	)

Definition at line 2147 of file ri.c.

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

References gen_typed_cons(), and SIZEOFEXPRESSION_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_statement_cons()

list gen_statement_cons	(	statement	p,
		list	l
	)

Definition at line 2202 of file ri.c.

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

References gen_typed_cons(), and STATEMENT_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_storage_cons()

list gen_storage_cons	(	storage	p,
		list	l
	)

Definition at line 2244 of file ri.c.

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

References gen_typed_cons(), and STORAGE_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_subscript_cons()

list gen_subscript_cons	(	subscript	p,
		list	l
	)

Definition at line 2307 of file ri.c.

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

References gen_typed_cons(), and SUBSCRIPT_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_symbolic_cons()

list gen_symbolic_cons	(	symbolic	p,
		list	l
	)

Definition at line 2349 of file ri.c.

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

References gen_typed_cons(), and SYMBOLIC_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_synchronization_cons()

list gen_synchronization_cons	(	synchronization	p,
		list	l
	)

Definition at line 2391 of file ri.c.

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

References gen_typed_cons(), and SYNCHRONIZATION_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_syntax_cons()

list gen_syntax_cons	(	syntax	p,
		list	l
	)

Definition at line 2458 of file ri.c.

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

References gen_typed_cons(), and SYNTAX_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_test_cons()

list gen_test_cons	(	test	p,
		list	l
	)

Definition at line 2587 of file ri.c.

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

References gen_typed_cons(), and TEST_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_transformer_cons()

list gen_transformer_cons	(	transformer	p,
		list	l
	)

Definition at line 2629 of file ri.c.

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

References gen_typed_cons(), and TRANSFORMER_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_type_cons()

list gen_type_cons	(	type	p,
		list	l
	)

Definition at line 2671 of file ri.c.

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

References gen_typed_cons(), and TYPE_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_unstructured_cons()

list gen_unstructured_cons	(	unstructured	p,
		list	l
	)

Definition at line 2758 of file ri.c.

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

References gen_typed_cons(), and UNSTRUCTURED_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_value_cons()

list gen_value_cons	(	value	p,
		list	l
	)

Definition at line 2800 of file ri.c.

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

References gen_typed_cons(), and VALUE_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_variable_cons()

list gen_variable_cons	(	variable	p,
		list	l
	)

Definition at line 2875 of file ri.c.

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

References gen_typed_cons(), and VARIABLE_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ gen_whileloop_cons()

list gen_whileloop_cons	(	whileloop	p,
		list	l
	)

Definition at line 2917 of file ri.c.

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

References gen_typed_cons(), and WHILELOOP_NEWGEN_DOMAIN.

Here is the call graph for this function:

◆ instruction_assign_contents()

void instruction_assign_contents	(	instruction	r,
		instruction	v
	)

Definition at line 1134 of file ri.c.

                                                                {
   check_instruction(r);
   check_instruction(v);
   message_assert("defined references to domain instruction",
                  instruction_defined_p(r) && instruction_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_instruction_));
 }

References check_instruction(), instruction_defined_p(), and message_assert.

Here is the call graph for this function:

◆ instruction_consistent_p()

bool instruction_consistent_p ( instruction p )

Definition at line 1124 of file ri.c.

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

References check_instruction(), and gen_consistent_p().

Here is the call graph for this function:

◆ instruction_defined_p()

bool instruction_defined_p ( instruction p )

Definition at line 1128 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ instruction_non_recursive_free()

void instruction_non_recursive_free ( instruction p )

Definition at line 1141 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ instruction_tag_as_string()

string instruction_tag_as_string ( enum instruction_utype tag )

Definition at line 1151 of file ri.c.

                                                              {
   switch (tag) {
   case is_instruction_sequence: return "sequence";
   case is_instruction_test: return "test";
   case is_instruction_loop: return "loop";
   case is_instruction_whileloop: return "whileloop";
   case is_instruction_goto: return "goto";
   case is_instruction_call: return "call";
   case is_instruction_unstructured: return "unstructured";
   case is_instruction_multitest: return "multitest";
   case is_instruction_forloop: return "forloop";
   case is_instruction_expression: return "expression";
   default: return string_undefined;
   }
 }

References is_instruction_call, is_instruction_expression, is_instruction_forloop, is_instruction_goto, is_instruction_loop, is_instruction_multitest, is_instruction_sequence, is_instruction_test, is_instruction_unstructured, is_instruction_whileloop, and string_undefined.

◆ language_assign_contents()

void language_assign_contents	(	language	r,
		language	v
	)

Definition at line 1221 of file ri.c.

                                                       {
   check_language(r);
   check_language(v);
   message_assert("defined references to domain language",
                  language_defined_p(r) && language_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_language_));
 }

References check_language(), language_defined_p(), and message_assert.

Here is the call graph for this function:

◆ language_consistent_p()

bool language_consistent_p ( language p )

Definition at line 1211 of file ri.c.

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

References check_language(), and gen_consistent_p().

Here is the call graph for this function:

◆ language_defined_p()

bool language_defined_p ( language p )

Definition at line 1215 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ language_non_recursive_free()

void language_non_recursive_free ( language p )

Definition at line 1228 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ language_tag_as_string()

string language_tag_as_string ( enum language_utype tag )

Definition at line 1238 of file ri.c.

                                                        {
   switch (tag) {
   case is_language_fortran: return "fortran";
   case is_language_c: return "c";
   case is_language_fortran95: return "fortran95";
   case is_language_unknown: return "unknown";
   default: return string_undefined;
   }
 }

References is_language_c, is_language_fortran, is_language_fortran95, is_language_unknown, and string_undefined.

◆ loop_assign_contents()

void loop_assign_contents	(	loop	r,
		loop	v
	)

Definition at line 1284 of file ri.c.

                                           {
   check_loop(r);
   check_loop(v);
   message_assert("defined references to domain loop",
                  loop_defined_p(r) && loop_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_loop_));
 }

References check_loop(), loop_defined_p(), and message_assert.

Here is the call graph for this function:

◆ loop_consistent_p()

bool loop_consistent_p ( loop p )

Definition at line 1274 of file ri.c.

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

References check_loop(), and gen_consistent_p().

Here is the call graph for this function:

◆ loop_defined_p()

bool loop_defined_p ( loop p )

Definition at line 1278 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ loop_non_recursive_free()

void loop_non_recursive_free ( loop p )

Definition at line 1291 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ make_application()

application make_application	(	expression	a1,
		list	a2
	)

Definition at line 56 of file ri.c.

                                                      {
   return (application) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, application_domain, a1, a2);
 }

References application_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_area()

area make_area	(	intptr_t	a1,
		list	a2
	)

Definition at line 98 of file ri.c.

                                      {
   return (area) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, area_domain, a1, a2);
 }

References area_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_basic()

basic make_basic	(	enum basic_utype	tag,
		void *	val
	)

Definition at line 155 of file ri.c.

                                                    {
   return (basic) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, basic_domain, tag, val);
 }

References basic_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_basic_bit()

basic make_basic_bit ( symbolic _field_ )

Definition at line 176 of file ri.c.

                                        {
   return make_basic(is_basic_bit, (void*)(intptr_t) _field_);
 }

References intptr_t, is_basic_bit, and make_basic().

Here is the call graph for this function:

◆ make_basic_complex()

basic make_basic_complex ( intptr_t _field_ )

Definition at line 170 of file ri.c.

                                            {
   return make_basic(is_basic_complex, (void*)(intptr_t) _field_);
 }

References intptr_t, is_basic_complex, and make_basic().

Here is the call graph for this function:

◆ make_basic_derived()

basic make_basic_derived ( entity _field_ )

Definition at line 182 of file ri.c.

                                          {
   return make_basic(is_basic_derived, (void*)(intptr_t) _field_);
 }

References intptr_t, is_basic_derived, and make_basic().

Here is the call graph for this function:

◆ make_basic_float()

basic make_basic_float ( intptr_t _field_ )

Definition at line 161 of file ri.c.

                                          {
   return make_basic(is_basic_float, (void*)(intptr_t) _field_);
 }

References intptr_t, is_basic_float, and make_basic().

Here is the call graph for this function:

◆ make_basic_int()

basic make_basic_int ( intptr_t _field_ )

Definition at line 158 of file ri.c.

                                        {
   return make_basic(is_basic_int, (void*)(intptr_t) _field_);
 }

References intptr_t, is_basic_int, and make_basic().

Here is the call graph for this function:

◆ make_basic_logical()

basic make_basic_logical ( intptr_t _field_ )

Definition at line 164 of file ri.c.

                                            {
   return make_basic(is_basic_logical, (void*)(intptr_t) _field_);
 }

References intptr_t, is_basic_logical, and make_basic().

Here is the call graph for this function:

◆ make_basic_overloaded()

basic make_basic_overloaded ( void )

Definition at line 167 of file ri.c.

                                   {
   return make_basic(is_basic_overloaded, UU);
 }

References is_basic_overloaded, make_basic(), and UU.

Here is the call graph for this function:

◆ make_basic_pointer()

basic make_basic_pointer ( type _field_ )

Definition at line 179 of file ri.c.

                                        {
   return make_basic(is_basic_pointer, (void*)(intptr_t) _field_);
 }

References intptr_t, is_basic_pointer, and make_basic().

Here is the call graph for this function:

◆ make_basic_string()

basic make_basic_string ( value _field_ )

Definition at line 173 of file ri.c.

                                        {
   return make_basic(is_basic_string, (void*)(intptr_t) _field_);
 }

References intptr_t, is_basic_string, and make_basic().

Here is the call graph for this function:

◆ make_basic_typedef()

basic make_basic_typedef ( entity _field_ )

Definition at line 185 of file ri.c.

                                          {
   return make_basic(is_basic_typedef, (void*)(intptr_t) _field_);
 }

References intptr_t, is_basic_typedef, and make_basic().

Here is the call graph for this function:

◆ make_call()

call make_call	(	entity	a1,
		list	a2
	)

Definition at line 269 of file ri.c.

                                    {
   return (call) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, call_domain, a1, a2);
 }

References call_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_callees()

callees make_callees ( list a )

Definition at line 227 of file ri.c.

                              {
   return (callees) gen_alloc(2*sizeof(gen_chunk), GEN_CHECK_ALLOC, callees_domain, a);
 }

References callees_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_cast()

cast make_cast	(	type	a1,
		expression	a2
	)

Definition at line 311 of file ri.c.

                                        {
   return (cast) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, cast_domain, a1, a2);
 }

References cast_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_code()

code make_code	(	list	a1,
		string	a2,
		sequence	a3,
		list	a4,
		language	a5
	)

Definition at line 353 of file ri.c.

                                                                       {
   return (code) gen_alloc(6*sizeof(gen_chunk), GEN_CHECK_ALLOC, code_domain, a1, a2, a3, a4, a5);
 }

References code_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_constant()

constant make_constant	(	enum constant_utype	tag,
		void *	val
	)

Definition at line 406 of file ri.c.

                                                             {
   return (constant) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, constant_domain, tag, val);
 }

References constant_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_constant_call()

constant make_constant_call ( entity _field_ )

Definition at line 421 of file ri.c.

                                             {
   return make_constant(is_constant_call, (void*)(intptr_t) _field_);
 }

References intptr_t, is_constant_call, and make_constant().

Here is the call graph for this function:

◆ make_constant_float()

constant make_constant_float ( float _field_ )

Definition at line 412 of file ri.c.

                                             {
   return make_constant(is_constant_float, (void*)(intptr_t) _field_);
 }

References intptr_t, is_constant_float, and make_constant().

Here is the call graph for this function:

◆ make_constant_int()

constant make_constant_int ( intptr_t _field_ )

Definition at line 409 of file ri.c.

                                              {
   return make_constant(is_constant_int, (void*)(intptr_t) _field_);
 }

References intptr_t, is_constant_int, and make_constant().

Here is the call graph for this function:

◆ make_constant_litteral()

constant make_constant_litteral ( void )

Definition at line 418 of file ri.c.

                                       {
   return make_constant(is_constant_litteral, UU);
 }

References is_constant_litteral, make_constant(), and UU.

Here is the call graph for this function:

◆ make_constant_logical()

constant make_constant_logical ( intptr_t _field_ )

Definition at line 415 of file ri.c.

                                                  {
   return make_constant(is_constant_logical, (void*)(intptr_t) _field_);
 }

References intptr_t, is_constant_logical, and make_constant().

Here is the call graph for this function:

◆ make_constant_unknown()

constant make_constant_unknown ( void )

Definition at line 424 of file ri.c.

                                      {
   return make_constant(is_constant_unknown, UU);
 }

References is_constant_unknown, make_constant(), and UU.

Here is the call graph for this function:

◆ make_control()

control make_control	(	statement	a1,
		list	a2,
		list	a3
	)

Definition at line 523 of file ri.c.

                                                      {
   return (control) gen_alloc(4*sizeof(gen_chunk), GEN_CHECK_ALLOC, control_domain, a1, a2, a3);
 }

References control_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_controlmap()

controlmap make_controlmap ( void )

Definition at line 466 of file ri.c.

                                  {
   return (controlmap) gen_alloc(2*sizeof(gen_chunk), GEN_CHECK_ALLOC, controlmap_domain);
 }

References controlmap_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_dimension()

dimension make_dimension	(	expression	a1,
		expression	a2,
		list	a3
	)

Definition at line 565 of file ri.c.

                                                                 {
   return (dimension) gen_alloc(4*sizeof(gen_chunk), GEN_CHECK_ALLOC, dimension_domain, a1, a2, a3);
 }

References dimension_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_dummy()

dummy make_dummy	(	enum dummy_utype	tag,
		void *	val
	)

Definition at line 614 of file ri.c.

                                                    {
   return (dummy) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, dummy_domain, tag, val);
 }

References dummy_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_dummy_identifier()

dummy make_dummy_identifier ( entity _field_ )

Definition at line 620 of file ri.c.

                                             {
   return make_dummy(is_dummy_identifier, (void*)(intptr_t) _field_);
 }

References intptr_t, is_dummy_identifier, and make_dummy().

Here is the call graph for this function:

◆ make_dummy_unknown()

dummy make_dummy_unknown ( void )

Definition at line 617 of file ri.c.

                                {
   return make_dummy(is_dummy_unknown, UU);
 }

References is_dummy_unknown, make_dummy(), and UU.

Here is the call graph for this function:

◆ make_entity()

entity make_entity	(	string	a1,
		type	a2,
		storage	a3,
		value	a4,
		intptr_t	a5
	)

Definition at line 2565 of file ri.c.

                                                                           {
   return (entity) gen_alloc(7*sizeof(gen_chunk), GEN_CHECK_ALLOC, entity_domain, a1, a2, a3, a4, a5);
 }

References entity_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_entity_int()

entity_int make_entity_int ( void )

Definition at line 662 of file ri.c.

                                  {
   return (entity_int) gen_alloc(2*sizeof(gen_chunk), GEN_CHECK_ALLOC, entity_int_domain);
 }

References entity_int_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_entity_to_entity()

entity_to_entity make_entity_to_entity ( void )

Definition at line 719 of file ri.c.

                                              {
   return (entity_to_entity) gen_alloc(2*sizeof(gen_chunk), GEN_CHECK_ALLOC, entity_to_entity_domain);
 }

References entity_to_entity_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_evaluation()

evaluation make_evaluation	(	enum evaluation_utype	tag,
		void *	val
	)

Definition at line 783 of file ri.c.

                                                                   {
   return (evaluation) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, evaluation_domain, tag, val);
 }

References evaluation_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_evaluation_after()

evaluation make_evaluation_after ( void )

Definition at line 789 of file ri.c.

                                        {
   return make_evaluation(is_evaluation_after, UU);
 }

References is_evaluation_after, make_evaluation(), and UU.

Here is the call graph for this function:

◆ make_evaluation_before()

evaluation make_evaluation_before ( void )

Definition at line 786 of file ri.c.

                                         {
   return make_evaluation(is_evaluation_before, UU);
 }

References is_evaluation_before, make_evaluation(), and UU.

Here is the call graph for this function:

◆ make_execution()

execution make_execution	(	enum execution_utype	tag,
		void *	val
	)

Definition at line 838 of file ri.c.

                                                                {
   return (execution) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, execution_domain, tag, val);
 }

References execution_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_execution_parallel()

execution make_execution_parallel ( void )

Definition at line 844 of file ri.c.

                                         {
   return make_execution(is_execution_parallel, UU);
 }

References is_execution_parallel, make_execution(), and UU.

Here is the call graph for this function:

◆ make_execution_sequential()

execution make_execution_sequential ( void )

Definition at line 841 of file ri.c.

                                           {
   return make_execution(is_execution_sequential, UU);
 }

References is_execution_sequential, make_execution(), and UU.

Here is the call graph for this function:

◆ make_expression()

expression make_expression	(	syntax	a1,
		normalized	a2
	)

Definition at line 886 of file ri.c.

                                                      {
   return (expression) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, expression_domain, a1, a2);
 }

References expression_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_extension()

extension make_extension	(	enum extension_utype	tag,
		void *	val
	)

Definition at line 935 of file ri.c.

                                                                {
   return (extension) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, extension_domain, tag, val);
 }

References extension_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_extension_pragma()

extension make_extension_pragma ( pragma _field_ )

Definition at line 938 of file ri.c.

                                                 {
   return make_extension(is_extension_pragma, (void*)(intptr_t) _field_);
 }

References intptr_t, is_extension_pragma, and make_extension().

Here is the call graph for this function:

◆ make_extension_unknown()

extension make_extension_unknown ( void )

Definition at line 941 of file ri.c.

                                        {
   return make_extension(is_extension_unknown, UU);
 }

References is_extension_unknown, make_extension(), and UU.

Here is the call graph for this function:

◆ make_extensions()

extensions make_extensions ( list a )

Definition at line 983 of file ri.c.

                                    {
   return (extensions) gen_alloc(2*sizeof(gen_chunk), GEN_CHECK_ALLOC, extensions_domain, a);
 }

References extensions_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_forloop()

forloop make_forloop	(	expression	a1,
		expression	a2,
		expression	a3,
		statement	a4
	)

Definition at line 1025 of file ri.c.

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

References forloop_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_formal()

formal make_formal	(	entity	a1,
		intptr_t	a2
	)

Definition at line 1067 of file ri.c.

                                            {
   return (formal) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, formal_domain, a1, a2);
 }

References formal_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_functional()

functional make_functional	(	list	a1,
		type	a2
	)

Definition at line 1109 of file ri.c.

                                              {
   return (functional) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, functional_domain, a1, a2);
 }

References functional_domain, gen_alloc(), and GEN_CHECK_ALLOC.

Here is the call graph for this function:

◆ make_instruction()

instruction make_instruction	(	enum instruction_utype	tag,
		void *	val
	)

Definition at line 1166 of file ri.c.

                                                                      {
   return (instruction) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, instruction_domain, tag, val);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and instruction_domain.

Here is the call graph for this function:

◆ make_instruction_call()

instruction make_instruction_call ( call _field_ )

Definition at line 1184 of file ri.c.

                                                 {
   return make_instruction(is_instruction_call, (void*)(intptr_t) _field_);
 }

References intptr_t, is_instruction_call, and make_instruction().

Here is the call graph for this function:

◆ make_instruction_expression()

instruction make_instruction_expression ( expression _field_ )

Definition at line 1196 of file ri.c.

                                                             {
   return make_instruction(is_instruction_expression, (void*)(intptr_t) _field_);
 }

References intptr_t, is_instruction_expression, and make_instruction().

Here is the call graph for this function:

◆ make_instruction_forloop()

instruction make_instruction_forloop ( forloop _field_ )

Definition at line 1193 of file ri.c.

                                                       {
   return make_instruction(is_instruction_forloop, (void*)(intptr_t) _field_);
 }

References intptr_t, is_instruction_forloop, and make_instruction().

Here is the call graph for this function:

◆ make_instruction_goto()

instruction make_instruction_goto ( statement _field_ )

Definition at line 1181 of file ri.c.

                                                      {
   return make_instruction(is_instruction_goto, (void*)(intptr_t) _field_);
 }

References intptr_t, is_instruction_goto, and make_instruction().

Here is the call graph for this function:

◆ make_instruction_loop()

instruction make_instruction_loop ( loop _field_ )

Definition at line 1175 of file ri.c.

                                                 {
   return make_instruction(is_instruction_loop, (void*)(intptr_t) _field_);
 }

References intptr_t, is_instruction_loop, and make_instruction().

Here is the call graph for this function:

◆ make_instruction_multitest()

instruction make_instruction_multitest ( multitest _field_ )

Definition at line 1190 of file ri.c.

                                                           {
   return make_instruction(is_instruction_multitest, (void*)(intptr_t) _field_);
 }

References intptr_t, is_instruction_multitest, and make_instruction().

Here is the call graph for this function:

◆ make_instruction_sequence()

instruction make_instruction_sequence ( sequence _field_ )

Definition at line 1169 of file ri.c.

                                                         {
   return make_instruction(is_instruction_sequence, (void*)(intptr_t) _field_);
 }

References intptr_t, is_instruction_sequence, and make_instruction().

Here is the call graph for this function:

◆ make_instruction_test()

instruction make_instruction_test ( test _field_ )

Definition at line 1172 of file ri.c.

                                                 {
   return make_instruction(is_instruction_test, (void*)(intptr_t) _field_);
 }

References intptr_t, is_instruction_test, and make_instruction().

Here is the call graph for this function:

◆ make_instruction_unstructured()

instruction make_instruction_unstructured ( unstructured _field_ )

Definition at line 1187 of file ri.c.

                                                                 {
   return make_instruction(is_instruction_unstructured, (void*)(intptr_t) _field_);
 }

References intptr_t, is_instruction_unstructured, and make_instruction().

Here is the call graph for this function:

◆ make_instruction_whileloop()

instruction make_instruction_whileloop ( whileloop _field_ )

Definition at line 1178 of file ri.c.

                                                           {
   return make_instruction(is_instruction_whileloop, (void*)(intptr_t) _field_);
 }

References intptr_t, is_instruction_whileloop, and make_instruction().

Here is the call graph for this function:

◆ make_language()

language make_language	(	enum language_utype	tag,
		void *	val
	)

Definition at line 1247 of file ri.c.

                                                             {
   return (language) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, language_domain, tag, val);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and language_domain.

Here is the call graph for this function:

◆ make_language_c()

language make_language_c ( void )

Definition at line 1253 of file ri.c.

                                {
   return make_language(is_language_c, UU);
 }

References is_language_c, make_language(), and UU.

Here is the call graph for this function:

◆ make_language_fortran()

language make_language_fortran ( void )

Definition at line 1250 of file ri.c.

                                      {
   return make_language(is_language_fortran, UU);
 }

References is_language_fortran, make_language(), and UU.

Here is the call graph for this function:

◆ make_language_fortran95()

language make_language_fortran95 ( void )

Definition at line 1256 of file ri.c.

                                        {
   return make_language(is_language_fortran95, UU);
 }

References is_language_fortran95, make_language(), and UU.

Here is the call graph for this function:

◆ make_language_unknown()

language make_language_unknown ( void )

Definition at line 1259 of file ri.c.

                                      {
   return make_language(is_language_unknown, UU);
 }

References is_language_unknown, make_language(), and UU.

Here is the call graph for this function:

◆ make_loop()

loop make_loop	(	entity	a1,
		range	a2,
		statement	a3,
		entity	a4,
		execution	a5,
		list	a6
	)

Definition at line 1301 of file ri.c.

                                                                                     {
   return (loop) gen_alloc(7*sizeof(gen_chunk), GEN_CHECK_ALLOC, loop_domain, a1, a2, a3, a4, a5, a6);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and loop_domain.

Here is the call graph for this function:

◆ make_mode()

mode make_mode	(	enum mode_utype	tag,
		void *	val
	)

Definition at line 1350 of file ri.c.

                                                 {
   return (mode) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, mode_domain, tag, val);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and mode_domain.

Here is the call graph for this function:

◆ make_mode_reference()

mode make_mode_reference ( void )

Definition at line 1356 of file ri.c.

                                {
   return make_mode(is_mode_reference, UU);
 }

References is_mode_reference, make_mode(), and UU.

Here is the call graph for this function:

◆ make_mode_value()

mode make_mode_value ( void )

Definition at line 1353 of file ri.c.

                            {
   return make_mode(is_mode_value, UU);
 }

References is_mode_value, make_mode(), and UU.

Here is the call graph for this function:

◆ make_multitest()

multitest make_multitest	(	expression	a1,
		statement	a2
	)

Definition at line 1398 of file ri.c.

                                                       {
   return (multitest) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, multitest_domain, a1, a2);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and multitest_domain.

Here is the call graph for this function:

◆ make_normalized()

normalized make_normalized	(	enum normalized_utype	tag,
		void *	val
	)

Definition at line 1447 of file ri.c.

                                                                   {
   return (normalized) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, normalized_domain, tag, val);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and normalized_domain.

Here is the call graph for this function:

◆ make_normalized_complex()

normalized make_normalized_complex ( void )

Definition at line 1453 of file ri.c.

                                          {
   return make_normalized(is_normalized_complex, UU);
 }

References is_normalized_complex, make_normalized(), and UU.

Here is the call graph for this function:

◆ make_normalized_linear()

normalized make_normalized_linear ( Pvecteur _field_ )

Definition at line 1450 of file ri.c.

                                                     {
   return make_normalized(is_normalized_linear, (void*)(intptr_t) _field_);
 }

References intptr_t, is_normalized_linear, and make_normalized().

Here is the call graph for this function:

◆ make_parameter()

parameter make_parameter	(	type	a1,
		mode	a2,
		dummy	a3
	)

Definition at line 1495 of file ri.c.

                                                      {
   return (parameter) gen_alloc(4*sizeof(gen_chunk), GEN_CHECK_ALLOC, parameter_domain, a1, a2, a3);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and parameter_domain.

Here is the call graph for this function:

◆ make_persistant_statement_to_cluster()

persistant_statement_to_cluster make_persistant_statement_to_cluster ( void )

Definition at line 1537 of file ri.c.

                                                                            {
   return (persistant_statement_to_cluster) gen_alloc(2*sizeof(gen_chunk), GEN_CHECK_ALLOC, persistant_statement_to_cluster_domain);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and persistant_statement_to_cluster_domain.

Here is the call graph for this function:

◆ make_persistant_statement_to_control()

persistant_statement_to_control make_persistant_statement_to_control ( void )

Definition at line 1594 of file ri.c.

                                                                            {
   return (persistant_statement_to_control) gen_alloc(2*sizeof(gen_chunk), GEN_CHECK_ALLOC, persistant_statement_to_control_domain);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and persistant_statement_to_control_domain.

Here is the call graph for this function:

◆ make_persistant_statement_to_int()

persistant_statement_to_int make_persistant_statement_to_int ( void )

Definition at line 1651 of file ri.c.

                                                                    {
   return (persistant_statement_to_int) gen_alloc(2*sizeof(gen_chunk), GEN_CHECK_ALLOC, persistant_statement_to_int_domain);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and persistant_statement_to_int_domain.

Here is the call graph for this function:

◆ make_persistant_statement_to_statement()

persistant_statement_to_statement make_persistant_statement_to_statement ( void )

Definition at line 1708 of file ri.c.

                                                                                {
   return (persistant_statement_to_statement) gen_alloc(2*sizeof(gen_chunk), GEN_CHECK_ALLOC, persistant_statement_to_statement_domain);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and persistant_statement_to_statement_domain.

Here is the call graph for this function:

◆ make_pragma()

pragma make_pragma	(	enum pragma_utype	tag,
		void *	val
	)

Definition at line 1772 of file ri.c.

                                                       {
   return (pragma) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, pragma_domain, tag, val);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and pragma_domain.

Here is the call graph for this function:

◆ make_pragma_expression()

pragma make_pragma_expression ( list _field_ )

Definition at line 1778 of file ri.c.

                                             {
   return make_pragma(is_pragma_expression, (void*)(intptr_t) _field_);
 }

References intptr_t, is_pragma_expression, and make_pragma().

Here is the call graph for this function:

◆ make_pragma_string()

pragma make_pragma_string ( string _field_ )

Definition at line 1775 of file ri.c.

                                           {
   return make_pragma(is_pragma_string, (void*)(intptr_t) _field_);
 }

References intptr_t, is_pragma_string, and make_pragma().

Here is the call graph for this function:

◆ make_predicate()

predicate make_predicate ( Psysteme a1 )

Definition at line 1820 of file ri.c.

                                       {
   return (predicate) gen_alloc(2*sizeof(gen_chunk), GEN_CHECK_ALLOC, predicate_domain, a1);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and predicate_domain.

Here is the call graph for this function:

◆ make_preference()

preference make_preference ( reference a1 )

Definition at line 1862 of file ri.c.

                                          {
   return (preference) gen_alloc(2*sizeof(gen_chunk), GEN_CHECK_ALLOC, preference_domain, a1);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and preference_domain.

Here is the call graph for this function:

◆ make_qualifier()

qualifier make_qualifier	(	enum qualifier_utype	tag,
		void *	val
	)

Definition at line 1921 of file ri.c.

                                                                {
   return (qualifier) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, qualifier_domain, tag, val);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and qualifier_domain.

Here is the call graph for this function:

◆ make_qualifier_asm()

qualifier make_qualifier_asm ( string _field_ )

Definition at line 1942 of file ri.c.

                                              {
   return make_qualifier(is_qualifier_asm, (void*)(intptr_t) _field_);
 }

References intptr_t, is_qualifier_asm, and make_qualifier().

Here is the call graph for this function:

◆ make_qualifier_auto()

qualifier make_qualifier_auto ( void )

Definition at line 1936 of file ri.c.

                                     {
   return make_qualifier(is_qualifier_auto, UU);
 }

References is_qualifier_auto, make_qualifier(), and UU.

Here is the call graph for this function:

◆ make_qualifier_const()

qualifier make_qualifier_const ( void )

Definition at line 1924 of file ri.c.

                                      {
   return make_qualifier(is_qualifier_const, UU);
 }

References is_qualifier_const, make_qualifier(), and UU.

Here is the call graph for this function:

◆ make_qualifier_constant()

qualifier make_qualifier_constant ( void )

Definition at line 1954 of file ri.c.

                                         {
   return make_qualifier(is_qualifier_constant, UU);
 }

References is_qualifier_constant, make_qualifier(), and UU.

Here is the call graph for this function:

◆ make_qualifier_global()

qualifier make_qualifier_global ( void )

Definition at line 1951 of file ri.c.

                                       {
   return make_qualifier(is_qualifier_global, UU);
 }

References is_qualifier_global, make_qualifier(), and UU.

Here is the call graph for this function:

◆ make_qualifier_local()

qualifier make_qualifier_local ( void )

Definition at line 1948 of file ri.c.

                                      {
   return make_qualifier(is_qualifier_local, UU);
 }

References is_qualifier_local, make_qualifier(), and UU.

Here is the call graph for this function:

◆ make_qualifier_private()

qualifier make_qualifier_private ( void )

Definition at line 1957 of file ri.c.

                                        {
   return make_qualifier(is_qualifier_private, UU);
 }

References is_qualifier_private, make_qualifier(), and UU.

Here is the call graph for this function:

◆ make_qualifier_register()

qualifier make_qualifier_register ( void )

Definition at line 1933 of file ri.c.

                                         {
   return make_qualifier(is_qualifier_register, UU);
 }

References is_qualifier_register, make_qualifier(), and UU.

Here is the call graph for this function:

◆ make_qualifier_restrict()

qualifier make_qualifier_restrict ( void )

Definition at line 1927 of file ri.c.

                                         {
   return make_qualifier(is_qualifier_restrict, UU);
 }

References is_qualifier_restrict, make_qualifier(), and UU.

Here is the call graph for this function:

◆ make_qualifier_static_dimension()

qualifier make_qualifier_static_dimension ( void )

Definition at line 1945 of file ri.c.

                                                 {
   return make_qualifier(is_qualifier_static_dimension, UU);
 }

References is_qualifier_static_dimension, make_qualifier(), and UU.

Here is the call graph for this function:

◆ make_qualifier_thread()

qualifier make_qualifier_thread ( void )

Definition at line 1939 of file ri.c.

                                       {
   return make_qualifier(is_qualifier_thread, UU);
 }

References is_qualifier_thread, make_qualifier(), and UU.

Here is the call graph for this function:

◆ make_qualifier_volatile()

qualifier make_qualifier_volatile ( void )

Definition at line 1930 of file ri.c.

                                         {
   return make_qualifier(is_qualifier_volatile, UU);
 }

References is_qualifier_volatile, make_qualifier(), and UU.

Here is the call graph for this function:

◆ make_ram()

ram make_ram	(	entity	a1,
		entity	a2,
		intptr_t	a3,
		list	a4
	)

Definition at line 1999 of file ri.c.

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

References gen_alloc(), GEN_CHECK_ALLOC, and ram_domain.

Here is the call graph for this function:

◆ make_range()

range make_range	(	expression	a1,
		expression	a2,
		expression	a3
	)

Definition at line 2041 of file ri.c.

                                                               {
   return (range) gen_alloc(4*sizeof(gen_chunk), GEN_CHECK_ALLOC, range_domain, a1, a2, a3);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and range_domain.

Here is the call graph for this function:

◆ make_reference()

reference make_reference	(	entity	a1,
		list	a2
	)

Definition at line 2083 of file ri.c.

                                              {
   return (reference) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, reference_domain, a1, a2);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and reference_domain.

Here is the call graph for this function:

◆ make_sequence()

sequence make_sequence ( list a )

Definition at line 2125 of file ri.c.

                                {
   return (sequence) gen_alloc(2*sizeof(gen_chunk), GEN_CHECK_ALLOC, sequence_domain, a);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and sequence_domain.

Here is the call graph for this function:

◆ make_sizeofexpression()

sizeofexpression make_sizeofexpression	(	enum sizeofexpression_utype	tag,
		void *	val
	)

Definition at line 2174 of file ri.c.

                                                                                     {
   return (sizeofexpression) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, sizeofexpression_domain, tag, val);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and sizeofexpression_domain.

Here is the call graph for this function:

◆ make_sizeofexpression_expression()

sizeofexpression make_sizeofexpression_expression ( expression _field_ )

Definition at line 2180 of file ri.c.

                                                                       {
   return make_sizeofexpression(is_sizeofexpression_expression, (void*)(intptr_t) _field_);
 }

References intptr_t, is_sizeofexpression_expression, and make_sizeofexpression().

Here is the call graph for this function:

◆ make_sizeofexpression_type()

sizeofexpression make_sizeofexpression_type ( type _field_ )

Definition at line 2177 of file ri.c.

                                                           {
   return make_sizeofexpression(is_sizeofexpression_type, (void*)(intptr_t) _field_);
 }

References intptr_t, is_sizeofexpression_type, and make_sizeofexpression().

Here is the call graph for this function:

◆ make_statement()

statement make_statement	(	entity	a1,
		intptr_t	a2,
		intptr_t	a3,
		string	a4,
		instruction	a5,
		list	a6,
		string	a7,
		extensions	a8,
		synchronization	a9
	)

Definition at line 2222 of file ri.c.

                                                                                                                                                 {
   return (statement) gen_alloc(10*sizeof(gen_chunk), GEN_CHECK_ALLOC, statement_domain, a1, a2, a3, a4, a5, a6, a7, a8, a9);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and statement_domain.

Here is the call graph for this function:

◆ make_storage()

storage make_storage	(	enum storage_utype	tag,
		void *	val
	)

Definition at line 2273 of file ri.c.

                                                          {
   return (storage) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, storage_domain, tag, val);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and storage_domain.

Here is the call graph for this function:

◆ make_storage_formal()

storage make_storage_formal ( formal _field_ )

Definition at line 2282 of file ri.c.

                                             {
   return make_storage(is_storage_formal, (void*)(intptr_t) _field_);
 }

References intptr_t, is_storage_formal, and make_storage().

Here is the call graph for this function:

◆ make_storage_ram()

storage make_storage_ram ( ram _field_ )

Definition at line 2279 of file ri.c.

                                       {
   return make_storage(is_storage_ram, (void*)(intptr_t) _field_);
 }

References intptr_t, is_storage_ram, and make_storage().

Here is the call graph for this function:

◆ make_storage_return()

storage make_storage_return ( entity _field_ )

Definition at line 2276 of file ri.c.

                                             {
   return make_storage(is_storage_return, (void*)(intptr_t) _field_);
 }

References intptr_t, is_storage_return, and make_storage().

Here is the call graph for this function:

◆ make_storage_rom()

storage make_storage_rom ( void )

Definition at line 2285 of file ri.c.

                                {
   return make_storage(is_storage_rom, UU);
 }

References is_storage_rom, make_storage(), and UU.

Here is the call graph for this function:

◆ make_subscript()

subscript make_subscript	(	expression	a1,
		list	a2
	)

Definition at line 2327 of file ri.c.

                                                  {
   return (subscript) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, subscript_domain, a1, a2);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and subscript_domain.

Here is the call graph for this function:

◆ make_symbolic()

symbolic make_symbolic	(	expression	a1,
		constant	a2
	)

Definition at line 2369 of file ri.c.

                                                    {
   return (symbolic) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, symbolic_domain, a1, a2);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and symbolic_domain.

Here is the call graph for this function:

◆ make_synchronization()

synchronization make_synchronization	(	enum synchronization_utype	tag,
		void *	val
	)

Definition at line 2421 of file ri.c.

                                                                                  {
   return (synchronization) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, synchronization_domain, tag, val);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and synchronization_domain.

Here is the call graph for this function:

◆ make_synchronization_barrier()

synchronization make_synchronization_barrier ( void )

Definition at line 2430 of file ri.c.

                                                    {
   return make_synchronization(is_synchronization_barrier, UU);
 }

References is_synchronization_barrier, make_synchronization(), and UU.

Here is the call graph for this function:

◆ make_synchronization_critical()

synchronization make_synchronization_critical ( reference _field_ )

Definition at line 2436 of file ri.c.

                                                                  {
   return make_synchronization(is_synchronization_critical, (void*)(intptr_t) _field_);
 }

References intptr_t, is_synchronization_critical, and make_synchronization().

Here is the call graph for this function:

◆ make_synchronization_none()

synchronization make_synchronization_none ( void )

Definition at line 2424 of file ri.c.

                                                 {
   return make_synchronization(is_synchronization_none, UU);
 }

References is_synchronization_none, make_synchronization(), and UU.

Here is the call graph for this function:

◆ make_synchronization_single()

synchronization make_synchronization_single ( bool _field_ )

Definition at line 2433 of file ri.c.

                                                           {
   return make_synchronization(is_synchronization_single, (void*)(intptr_t) _field_);
 }

References intptr_t, is_synchronization_single, and make_synchronization().

Here is the call graph for this function:

◆ make_synchronization_spawn()

synchronization make_synchronization_spawn ( entity _field_ )

Definition at line 2427 of file ri.c.

                                                            {
   return make_synchronization(is_synchronization_spawn, (void*)(intptr_t) _field_);
 }

References intptr_t, is_synchronization_spawn, and make_synchronization().

Here is the call graph for this function:

◆ make_syntax()

syntax make_syntax	(	enum syntax_utype	tag,
		void *	val
	)

Definition at line 2491 of file ri.c.

                                                       {
   return (syntax) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, syntax_domain, tag, val);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and syntax_domain.

Here is the call graph for this function:

◆ make_syntax_application()

syntax make_syntax_application ( application _field_ )

Definition at line 2512 of file ri.c.

                                                     {
   return make_syntax(is_syntax_application, (void*)(intptr_t) _field_);
 }

References intptr_t, is_syntax_application, and make_syntax().

Here is the call graph for this function:

◆ make_syntax_call()

syntax make_syntax_call ( call _field_ )

Definition at line 2500 of file ri.c.

                                       {
   return make_syntax(is_syntax_call, (void*)(intptr_t) _field_);
 }

References intptr_t, is_syntax_call, and make_syntax().

Here is the call graph for this function:

◆ make_syntax_cast()

syntax make_syntax_cast ( cast _field_ )

Definition at line 2503 of file ri.c.

                                       {
   return make_syntax(is_syntax_cast, (void*)(intptr_t) _field_);
 }

References intptr_t, is_syntax_cast, and make_syntax().

Here is the call graph for this function:

◆ make_syntax_range()

syntax make_syntax_range ( range _field_ )

Definition at line 2497 of file ri.c.

                                         {
   return make_syntax(is_syntax_range, (void*)(intptr_t) _field_);
 }

References intptr_t, is_syntax_range, and make_syntax().

Here is the call graph for this function:

◆ make_syntax_reference()

syntax make_syntax_reference ( reference _field_ )

Definition at line 2494 of file ri.c.

                                                 {
   return make_syntax(is_syntax_reference, (void*)(intptr_t) _field_);
 }

References intptr_t, is_syntax_reference, and make_syntax().

Here is the call graph for this function:

◆ make_syntax_sizeofexpression()

syntax make_syntax_sizeofexpression ( sizeofexpression _field_ )

Definition at line 2506 of file ri.c.

                                                               {
   return make_syntax(is_syntax_sizeofexpression, (void*)(intptr_t) _field_);
 }

References intptr_t, is_syntax_sizeofexpression, and make_syntax().

Here is the call graph for this function:

◆ make_syntax_subscript()

syntax make_syntax_subscript ( subscript _field_ )

Definition at line 2509 of file ri.c.

                                                 {
   return make_syntax(is_syntax_subscript, (void*)(intptr_t) _field_);
 }

References intptr_t, is_syntax_subscript, and make_syntax().

Here is the call graph for this function:

◆ make_syntax_va_arg()

syntax make_syntax_va_arg ( list _field_ )

Definition at line 2515 of file ri.c.

                                         {
   return make_syntax(is_syntax_va_arg, (void*)(intptr_t) _field_);
 }

References intptr_t, is_syntax_va_arg, and make_syntax().

Here is the call graph for this function:

◆ make_test()

test make_test	(	expression	a1,
		statement	a2,
		statement	a3
	)

Definition at line 2607 of file ri.c.

                                                           {
   return (test) gen_alloc(4*sizeof(gen_chunk), GEN_CHECK_ALLOC, test_domain, a1, a2, a3);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and test_domain.

Here is the call graph for this function:

◆ make_transformer()

transformer make_transformer	(	list	a1,
		predicate	a2
	)

Definition at line 2649 of file ri.c.

                                                     {
   return (transformer) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, transformer_domain, a1, a2);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and transformer_domain.

Here is the call graph for this function:

◆ make_type()

type make_type	(	enum type_utype	tag,
		void *	val
	)

Definition at line 2706 of file ri.c.

                                                 {
   return (type) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, type_domain, tag, val);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and type_domain.

Here is the call graph for this function:

◆ make_type_area()

type make_type_area ( area _field_ )

Definition at line 2712 of file ri.c.

                                   {
   return make_type(is_type_area, (void*)(intptr_t) _field_);
 }

References intptr_t, is_type_area, and make_type().

Here is the call graph for this function:

◆ make_type_enum()

type make_type_enum ( list _field_ )

Definition at line 2736 of file ri.c.

                                   {
   return make_type(is_type_enum, (void*)(intptr_t) _field_);
 }

References intptr_t, is_type_enum, and make_type().

Here is the call graph for this function:

◆ make_type_functional()

type make_type_functional ( functional _field_ )

Definition at line 2718 of file ri.c.

                                               {
   return make_type(is_type_functional, (void*)(intptr_t) _field_);
 }

References intptr_t, is_type_functional, and make_type().

Here is the call graph for this function:

◆ make_type_statement()

type make_type_statement ( void )

Definition at line 2709 of file ri.c.

                                {
   return make_type(is_type_statement, UU);
 }

References is_type_statement, make_type(), and UU.

Here is the call graph for this function:

◆ make_type_struct()

type make_type_struct ( list _field_ )

Definition at line 2730 of file ri.c.

                                     {
   return make_type(is_type_struct, (void*)(intptr_t) _field_);
 }

References intptr_t, is_type_struct, and make_type().

Here is the call graph for this function:

◆ make_type_union()

type make_type_union ( list _field_ )

Definition at line 2733 of file ri.c.

                                    {
   return make_type(is_type_union, (void*)(intptr_t) _field_);
 }

References intptr_t, is_type_union, and make_type().

Here is the call graph for this function:

◆ make_type_unknown()

type make_type_unknown ( void )

Definition at line 2724 of file ri.c.

                              {
   return make_type(is_type_unknown, UU);
 }

References is_type_unknown, make_type(), and UU.

Here is the call graph for this function:

◆ make_type_varargs()

type make_type_varargs ( type _field_ )

Definition at line 2721 of file ri.c.

                                      {
   return make_type(is_type_varargs, (void*)(intptr_t) _field_);
 }

References intptr_t, is_type_varargs, and make_type().

Here is the call graph for this function:

◆ make_type_variable()

type make_type_variable ( variable _field_ )

Definition at line 2715 of file ri.c.

                                           {
   return make_type(is_type_variable, (void*)(intptr_t) _field_);
 }

References intptr_t, is_type_variable, and make_type().

Here is the call graph for this function:

◆ make_type_void()

type make_type_void ( list _field_ )

Definition at line 2727 of file ri.c.

                                   {
   return make_type(is_type_void, (void*)(intptr_t) _field_);
 }

References intptr_t, is_type_void, and make_type().

Here is the call graph for this function:

◆ make_unstructured()

unstructured make_unstructured	(	control	a1,
		control	a2
	)

Definition at line 2778 of file ri.c.

                                                        {
   return (unstructured) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, unstructured_domain, a1, a2);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and unstructured_domain.

Here is the call graph for this function:

◆ make_value()

value make_value	(	enum value_utype	tag,
		void *	val
	)

Definition at line 2832 of file ri.c.

                                                    {
   return (value) gen_alloc(3*sizeof(gen_chunk), GEN_CHECK_ALLOC, value_domain, tag, val);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and value_domain.

Here is the call graph for this function:

◆ make_value_code()

value make_value_code ( code _field_ )

Definition at line 2835 of file ri.c.

                                     {
   return make_value(is_value_code, (void*)(intptr_t) _field_);
 }

References intptr_t, is_value_code, and make_value().

Here is the call graph for this function:

◆ make_value_constant()

value make_value_constant ( constant _field_ )

Definition at line 2841 of file ri.c.

                                             {
   return make_value(is_value_constant, (void*)(intptr_t) _field_);
 }

References intptr_t, is_value_constant, and make_value().

Here is the call graph for this function:

◆ make_value_expression()

value make_value_expression ( expression _field_ )

Definition at line 2850 of file ri.c.

                                                 {
   return make_value(is_value_expression, (void*)(intptr_t) _field_);
 }

References intptr_t, is_value_expression, and make_value().

Here is the call graph for this function:

◆ make_value_intrinsic()

value make_value_intrinsic ( void )

Definition at line 2844 of file ri.c.

                                  {
   return make_value(is_value_intrinsic, UU);
 }

References is_value_intrinsic, make_value(), and UU.

Here is the call graph for this function:

◆ make_value_reference()

value make_value_reference ( reference _field_ )

Definition at line 2853 of file ri.c.

                                               {
   return make_value(is_value_reference, (void*)(intptr_t) _field_);
 }

References intptr_t, is_value_reference, and make_value().

Here is the call graph for this function:

◆ make_value_symbolic()

value make_value_symbolic ( symbolic _field_ )

Definition at line 2838 of file ri.c.

                                             {
   return make_value(is_value_symbolic, (void*)(intptr_t) _field_);
 }

References intptr_t, is_value_symbolic, and make_value().

Here is the call graph for this function:

◆ make_value_unknown()

value make_value_unknown ( void )

Definition at line 2847 of file ri.c.

                                {
   return make_value(is_value_unknown, UU);
 }

References is_value_unknown, make_value(), and UU.

Here is the call graph for this function:

◆ make_variable()

variable make_variable	(	basic	a1,
		list	a2,
		list	a3
	)

Definition at line 2895 of file ri.c.

                                                    {
   return (variable) gen_alloc(4*sizeof(gen_chunk), GEN_CHECK_ALLOC, variable_domain, a1, a2, a3);
 }

References gen_alloc(), GEN_CHECK_ALLOC, and variable_domain.

Here is the call graph for this function:

◆ make_whileloop()

whileloop make_whileloop	(	expression	a1,
		statement	a2,
		entity	a3,
		evaluation	a4
	)

Definition at line 2937 of file ri.c.

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

References gen_alloc(), GEN_CHECK_ALLOC, and whileloop_domain.

Here is the call graph for this function:

◆ mode_assign_contents()

void mode_assign_contents	(	mode	r,
		mode	v
	)

Definition at line 1326 of file ri.c.

                                           {
   check_mode(r);
   check_mode(v);
   message_assert("defined references to domain mode",
                  mode_defined_p(r) && mode_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_mode_));
 }

References check_mode(), message_assert, and mode_defined_p().

Here is the call graph for this function:

◆ mode_consistent_p()

bool mode_consistent_p ( mode p )

Definition at line 1316 of file ri.c.

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

References check_mode(), and gen_consistent_p().

Here is the call graph for this function:

◆ mode_defined_p()

bool mode_defined_p ( mode p )

Definition at line 1320 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ mode_non_recursive_free()

void mode_non_recursive_free ( mode p )

Definition at line 1333 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ mode_tag_as_string()

string mode_tag_as_string ( enum mode_utype tag )

Definition at line 1343 of file ri.c.

                                                {
   switch (tag) {
   case is_mode_value: return "value";
   case is_mode_reference: return "reference";
   default: return string_undefined;
   }
 }

References is_mode_reference, is_mode_value, and string_undefined.

◆ multitest_assign_contents()

void multitest_assign_contents	(	multitest	r,
		multitest	v
	)

Definition at line 1381 of file ri.c.

                                                          {
   check_multitest(r);
   check_multitest(v);
   message_assert("defined references to domain multitest",
                  multitest_defined_p(r) && multitest_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_multitest_));
 }

References check_multitest(), message_assert, and multitest_defined_p().

Here is the call graph for this function:

◆ multitest_consistent_p()

bool multitest_consistent_p ( multitest p )

Definition at line 1371 of file ri.c.

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

References check_multitest(), and gen_consistent_p().

Here is the call graph for this function:

◆ multitest_defined_p()

bool multitest_defined_p ( multitest p )

Definition at line 1375 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ multitest_non_recursive_free()

void multitest_non_recursive_free ( multitest p )

Definition at line 1388 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ normalized_assign_contents()

void normalized_assign_contents	(	normalized	r,
		normalized	v
	)

Definition at line 1423 of file ri.c.

                                                             {
   check_normalized(r);
   check_normalized(v);
   message_assert("defined references to domain normalized",
                  normalized_defined_p(r) && normalized_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_normalized_));
 }

References check_normalized(), message_assert, and normalized_defined_p().

Here is the call graph for this function:

◆ normalized_consistent_p()

bool normalized_consistent_p ( normalized p )

Definition at line 1413 of file ri.c.

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

References check_normalized(), and gen_consistent_p().

Here is the call graph for this function:

◆ normalized_defined_p()

bool normalized_defined_p ( normalized p )

Definition at line 1417 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ normalized_non_recursive_free()

void normalized_non_recursive_free ( normalized p )

Definition at line 1430 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ normalized_tag_as_string()

string normalized_tag_as_string ( enum normalized_utype tag )

Definition at line 1440 of file ri.c.

                                                            {
   switch (tag) {
   case is_normalized_linear: return "linear";
   case is_normalized_complex: return "complex";
   default: return string_undefined;
   }
 }

References is_normalized_complex, is_normalized_linear, and string_undefined.

◆ parameter_assign_contents()

void parameter_assign_contents	(	parameter	r,
		parameter	v
	)

Definition at line 1478 of file ri.c.

                                                          {
   check_parameter(r);
   check_parameter(v);
   message_assert("defined references to domain parameter",
                  parameter_defined_p(r) && parameter_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_parameter_));
 }

References check_parameter(), message_assert, and parameter_defined_p().

Here is the call graph for this function:

◆ parameter_consistent_p()

bool parameter_consistent_p ( parameter p )

Definition at line 1468 of file ri.c.

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

References check_parameter(), and gen_consistent_p().

Here is the call graph for this function:

◆ parameter_defined_p()

bool parameter_defined_p ( parameter p )

Definition at line 1472 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ parameter_non_recursive_free()

void parameter_non_recursive_free ( parameter p )

Definition at line 1485 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ persistant_statement_to_cluster_assign_contents()

void persistant_statement_to_cluster_assign_contents	(	persistant_statement_to_cluster	r,
		persistant_statement_to_cluster	v
	)

Definition at line 1520 of file ri.c.

                                                                                                                            {
   check_persistant_statement_to_cluster(r);
   check_persistant_statement_to_cluster(v);
   message_assert("defined references to domain persistant_statement_to_cluster",
                  persistant_statement_to_cluster_defined_p(r) && persistant_statement_to_cluster_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_persistant_statement_to_cluster_));
 }

References check_persistant_statement_to_cluster(), message_assert, and persistant_statement_to_cluster_defined_p().

Here is the call graph for this function:

◆ persistant_statement_to_cluster_consistent_p()

bool persistant_statement_to_cluster_consistent_p ( persistant_statement_to_cluster p )

Definition at line 1510 of file ri.c.

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

References check_persistant_statement_to_cluster(), and gen_consistent_p().

Here is the call graph for this function:

◆ persistant_statement_to_cluster_defined_p()

bool persistant_statement_to_cluster_defined_p ( persistant_statement_to_cluster p )

Definition at line 1514 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ persistant_statement_to_cluster_non_recursive_free()

void persistant_statement_to_cluster_non_recursive_free ( persistant_statement_to_cluster p )

Definition at line 1527 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ persistant_statement_to_control_assign_contents()

void persistant_statement_to_control_assign_contents	(	persistant_statement_to_control	r,
		persistant_statement_to_control	v
	)

Definition at line 1577 of file ri.c.

                                                                                                                            {
   check_persistant_statement_to_control(r);
   check_persistant_statement_to_control(v);
   message_assert("defined references to domain persistant_statement_to_control",
                  persistant_statement_to_control_defined_p(r) && persistant_statement_to_control_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_persistant_statement_to_control_));
 }

References check_persistant_statement_to_control(), message_assert, and persistant_statement_to_control_defined_p().

Here is the call graph for this function:

◆ persistant_statement_to_control_consistent_p()

bool persistant_statement_to_control_consistent_p ( persistant_statement_to_control p )

Definition at line 1567 of file ri.c.

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

References check_persistant_statement_to_control(), and gen_consistent_p().

Here is the call graph for this function:

◆ persistant_statement_to_control_defined_p()

bool persistant_statement_to_control_defined_p ( persistant_statement_to_control p )

Definition at line 1571 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ persistant_statement_to_control_non_recursive_free()

void persistant_statement_to_control_non_recursive_free ( persistant_statement_to_control p )

Definition at line 1584 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ persistant_statement_to_int_assign_contents()

void persistant_statement_to_int_assign_contents	(	persistant_statement_to_int	r,
		persistant_statement_to_int	v
	)

Definition at line 1634 of file ri.c.

                                                                                                                {
   check_persistant_statement_to_int(r);
   check_persistant_statement_to_int(v);
   message_assert("defined references to domain persistant_statement_to_int",
                  persistant_statement_to_int_defined_p(r) && persistant_statement_to_int_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_persistant_statement_to_int_));
 }

References check_persistant_statement_to_int(), message_assert, and persistant_statement_to_int_defined_p().

Here is the call graph for this function:

◆ persistant_statement_to_int_consistent_p()

bool persistant_statement_to_int_consistent_p ( persistant_statement_to_int p )

Definition at line 1624 of file ri.c.

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

References check_persistant_statement_to_int(), and gen_consistent_p().

Here is the call graph for this function:

◆ persistant_statement_to_int_defined_p()

bool persistant_statement_to_int_defined_p ( persistant_statement_to_int p )

Definition at line 1628 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ persistant_statement_to_int_non_recursive_free()

void persistant_statement_to_int_non_recursive_free ( persistant_statement_to_int p )

Definition at line 1641 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ persistant_statement_to_statement_assign_contents()

void persistant_statement_to_statement_assign_contents	(	persistant_statement_to_statement	r,
		persistant_statement_to_statement	v
	)

Definition at line 1691 of file ri.c.

                                                                                                                                  {
   check_persistant_statement_to_statement(r);
   check_persistant_statement_to_statement(v);
   message_assert("defined references to domain persistant_statement_to_statement",
                  persistant_statement_to_statement_defined_p(r) && persistant_statement_to_statement_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_persistant_statement_to_statement_));
 }

References check_persistant_statement_to_statement(), message_assert, and persistant_statement_to_statement_defined_p().

Here is the call graph for this function:

◆ persistant_statement_to_statement_consistent_p()

bool persistant_statement_to_statement_consistent_p ( persistant_statement_to_statement p )

Definition at line 1681 of file ri.c.

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

References check_persistant_statement_to_statement(), and gen_consistent_p().

Here is the call graph for this function:

◆ persistant_statement_to_statement_defined_p()

bool persistant_statement_to_statement_defined_p ( persistant_statement_to_statement p )

Definition at line 1685 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ persistant_statement_to_statement_non_recursive_free()

void persistant_statement_to_statement_non_recursive_free ( persistant_statement_to_statement p )

Definition at line 1698 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ pragma_assign_contents()

void pragma_assign_contents	(	pragma	r,
		pragma	v
	)

Definition at line 1748 of file ri.c.

                                                 {
   check_pragma(r);
   check_pragma(v);
   message_assert("defined references to domain pragma",
                  pragma_defined_p(r) && pragma_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_pragma_));
 }

References check_pragma(), message_assert, and pragma_defined_p().

Here is the call graph for this function:

◆ pragma_consistent_p()

bool pragma_consistent_p ( pragma p )

Definition at line 1738 of file ri.c.

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

References check_pragma(), and gen_consistent_p().

Here is the call graph for this function:

◆ pragma_defined_p()

bool pragma_defined_p ( pragma p )

Definition at line 1742 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ pragma_non_recursive_free()

void pragma_non_recursive_free ( pragma p )

Definition at line 1755 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ pragma_tag_as_string()

string pragma_tag_as_string ( enum pragma_utype tag )

Definition at line 1765 of file ri.c.

                                                    {
   switch (tag) {
   case is_pragma_string: return "string";
   case is_pragma_expression: return "expression";
   default: return string_undefined;
   }
 }

References is_pragma_expression, is_pragma_string, and string_undefined.

◆ predicate_assign_contents()

void predicate_assign_contents	(	predicate	r,
		predicate	v
	)

Definition at line 1803 of file ri.c.

                                                          {
   check_predicate(r);
   check_predicate(v);
   message_assert("defined references to domain predicate",
                  predicate_defined_p(r) && predicate_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_predicate_));
 }

References check_predicate(), message_assert, and predicate_defined_p().

Here is the call graph for this function:

◆ predicate_consistent_p()

bool predicate_consistent_p ( predicate p )

Definition at line 1793 of file ri.c.

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

References check_predicate(), and gen_consistent_p().

Here is the call graph for this function:

◆ predicate_defined_p()

bool predicate_defined_p ( predicate p )

Definition at line 1797 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ predicate_non_recursive_free()

void predicate_non_recursive_free ( predicate p )

Definition at line 1810 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ preference_assign_contents()

void preference_assign_contents	(	preference	r,
		preference	v
	)

Definition at line 1845 of file ri.c.

                                                             {
   check_preference(r);
   check_preference(v);
   message_assert("defined references to domain preference",
                  preference_defined_p(r) && preference_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_preference_));
 }

References check_preference(), message_assert, and preference_defined_p().

Here is the call graph for this function:

◆ preference_consistent_p()

bool preference_consistent_p ( preference p )

Definition at line 1835 of file ri.c.

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

References check_preference(), and gen_consistent_p().

Here is the call graph for this function:

◆ preference_defined_p()

bool preference_defined_p ( preference p )

Definition at line 1839 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ preference_non_recursive_free()

void preference_non_recursive_free ( preference p )

Definition at line 1852 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ qualifier_assign_contents()

void qualifier_assign_contents	(	qualifier	r,
		qualifier	v
	)

Definition at line 1887 of file ri.c.

                                                          {
   check_qualifier(r);
   check_qualifier(v);
   message_assert("defined references to domain qualifier",
                  qualifier_defined_p(r) && qualifier_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_qualifier_));
 }

References check_qualifier(), message_assert, and qualifier_defined_p().

Here is the call graph for this function:

◆ qualifier_consistent_p()

bool qualifier_consistent_p ( qualifier p )

Definition at line 1877 of file ri.c.

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

References check_qualifier(), and gen_consistent_p().

Here is the call graph for this function:

◆ qualifier_defined_p()

bool qualifier_defined_p ( qualifier p )

Definition at line 1881 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ qualifier_non_recursive_free()

void qualifier_non_recursive_free ( qualifier p )

Definition at line 1894 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ qualifier_tag_as_string()

string qualifier_tag_as_string ( enum qualifier_utype tag )

Definition at line 1904 of file ri.c.

                                                          {
   switch (tag) {
   case is_qualifier_const: return "const";
   case is_qualifier_restrict: return "restrict";
   case is_qualifier_volatile: return "volatile";
   case is_qualifier_register: return "register";
   case is_qualifier_auto: return "auto";
   case is_qualifier_thread: return "thread";
   case is_qualifier_asm: return "asm";
   case is_qualifier_static_dimension: return "static_dimension";
   case is_qualifier_local: return "local";
   case is_qualifier_global: return "global";
   case is_qualifier_constant: return "constant";
   case is_qualifier_private: return "private";
   default: return string_undefined;
   }
 }

References is_qualifier_asm, is_qualifier_auto, is_qualifier_const, is_qualifier_constant, is_qualifier_global, is_qualifier_local, is_qualifier_private, is_qualifier_register, is_qualifier_restrict, is_qualifier_static_dimension, is_qualifier_thread, is_qualifier_volatile, and string_undefined.

◆ ram_assign_contents()

void ram_assign_contents	(	ram	r,
		ram	v
	)

Definition at line 1982 of file ri.c.

                                        {
   check_ram(r);
   check_ram(v);
   message_assert("defined references to domain ram",
                  ram_defined_p(r) && ram_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_ram_));
 }

References check_ram(), message_assert, and ram_defined_p().

Here is the call graph for this function:

◆ ram_consistent_p()

bool ram_consistent_p ( ram p )

Definition at line 1972 of file ri.c.

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

References check_ram(), and gen_consistent_p().

Here is the call graph for this function:

◆ ram_defined_p()

bool ram_defined_p ( ram p )

Definition at line 1976 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ ram_non_recursive_free()

void ram_non_recursive_free ( ram p )

Definition at line 1989 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ range_assign_contents()

void range_assign_contents	(	range	r,
		range	v
	)

Definition at line 2024 of file ri.c.

                                              {
   check_range(r);
   check_range(v);
   message_assert("defined references to domain range",
                  range_defined_p(r) && range_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_range_));
 }

References check_range(), message_assert, and range_defined_p().

Here is the call graph for this function:

◆ range_consistent_p()

bool range_consistent_p ( range p )

Definition at line 2014 of file ri.c.

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

References check_range(), and gen_consistent_p().

Here is the call graph for this function:

◆ range_defined_p()

bool range_defined_p ( range p )

Definition at line 2018 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ range_non_recursive_free()

void range_non_recursive_free ( range p )

Definition at line 2031 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ read_application()

application read_application ( FILE * f )

Definition at line 53 of file ri.c.

                                       {
   return (application) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_area()

area read_area ( FILE * f )

Definition at line 95 of file ri.c.

                         {
   return (area) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_basic()

basic read_basic ( FILE * f )

Definition at line 137 of file ri.c.

                           {
   return (basic) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_call()

call read_call ( FILE * f )

Definition at line 266 of file ri.c.

                         {
   return (call) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_callees()

callees read_callees ( FILE * f )

Definition at line 224 of file ri.c.

                               {
   return (callees) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_cast()

cast read_cast ( FILE * f )

Definition at line 308 of file ri.c.

                         {
   return (cast) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_code()

code read_code ( FILE * f )

Definition at line 350 of file ri.c.

                         {
   return (code) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_constant()

constant read_constant ( FILE * f )

Definition at line 392 of file ri.c.

                                 {
   return (constant) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_control()

control read_control ( FILE * f )

Definition at line 520 of file ri.c.

                               {
   return (control) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_controlmap()

controlmap read_controlmap ( FILE * f )

Definition at line 463 of file ri.c.

                                     {
   return (controlmap) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_dimension()

dimension read_dimension ( FILE * f )

Definition at line 562 of file ri.c.

                                   {
   return (dimension) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_dummy()

dummy read_dummy ( FILE * f )

Definition at line 604 of file ri.c.

                           {
   return (dummy) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_entity_int()

entity_int read_entity_int ( FILE * f )

Definition at line 659 of file ri.c.

                                     {
   return (entity_int) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_entity_to_entity()

entity_to_entity read_entity_to_entity ( FILE * f )

Definition at line 716 of file ri.c.

                                                 {
   return (entity_to_entity) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_evaluation()

evaluation read_evaluation ( FILE * f )

Definition at line 773 of file ri.c.

                                     {
   return (evaluation) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_execution()

execution read_execution ( FILE * f )

Definition at line 828 of file ri.c.

                                   {
   return (execution) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_expression()

expression read_expression ( FILE * f )

Definition at line 883 of file ri.c.

                                     {
   return (expression) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_extension()

extension read_extension ( FILE * f )

Definition at line 925 of file ri.c.

                                   {
   return (extension) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_extensions()

extensions read_extensions ( FILE * f )

Definition at line 980 of file ri.c.

                                     {
   return (extensions) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_forloop()

forloop read_forloop ( FILE * f )

Definition at line 1022 of file ri.c.

                               {
   return (forloop) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_formal()

formal read_formal ( FILE * f )

Definition at line 1064 of file ri.c.

                             {
   return (formal) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_functional()

functional read_functional ( FILE * f )

Definition at line 1106 of file ri.c.

                                     {
   return (functional) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_instruction()

instruction read_instruction ( FILE * f )

Definition at line 1148 of file ri.c.

                                       {
   return (instruction) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_language()

language read_language ( FILE * f )

Definition at line 1235 of file ri.c.

                                 {
   return (language) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_loop()

loop read_loop ( FILE * f )

Definition at line 1298 of file ri.c.

                         {
   return (loop) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_mode()

mode read_mode ( FILE * f )

Definition at line 1340 of file ri.c.

                         {
   return (mode) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_multitest()

multitest read_multitest ( FILE * f )

Definition at line 1395 of file ri.c.

                                   {
   return (multitest) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_normalized()

normalized read_normalized ( FILE * f )

Definition at line 1437 of file ri.c.

                                     {
   return (normalized) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_parameter()

parameter read_parameter ( FILE * f )

Definition at line 1492 of file ri.c.

                                   {
   return (parameter) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_persistant_statement_to_cluster()

persistant_statement_to_cluster read_persistant_statement_to_cluster ( FILE * f )

Definition at line 1534 of file ri.c.

                                                                               {
   return (persistant_statement_to_cluster) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_persistant_statement_to_control()

persistant_statement_to_control read_persistant_statement_to_control ( FILE * f )

Definition at line 1591 of file ri.c.

                                                                               {
   return (persistant_statement_to_control) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_persistant_statement_to_int()

persistant_statement_to_int read_persistant_statement_to_int ( FILE * f )

Definition at line 1648 of file ri.c.

                                                                       {
   return (persistant_statement_to_int) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_persistant_statement_to_statement()

persistant_statement_to_statement read_persistant_statement_to_statement ( FILE * f )

Definition at line 1705 of file ri.c.

                                                                                   {
   return (persistant_statement_to_statement) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_pragma()

pragma read_pragma ( FILE * f )

Definition at line 1762 of file ri.c.

                             {
   return (pragma) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_predicate()

predicate read_predicate ( FILE * f )

Definition at line 1817 of file ri.c.

                                   {
   return (predicate) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_preference()

preference read_preference ( FILE * f )

Definition at line 1859 of file ri.c.

                                     {
   return (preference) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_qualifier()

qualifier read_qualifier ( FILE * f )

Definition at line 1901 of file ri.c.

                                   {
   return (qualifier) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_ram()

ram read_ram ( FILE * f )

Definition at line 1996 of file ri.c.

                       {
   return (ram) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_range()

range read_range ( FILE * f )

Definition at line 2038 of file ri.c.

                           {
   return (range) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_reference()

reference read_reference ( FILE * f )

Definition at line 2080 of file ri.c.

                                   {
   return (reference) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_sequence()

sequence read_sequence ( FILE * f )

Definition at line 2122 of file ri.c.

                                 {
   return (sequence) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_sizeofexpression()

sizeofexpression read_sizeofexpression ( FILE * f )

Definition at line 2164 of file ri.c.

                                                 {
   return (sizeofexpression) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_statement()

statement read_statement ( FILE * f )

Definition at line 2219 of file ri.c.

                                   {
   return (statement) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_storage()

storage read_storage ( FILE * f )

Definition at line 2261 of file ri.c.

                               {
   return (storage) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_subscript()

subscript read_subscript ( FILE * f )

Definition at line 2324 of file ri.c.

                                   {
   return (subscript) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_symbolic()

symbolic read_symbolic ( FILE * f )

Definition at line 2366 of file ri.c.

                                 {
   return (symbolic) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_synchronization()

synchronization read_synchronization ( FILE * f )

Definition at line 2408 of file ri.c.

                                               {
   return (synchronization) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_syntax()

syntax read_syntax ( FILE * f )

Definition at line 2475 of file ri.c.

                             {
   return (syntax) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_tabulated_entity()

void read_tabulated_entity ( FILE * f )

Definition at line 2557 of file ri.c.

                                     {
   int domain = gen_read_tabulated(f, 0);
   if (domain!=entity_domain) {
     fprintf(stderr, "[newgen internal error]""inconsistent domain number for entity: %d (expecting %d)\n",
             domain, entity_domain);
     abort();
   }
 }

References abort, entity_domain, f(), fprintf(), and gen_read_tabulated().

Here is the call graph for this function:

◆ read_test()

test read_test ( FILE * f )

Definition at line 2604 of file ri.c.

                         {
   return (test) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_transformer()

transformer read_transformer ( FILE * f )

Definition at line 2646 of file ri.c.

                                       {
   return (transformer) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_type()

type read_type ( FILE * f )

Definition at line 2688 of file ri.c.

                         {
   return (type) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_unstructured()

unstructured read_unstructured ( FILE * f )

Definition at line 2775 of file ri.c.

                                         {
   return (unstructured) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_value()

value read_value ( FILE * f )

Definition at line 2817 of file ri.c.

                           {
   return (value) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_variable()

variable read_variable ( FILE * f )

Definition at line 2892 of file ri.c.

                                 {
   return (variable) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ read_whileloop()

whileloop read_whileloop ( FILE * f )

Definition at line 2934 of file ri.c.

                                   {
   return (whileloop) gen_read(f);
 }

References f(), and gen_read().

Here is the call graph for this function:

◆ reference_assign_contents()

void reference_assign_contents	(	reference	r,
		reference	v
	)

Definition at line 2066 of file ri.c.

                                                          {
   check_reference(r);
   check_reference(v);
   message_assert("defined references to domain reference",
                  reference_defined_p(r) && reference_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_reference_));
 }

References check_reference(), message_assert, and reference_defined_p().

Here is the call graph for this function:

◆ reference_consistent_p()

bool reference_consistent_p ( reference p )

Definition at line 2056 of file ri.c.

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

References check_reference(), and gen_consistent_p().

Here is the call graph for this function:

◆ reference_defined_p()

bool reference_defined_p ( reference p )

Definition at line 2060 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ reference_non_recursive_free()

void reference_non_recursive_free ( reference p )

Definition at line 2073 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ sequence_assign_contents()

void sequence_assign_contents	(	sequence	r,
		sequence	v
	)

Definition at line 2108 of file ri.c.

                                                       {
   check_sequence(r);
   check_sequence(v);
   message_assert("defined references to domain sequence",
                  sequence_defined_p(r) && sequence_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_sequence_));
 }

References check_sequence(), message_assert, and sequence_defined_p().

Here is the call graph for this function:

◆ sequence_consistent_p()

bool sequence_consistent_p ( sequence p )

Definition at line 2098 of file ri.c.

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

References check_sequence(), and gen_consistent_p().

Here is the call graph for this function:

◆ sequence_defined_p()

bool sequence_defined_p ( sequence p )

Definition at line 2102 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ sequence_non_recursive_free()

void sequence_non_recursive_free ( sequence p )

Definition at line 2115 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ sizeofexpression_assign_contents()

void sizeofexpression_assign_contents	(	sizeofexpression	r,
		sizeofexpression	v
	)

Definition at line 2150 of file ri.c.

                                                                               {
   check_sizeofexpression(r);
   check_sizeofexpression(v);
   message_assert("defined references to domain sizeofexpression",
                  sizeofexpression_defined_p(r) && sizeofexpression_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_sizeofexpression_));
 }

References check_sizeofexpression(), message_assert, and sizeofexpression_defined_p().

Here is the call graph for this function:

◆ sizeofexpression_consistent_p()

bool sizeofexpression_consistent_p ( sizeofexpression p )

Definition at line 2140 of file ri.c.

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

References check_sizeofexpression(), and gen_consistent_p().

Here is the call graph for this function:

◆ sizeofexpression_defined_p()

bool sizeofexpression_defined_p ( sizeofexpression p )

Definition at line 2144 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ sizeofexpression_non_recursive_free()

void sizeofexpression_non_recursive_free ( sizeofexpression p )

Definition at line 2157 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ sizeofexpression_tag_as_string()

string sizeofexpression_tag_as_string ( enum sizeofexpression_utype tag )

Definition at line 2167 of file ri.c.

                                                                        {
   switch (tag) {
   case is_sizeofexpression_type: return "type";
   case is_sizeofexpression_expression: return "expression";
   default: return string_undefined;
   }
 }

References is_sizeofexpression_expression, is_sizeofexpression_type, and string_undefined.

◆ statement_assign_contents()

void statement_assign_contents	(	statement	r,
		statement	v
	)

Definition at line 2205 of file ri.c.

                                                          {
   check_statement(r);
   check_statement(v);
   message_assert("defined references to domain statement",
                  statement_defined_p(r) && statement_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_statement_));
 }

References check_statement(), message_assert, and statement_defined_p().

Here is the call graph for this function:

◆ statement_consistent_p()

bool statement_consistent_p ( statement p )

Definition at line 2195 of file ri.c.

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

References check_statement(), and gen_consistent_p().

Here is the call graph for this function:

◆ statement_defined_p()

bool statement_defined_p ( statement p )

Definition at line 2199 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ statement_non_recursive_free()

void statement_non_recursive_free ( statement p )

Definition at line 2212 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ storage_assign_contents()

void storage_assign_contents	(	storage	r,
		storage	v
	)

Definition at line 2247 of file ri.c.

                                                    {
   check_storage(r);
   check_storage(v);
   message_assert("defined references to domain storage",
                  storage_defined_p(r) && storage_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_storage_));
 }

References check_storage(), message_assert, and storage_defined_p().

Here is the call graph for this function:

◆ storage_consistent_p()

bool storage_consistent_p ( storage p )

Definition at line 2237 of file ri.c.

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

References check_storage(), and gen_consistent_p().

Here is the call graph for this function:

◆ storage_defined_p()

bool storage_defined_p ( storage p )

Definition at line 2241 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ storage_non_recursive_free()

void storage_non_recursive_free ( storage p )

Definition at line 2254 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ storage_tag_as_string()

string storage_tag_as_string ( enum storage_utype tag )

Definition at line 2264 of file ri.c.

                                                      {
   switch (tag) {
   case is_storage_return: return "return";
   case is_storage_ram: return "ram";
   case is_storage_formal: return "formal";
   case is_storage_rom: return "rom";
   default: return string_undefined;
   }
 }

References is_storage_formal, is_storage_ram, is_storage_return, is_storage_rom, and string_undefined.

◆ subscript_assign_contents()

void subscript_assign_contents	(	subscript	r,
		subscript	v
	)

Definition at line 2310 of file ri.c.

                                                          {
   check_subscript(r);
   check_subscript(v);
   message_assert("defined references to domain subscript",
                  subscript_defined_p(r) && subscript_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_subscript_));
 }

References check_subscript(), message_assert, and subscript_defined_p().

Here is the call graph for this function:

◆ subscript_consistent_p()

bool subscript_consistent_p ( subscript p )

Definition at line 2300 of file ri.c.

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

References check_subscript(), and gen_consistent_p().

Here is the call graph for this function:

◆ subscript_defined_p()

bool subscript_defined_p ( subscript p )

Definition at line 2304 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ subscript_non_recursive_free()

void subscript_non_recursive_free ( subscript p )

Definition at line 2317 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ symbolic_assign_contents()

void symbolic_assign_contents	(	symbolic	r,
		symbolic	v
	)

Definition at line 2352 of file ri.c.

                                                       {
   check_symbolic(r);
   check_symbolic(v);
   message_assert("defined references to domain symbolic",
                  symbolic_defined_p(r) && symbolic_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_symbolic_));
 }

References check_symbolic(), message_assert, and symbolic_defined_p().

Here is the call graph for this function:

◆ symbolic_consistent_p()

bool symbolic_consistent_p ( symbolic p )

Definition at line 2342 of file ri.c.

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

References check_symbolic(), and gen_consistent_p().

Here is the call graph for this function:

◆ symbolic_defined_p()

bool symbolic_defined_p ( symbolic p )

Definition at line 2346 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ symbolic_non_recursive_free()

void symbolic_non_recursive_free ( symbolic p )

Definition at line 2359 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ synchronization_assign_contents()

void synchronization_assign_contents	(	synchronization	r,
		synchronization	v
	)

Definition at line 2394 of file ri.c.

                                                                            {
   check_synchronization(r);
   check_synchronization(v);
   message_assert("defined references to domain synchronization",
                  synchronization_defined_p(r) && synchronization_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_synchronization_));
 }

References check_synchronization(), message_assert, and synchronization_defined_p().

Here is the call graph for this function:

◆ synchronization_consistent_p()

bool synchronization_consistent_p ( synchronization p )

Definition at line 2384 of file ri.c.

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

References check_synchronization(), and gen_consistent_p().

Here is the call graph for this function:

◆ synchronization_defined_p()

bool synchronization_defined_p ( synchronization p )

Definition at line 2388 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ synchronization_non_recursive_free()

void synchronization_non_recursive_free ( synchronization p )

Definition at line 2401 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ synchronization_tag_as_string()

string synchronization_tag_as_string ( enum synchronization_utype tag )

Definition at line 2411 of file ri.c.

                                                                      {
   switch (tag) {
   case is_synchronization_none: return "none";
   case is_synchronization_spawn: return "spawn";
   case is_synchronization_barrier: return "barrier";
   case is_synchronization_single: return "single";
   case is_synchronization_critical: return "critical";
   default: return string_undefined;
   }
 }

References is_synchronization_barrier, is_synchronization_critical, is_synchronization_none, is_synchronization_single, is_synchronization_spawn, and string_undefined.

◆ syntax_assign_contents()

void syntax_assign_contents	(	syntax	r,
		syntax	v
	)

Definition at line 2461 of file ri.c.

                                                 {
   check_syntax(r);
   check_syntax(v);
   message_assert("defined references to domain syntax",
                  syntax_defined_p(r) && syntax_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_syntax_));
 }

References check_syntax(), message_assert, and syntax_defined_p().

Here is the call graph for this function:

◆ syntax_consistent_p()

bool syntax_consistent_p ( syntax p )

Definition at line 2451 of file ri.c.

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

References check_syntax(), and gen_consistent_p().

Here is the call graph for this function:

◆ syntax_defined_p()

bool syntax_defined_p ( syntax p )

Definition at line 2455 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ syntax_non_recursive_free()

void syntax_non_recursive_free ( syntax p )

Definition at line 2468 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ syntax_tag_as_string()

string syntax_tag_as_string ( enum syntax_utype tag )

Definition at line 2478 of file ri.c.

                                                    {
   switch (tag) {
   case is_syntax_reference: return "reference";
   case is_syntax_range: return "range";
   case is_syntax_call: return "call";
   case is_syntax_cast: return "cast";
   case is_syntax_sizeofexpression: return "sizeofexpression";
   case is_syntax_subscript: return "subscript";
   case is_syntax_application: return "application";
   case is_syntax_va_arg: return "va_arg";
   default: return string_undefined;
   }
 }

References is_syntax_application, is_syntax_call, is_syntax_cast, is_syntax_range, is_syntax_reference, is_syntax_sizeofexpression, is_syntax_subscript, is_syntax_va_arg, and string_undefined.

◆ test_assign_contents()

void test_assign_contents	(	test	r,
		test	v
	)

Definition at line 2590 of file ri.c.

                                           {
   check_test(r);
   check_test(v);
   message_assert("defined references to domain test",
                  test_defined_p(r) && test_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_test_));
 }

References check_test(), message_assert, and test_defined_p().

Here is the call graph for this function:

◆ test_consistent_p()

bool test_consistent_p ( test p )

Definition at line 2580 of file ri.c.

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

References check_test(), and gen_consistent_p().

Here is the call graph for this function:

◆ test_defined_p()

bool test_defined_p ( test p )

Definition at line 2584 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ test_non_recursive_free()

void test_non_recursive_free ( test p )

Definition at line 2597 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ transformer_assign_contents()

void transformer_assign_contents	(	transformer	r,
		transformer	v
	)

Definition at line 2632 of file ri.c.

                                                                {
   check_transformer(r);
   check_transformer(v);
   message_assert("defined references to domain transformer",
                  transformer_defined_p(r) && transformer_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_transformer_));
 }

References check_transformer(), message_assert, and transformer_defined_p().

Here is the call graph for this function:

◆ transformer_consistent_p()

bool transformer_consistent_p ( transformer p )

Definition at line 2622 of file ri.c.

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

References check_transformer(), and gen_consistent_p().

Here is the call graph for this function:

◆ transformer_defined_p()

bool transformer_defined_p ( transformer p )

Definition at line 2626 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ transformer_non_recursive_free()

void transformer_non_recursive_free ( transformer p )

Definition at line 2639 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ type_assign_contents()

void type_assign_contents	(	type	r,
		type	v
	)

Definition at line 2674 of file ri.c.

                                           {
   check_type(r);
   check_type(v);
   message_assert("defined references to domain type",
                  type_defined_p(r) && type_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_type_));
 }

References check_type(), message_assert, and type_defined_p().

Here is the call graph for this function:

◆ type_consistent_p()

bool type_consistent_p ( type p )

Definition at line 2664 of file ri.c.

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

References check_type(), and gen_consistent_p().

Here is the call graph for this function:

◆ type_defined_p()

bool type_defined_p ( type p )

Definition at line 2668 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ type_non_recursive_free()

void type_non_recursive_free ( type p )

Definition at line 2681 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ type_tag_as_string()

string type_tag_as_string ( enum type_utype tag )

Definition at line 2691 of file ri.c.

                                                {
   switch (tag) {
   case is_type_statement: return "statement";
   case is_type_area: return "area";
   case is_type_variable: return "variable";
   case is_type_functional: return "functional";
   case is_type_varargs: return "varargs";
   case is_type_unknown: return "unknown";
   case is_type_void: return "void";
   case is_type_struct: return "struct";
   case is_type_union: return "union";
   case is_type_enum: return "enum";
   default: return string_undefined;
   }
 }

References is_type_area, is_type_enum, is_type_functional, is_type_statement, is_type_struct, is_type_union, is_type_unknown, is_type_varargs, is_type_variable, is_type_void, and string_undefined.

◆ unstructured_assign_contents()

void unstructured_assign_contents	(	unstructured	r,
		unstructured	v
	)

Definition at line 2761 of file ri.c.

                                                                   {
   check_unstructured(r);
   check_unstructured(v);
   message_assert("defined references to domain unstructured",
                  unstructured_defined_p(r) && unstructured_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_unstructured_));
 }

References check_unstructured(), message_assert, and unstructured_defined_p().

Here is the call graph for this function:

◆ unstructured_consistent_p()

bool unstructured_consistent_p ( unstructured p )

Definition at line 2751 of file ri.c.

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

References check_unstructured(), and gen_consistent_p().

Here is the call graph for this function:

◆ unstructured_defined_p()

bool unstructured_defined_p ( unstructured p )

Definition at line 2755 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ unstructured_non_recursive_free()

void unstructured_non_recursive_free ( unstructured p )

Definition at line 2768 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ update_controlmap()

void update_controlmap	(	controlmap	f,
		statement	k,
		control	v
	)

Definition at line 472 of file ri.c.

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

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

Here is the call graph for this function:

◆ update_entity_int()

void update_entity_int	(	entity_int	f,
		entity	k,
		intptr_t	v
	)

Definition at line 668 of file ri.c.

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

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

Here is the call graph for this function:

◆ update_entity_to_entity()

void update_entity_to_entity	(	entity_to_entity	f,
		entity	k,
		entity	v
	)

Definition at line 725 of file ri.c.

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

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

Here is the call graph for this function:

◆ update_persistant_statement_to_cluster()

void update_persistant_statement_to_cluster	(	persistant_statement_to_cluster	f,
		intptr_t	k,
		intptr_t	v
	)

Definition at line 1543 of file ri.c.

                                                                                                        {
   HASH_UPDATE(i, i, persistant_statement_to_cluster_hash_table(f), k, (intptr_t)v);
 }

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

Here is the call graph for this function:

◆ update_persistant_statement_to_control()

void update_persistant_statement_to_control	(	persistant_statement_to_control	f,
		statement	k,
		control	v
	)

Definition at line 1600 of file ri.c.

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

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

Here is the call graph for this function:

◆ update_persistant_statement_to_int()

void update_persistant_statement_to_int	(	persistant_statement_to_int	f,
		statement	k,
		intptr_t	v
	)

Definition at line 1657 of file ri.c.

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

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

Here is the call graph for this function:

◆ update_persistant_statement_to_statement()

void update_persistant_statement_to_statement	(	persistant_statement_to_statement	f,
		statement	k,
		statement	v
	)

Definition at line 1714 of file ri.c.

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

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

Here is the call graph for this function:

◆ value_assign_contents()

void value_assign_contents	(	value	r,
		value	v
	)

Definition at line 2803 of file ri.c.

                                              {
   check_value(r);
   check_value(v);
   message_assert("defined references to domain value",
                  value_defined_p(r) && value_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_value_));
 }

References check_value(), message_assert, and value_defined_p().

Here is the call graph for this function:

◆ value_consistent_p()

bool value_consistent_p ( value p )

Definition at line 2793 of file ri.c.

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

References check_value(), and gen_consistent_p().

Here is the call graph for this function:

◆ value_defined_p()

bool value_defined_p ( value p )

Definition at line 2797 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ value_non_recursive_free()

void value_non_recursive_free ( value p )

Definition at line 2810 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ value_tag_as_string()

string value_tag_as_string ( enum value_utype tag )

Definition at line 2820 of file ri.c.

                                                  {
   switch (tag) {
   case is_value_code: return "code";
   case is_value_symbolic: return "symbolic";
   case is_value_constant: return "constant";
   case is_value_intrinsic: return "intrinsic";
   case is_value_unknown: return "unknown";
   case is_value_expression: return "expression";
   case is_value_reference: return "reference";
   default: return string_undefined;
   }
 }

References is_value_code, is_value_constant, is_value_expression, is_value_intrinsic, is_value_reference, is_value_symbolic, is_value_unknown, and string_undefined.

◆ variable_assign_contents()

void variable_assign_contents	(	variable	r,
		variable	v
	)

Definition at line 2878 of file ri.c.

                                                       {
   check_variable(r);
   check_variable(v);
   message_assert("defined references to domain variable",
                  variable_defined_p(r) && variable_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_variable_));
 }

References check_variable(), message_assert, and variable_defined_p().

Here is the call graph for this function:

◆ variable_consistent_p()

bool variable_consistent_p ( variable p )

Definition at line 2868 of file ri.c.

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

References check_variable(), and gen_consistent_p().

Here is the call graph for this function:

◆ variable_defined_p()

bool variable_defined_p ( variable p )

Definition at line 2872 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ variable_non_recursive_free()

void variable_non_recursive_free ( variable p )

Definition at line 2885 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ whileloop_assign_contents()

void whileloop_assign_contents	(	whileloop	r,
		whileloop	v
	)

Definition at line 2920 of file ri.c.

                                                          {
   check_whileloop(r);
   check_whileloop(v);
   message_assert("defined references to domain whileloop",
                  whileloop_defined_p(r) && whileloop_defined_p(v));
        memcpy(r, v, sizeof(struct _newgen_struct_whileloop_));
 }

References check_whileloop(), message_assert, and whileloop_defined_p().

Here is the call graph for this function:

◆ whileloop_consistent_p()

bool whileloop_consistent_p ( whileloop p )

Definition at line 2910 of file ri.c.

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

References check_whileloop(), and gen_consistent_p().

Here is the call graph for this function:

◆ whileloop_defined_p()

bool whileloop_defined_p ( whileloop p )

Definition at line 2914 of file ri.c.

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

References gen_defined_p().

Here is the call graph for this function:

◆ whileloop_non_recursive_free()

void whileloop_non_recursive_free ( whileloop p )

Definition at line 2927 of file ri.c.

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

References free().

Here is the call graph for this function:

◆ write_application()

void write_application	(	FILE *	f,
		application	p
	)

Definition at line 50 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_area()

void write_area	(	FILE *	f,
		area	p
	)

Definition at line 92 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_basic()

void write_basic	(	FILE *	f,
		basic	p
	)

Definition at line 134 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_call()

void write_call	(	FILE *	f,
		call	p
	)

Definition at line 263 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_callees()

void write_callees	(	FILE *	f,
		callees	p
	)

Definition at line 221 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_cast()

void write_cast	(	FILE *	f,
		cast	p
	)

Definition at line 305 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_code()

void write_code	(	FILE *	f,
		code	p
	)

Definition at line 347 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_constant()

void write_constant	(	FILE *	f,
		constant	p
	)

Definition at line 389 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_control()

void write_control	(	FILE *	f,
		control	p
	)

Definition at line 517 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_controlmap()

void write_controlmap	(	FILE *	f,
		controlmap	p
	)

Definition at line 460 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_dimension()

void write_dimension	(	FILE *	f,
		dimension	p
	)

Definition at line 559 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_dummy()

void write_dummy	(	FILE *	f,
		dummy	p
	)

Definition at line 601 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_entity_int()

void write_entity_int	(	FILE *	f,
		entity_int	p
	)

Definition at line 656 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_entity_to_entity()

void write_entity_to_entity	(	FILE *	f,
		entity_to_entity	p
	)

Definition at line 713 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_evaluation()

void write_evaluation	(	FILE *	f,
		evaluation	p
	)

Definition at line 770 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_execution()

void write_execution	(	FILE *	f,
		execution	p
	)

Definition at line 825 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_expression()

void write_expression	(	FILE *	f,
		expression	p
	)

Definition at line 880 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_extension()

void write_extension	(	FILE *	f,
		extension	p
	)

Definition at line 922 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_extensions()

void write_extensions	(	FILE *	f,
		extensions	p
	)

Definition at line 977 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_forloop()

void write_forloop	(	FILE *	f,
		forloop	p
	)

Definition at line 1019 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_formal()

void write_formal	(	FILE *	f,
		formal	p
	)

Definition at line 1061 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_functional()

void write_functional	(	FILE *	f,
		functional	p
	)

Definition at line 1103 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_instruction()

void write_instruction	(	FILE *	f,
		instruction	p
	)

Definition at line 1145 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_language()

void write_language	(	FILE *	f,
		language	p
	)

Definition at line 1232 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_loop()

void write_loop	(	FILE *	f,
		loop	p
	)

Definition at line 1295 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_mode()

void write_mode	(	FILE *	f,
		mode	p
	)

Definition at line 1337 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_multitest()

void write_multitest	(	FILE *	f,
		multitest	p
	)

Definition at line 1392 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_normalized()

void write_normalized	(	FILE *	f,
		normalized	p
	)

Definition at line 1434 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_parameter()

void write_parameter	(	FILE *	f,
		parameter	p
	)

Definition at line 1489 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_persistant_statement_to_cluster()

void write_persistant_statement_to_cluster	(	FILE *	f,
		persistant_statement_to_cluster	p
	)

Definition at line 1531 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_persistant_statement_to_control()

void write_persistant_statement_to_control	(	FILE *	f,
		persistant_statement_to_control	p
	)

Definition at line 1588 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_persistant_statement_to_int()

void write_persistant_statement_to_int	(	FILE *	f,
		persistant_statement_to_int	p
	)

Definition at line 1645 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_persistant_statement_to_statement()

void write_persistant_statement_to_statement	(	FILE *	f,
		persistant_statement_to_statement	p
	)

Definition at line 1702 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_pragma()

void write_pragma	(	FILE *	f,
		pragma	p
	)

Definition at line 1759 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_predicate()

void write_predicate	(	FILE *	f,
		predicate	p
	)

Definition at line 1814 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_preference()

void write_preference	(	FILE *	f,
		preference	p
	)

Definition at line 1856 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_qualifier()

void write_qualifier	(	FILE *	f,
		qualifier	p
	)

Definition at line 1898 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_ram()

void write_ram	(	FILE *	f,
		ram	p
	)

Definition at line 1993 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_range()

void write_range	(	FILE *	f,
		range	p
	)

Definition at line 2035 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_reference()

void write_reference	(	FILE *	f,
		reference	p
	)

Definition at line 2077 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_sequence()

void write_sequence	(	FILE *	f,
		sequence	p
	)

Definition at line 2119 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_sizeofexpression()

void write_sizeofexpression	(	FILE *	f,
		sizeofexpression	p
	)

Definition at line 2161 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_statement()

void write_statement	(	FILE *	f,
		statement	p
	)

Definition at line 2216 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_storage()

void write_storage	(	FILE *	f,
		storage	p
	)

Definition at line 2258 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_subscript()

void write_subscript	(	FILE *	f,
		subscript	p
	)

Definition at line 2321 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_symbolic()

void write_symbolic	(	FILE *	f,
		symbolic	p
	)

Definition at line 2363 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_synchronization()

void write_synchronization	(	FILE *	f,
		synchronization	p
	)

Definition at line 2405 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_syntax()

void write_syntax	(	FILE *	f,
		syntax	p
	)

Definition at line 2472 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_tabulated_entity()

void write_tabulated_entity ( FILE * f )

Definition at line 2554 of file ri.c.

                                      {
   (void) gen_write_tabulated(f, entity_domain);
 }

References entity_domain, f(), and gen_write_tabulated().

Here is the call graph for this function:

◆ write_test()

void write_test	(	FILE *	f,
		test	p
	)

Definition at line 2601 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_transformer()

void write_transformer	(	FILE *	f,
		transformer	p
	)

Definition at line 2643 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_type()

void write_type	(	FILE *	f,
		type	p
	)

Definition at line 2685 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_unstructured()

void write_unstructured	(	FILE *	f,
		unstructured	p
	)

Definition at line 2772 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_value()

void write_value	(	FILE *	f,
		value	p
	)

Definition at line 2814 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_variable()

void write_variable	(	FILE *	f,
		variable	p
	)

Definition at line 2889 of file ri.c.

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

References f(), and gen_write().

Here is the call graph for this function:

◆ write_whileloop()

void write_whileloop	(	FILE *	f,
		whileloop	p
	)

Definition at line 2931 of file ri.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

◆ Pvecteur

Function Documentation

◆ application_assign_contents()

◆ application_consistent_p()

◆ application_defined_p()

◆ application_non_recursive_free()

◆ apply_controlmap()

◆ apply_entity_int()

◆ apply_entity_to_entity()

◆ apply_persistant_statement_to_cluster()

◆ apply_persistant_statement_to_control()

◆ apply_persistant_statement_to_int()

◆ apply_persistant_statement_to_statement()

◆ area_assign_contents()

◆ area_consistent_p()

◆ area_defined_p()

◆ area_non_recursive_free()

◆ basic_assign_contents()

◆ basic_consistent_p()

◆ basic_defined_p()

◆ basic_non_recursive_free()

◆ basic_tag_as_string()

◆ bound_controlmap_p()

◆ bound_entity_int_p()

◆ bound_entity_to_entity_p()

◆ bound_persistant_statement_to_cluster_p()

◆ bound_persistant_statement_to_control_p()

◆ bound_persistant_statement_to_int_p()

◆ bound_persistant_statement_to_statement_p()

◆ call_assign_contents()

◆ call_consistent_p()

◆ call_defined_p()

◆ call_non_recursive_free()

◆ callees_assign_contents()

◆ callees_consistent_p()

◆ callees_defined_p()

◆ callees_non_recursive_free()

◆ cast_assign_contents()

◆ cast_consistent_p()

◆ cast_defined_p()

◆ cast_non_recursive_free()

◆ check_application()

◆ check_area()

◆ check_basic()

◆ check_call()

◆ check_callees()

◆ check_cast()

◆ check_code()

◆ check_constant()

◆ check_control()

◆ check_controlmap()

◆ check_dimension()

◆ check_dummy()

◆ check_entity()

◆ check_entity_int()

◆ check_entity_to_entity()

◆ check_evaluation()

◆ check_execution()

◆ check_expression()

◆ check_extension()

◆ check_extensions()

◆ check_forloop()

◆ check_formal()

◆ check_functional()

◆ check_instruction()

◆ check_language()

◆ check_loop()

◆ check_mode()

◆ check_multitest()

◆ check_normalized()

◆ check_parameter()

◆ check_persistant_statement_to_cluster()

◆ check_persistant_statement_to_control()

◆ check_persistant_statement_to_int()

◆ check_persistant_statement_to_statement()

◆ check_pragma()