1523 message_assert(
"defined references to domain persistant_statement_to_cluster",
1580 message_assert(
"defined references to domain persistant_statement_to_control",
1637 message_assert(
"defined references to domain persistant_statement_to_int",
1694 message_assert(
"defined references to domain persistant_statement_to_statement",
2223 return (
statement)
gen_alloc(10*
sizeof(
gen_chunk),
GEN_CHECK_ALLOC,
statement_domain, a1, a2, a3, a4, a5, a6, a7, a8, a9);
2560 fprintf(stderr,
"[newgen internal error]""inconsistent domain number for entity: %d (expecting %d)\n",
instruction make_instruction_loop(loop _field_)
list gen_multitest_cons(multitest p, list l)
bool entity_int_defined_p(entity_int p)
bool execution_consistent_p(execution p)
void free_transformer(transformer p)
list gen_area_cons(area p, list l)
void functional_assign_contents(functional r, functional v)
bool application_defined_p(application p)
bool pragma_consistent_p(pragma p)
dummy make_dummy_identifier(entity _field_)
void free_forloop(forloop p)
normalized copy_normalized(normalized p)
NORMALIZED.
syntax make_syntax_application(application _field_)
qualifier make_qualifier_static_dimension(void)
void write_code(FILE *f, code p)
void free_application(application p)
list gen_persistant_statement_to_int_cons(persistant_statement_to_int p, list l)
bool sizeofexpression_defined_p(sizeofexpression p)
list gen_constant_cons(constant p, list l)
void write_call(FILE *f, call p)
bool preference_consistent_p(preference p)
void free_functional(functional p)
list gen_value_cons(value p, list l)
callees check_callees(callees p)
void free_persistant_statement_to_statement(persistant_statement_to_statement p)
bool instruction_consistent_p(instruction p)
formal read_formal(FILE *f)
void write_whileloop(FILE *f, whileloop p)
void free_normalized(normalized p)
void whileloop_non_recursive_free(whileloop p)
list gen_expression_cons(expression p, list l)
bool persistant_statement_to_control_defined_p(persistant_statement_to_control p)
transformer make_transformer(list a1, predicate a2)
string normalized_tag_as_string(enum normalized_utype tag)
void write_variable(FILE *f, variable p)
unstructured make_unstructured(control a1, control a2)
extension make_extension(enum extension_utype tag, void *val)
void write_formal(FILE *f, formal p)
void free_sizeofexpression(sizeofexpression p)
list gen_application_cons(application p, list l)
void update_controlmap(controlmap f, statement k, control v)
predicate copy_predicate(predicate p)
PREDICATE.
functional make_functional(list a1, type a2)
synchronization check_synchronization(synchronization p)
intptr_t apply_entity_int(entity_int f, entity k)
qualifier make_qualifier_constant(void)
void write_entity_int(FILE *f, entity_int p)
constant read_constant(FILE *f)
synchronization copy_synchronization(synchronization p)
SYNCHRONIZATION.
instruction read_instruction(FILE *f)
cast make_cast(type a1, expression a2)
dummy make_dummy(enum dummy_utype tag, void *val)
language make_language_fortran95(void)
void update_persistant_statement_to_cluster(persistant_statement_to_cluster f, intptr_t k, intptr_t v)
execution make_execution(enum execution_utype tag, void *val)
bool evaluation_consistent_p(evaluation p)
multitest copy_multitest(multitest p)
MULTITEST.
void test_non_recursive_free(test p)
void write_synchronization(FILE *f, synchronization p)
void entity_assign_contents(entity r, entity v)
bool type_defined_p(type p)
void call_non_recursive_free(call p)
void range_non_recursive_free(range p)
void reference_non_recursive_free(reference p)
evaluation make_evaluation_before(void)
bool forloop_defined_p(forloop p)
instruction copy_instruction(instruction p)
INSTRUCTION.
void update_persistant_statement_to_control(persistant_statement_to_control f, statement k, control v)
void sizeofexpression_assign_contents(sizeofexpression r, sizeofexpression v)
call make_call(entity a1, list a2)
void normalized_assign_contents(normalized r, normalized v)
list gen_basic_cons(basic p, list l)
void basic_non_recursive_free(basic p)
void persistant_statement_to_statement_non_recursive_free(persistant_statement_to_statement p)
string evaluation_tag_as_string(enum evaluation_utype tag)
constant make_constant(enum constant_utype tag, void *val)
string syntax_tag_as_string(enum syntax_utype tag)
bool code_consistent_p(code p)
loop copy_loop(loop p)
LOOP.
bool unstructured_consistent_p(unstructured p)
bool expression_defined_p(expression p)
dimension read_dimension(FILE *f)
persistant_statement_to_statement read_persistant_statement_to_statement(FILE *f)
parameter copy_parameter(parameter p)
PARAMETER.
void write_area(FILE *f, area p)
qualifier make_qualifier_private(void)
basic read_basic(FILE *f)
bool reference_consistent_p(reference p)
void write_application(FILE *f, application p)
list gen_extensions_cons(extensions p, list l)
multitest read_multitest(FILE *f)
bool entity_int_consistent_p(entity_int p)
void constant_assign_contents(constant r, constant v)
bool multitest_consistent_p(multitest p)
void free_persistant_statement_to_cluster(persistant_statement_to_cluster p)
entity_int read_entity_int(FILE *f)
basic make_basic_complex(intptr_t _field_)
void write_functional(FILE *f, functional p)
normalized make_normalized(enum normalized_utype tag, void *val)
controlmap make_controlmap(void)
bool controlmap_consistent_p(controlmap p)
persistant_statement_to_cluster check_persistant_statement_to_cluster(persistant_statement_to_cluster p)
preference copy_preference(preference p)
PREFERENCE.
bool whileloop_defined_p(whileloop p)
void write_preference(FILE *f, preference p)
void free_extension(extension p)
void variable_non_recursive_free(variable p)
void formal_assign_contents(formal r, formal v)
void entity_non_recursive_free(entity p)
preference read_preference(FILE *f)
intptr_t delete_entity_int(entity_int f, entity k)
range check_range(range p)
instruction make_instruction_forloop(forloop _field_)
subscript check_subscript(subscript p)
range copy_range(range p)
RANGE.
list gen_qualifier_cons(qualifier p, list l)
void transformer_assign_contents(transformer r, transformer v)
basic make_basic_typedef(entity _field_)
bool parameter_consistent_p(parameter p)
bool syntax_defined_p(syntax p)
void loop_non_recursive_free(loop p)
persistant_statement_to_int read_persistant_statement_to_int(FILE *f)
bool whileloop_consistent_p(whileloop p)
bool reference_defined_p(reference p)
void write_entity_to_entity(FILE *f, entity_to_entity p)
void write_reference(FILE *f, reference p)
persistant_statement_to_control make_persistant_statement_to_control(void)
bool persistant_statement_to_statement_consistent_p(persistant_statement_to_statement p)
list gen_pragma_cons(pragma p, list l)
value make_value_unknown(void)
basic make_basic_derived(entity _field_)
value make_value_expression(expression _field_)
parameter make_parameter(type a1, mode a2, dummy a3)
sizeofexpression make_sizeofexpression_expression(expression _field_)
syntax make_syntax_call(call _field_)
bool sequence_consistent_p(sequence p)
expression make_expression(syntax a1, normalized a2)
bool predicate_consistent_p(predicate p)
reference check_reference(reference p)
bool language_defined_p(language p)
bool transformer_defined_p(transformer p)
type make_type_union(list _field_)
void write_expression(FILE *f, expression p)
list gen_extension_cons(extension p, list l)
extensions read_extensions(FILE *f)
bool functional_consistent_p(functional p)
list gen_evaluation_cons(evaluation p, list l)
normalized check_normalized(normalized p)
void predicate_assign_contents(predicate r, predicate v)
void free_parameter(parameter p)
whileloop make_whileloop(expression a1, statement a2, entity a3, evaluation a4)
application make_application(expression a1, list a2)
bool unstructured_defined_p(unstructured p)
void write_extensions(FILE *f, extensions p)
basic make_basic_bit(symbolic _field_)
bool evaluation_defined_p(evaluation p)
void pragma_assign_contents(pragma r, pragma v)
void value_non_recursive_free(value p)
void free_whileloop(whileloop p)
bool bound_controlmap_p(controlmap f, statement k)
void normalized_non_recursive_free(normalized p)
list gen_code_cons(code p, list l)
entity_to_entity make_entity_to_entity(void)
bool entity_to_entity_consistent_p(entity_to_entity p)
void write_language(FILE *f, language p)
storage check_storage(storage p)
evaluation read_evaluation(FILE *f)
void update_persistant_statement_to_int(persistant_statement_to_int f, statement k, intptr_t v)
value make_value_code(code _field_)
symbolic copy_symbolic(symbolic p)
SYMBOLIC.
loop make_loop(entity a1, range a2, statement a3, entity a4, execution a5, list a6)
bool symbolic_consistent_p(symbolic p)
void free_control(control p)
void execution_non_recursive_free(execution p)
language make_language_fortran(void)
list gen_entity_to_entity_cons(entity_to_entity p, list l)
qualifier make_qualifier_local(void)
void ram_non_recursive_free(ram p)
unstructured read_unstructured(FILE *f)
mode make_mode(enum mode_utype tag, void *val)
void write_dimension(FILE *f, dimension p)
subscript make_subscript(expression a1, list a2)
void entity_int_non_recursive_free(entity_int p)
bool mode_defined_p(mode p)
list gen_entity_cons(entity p, list l)
instruction check_instruction(instruction p)
pragma copy_pragma(pragma p)
PRAGMA.
void storage_non_recursive_free(storage p)
void sequence_non_recursive_free(sequence p)
entity_to_entity copy_entity_to_entity(entity_to_entity p)
ENTITY_TO_ENTITY.
bool formal_consistent_p(formal p)
void write_normalized(FILE *f, normalized p)
void parameter_assign_contents(parameter r, parameter v)
void language_assign_contents(language r, language v)
void formal_non_recursive_free(formal p)
cast copy_cast(cast p)
CAST.
list gen_subscript_cons(subscript p, list l)
void mode_assign_contents(mode r, mode v)
void language_non_recursive_free(language p)
void free_symbolic(symbolic p)
void extend_persistant_statement_to_cluster(persistant_statement_to_cluster f, intptr_t k, intptr_t v)
void dummy_non_recursive_free(dummy p)
execution check_execution(execution p)
expression check_expression(expression p)
type make_type_variable(variable _field_)
basic make_basic(enum basic_utype tag, void *val)
void qualifier_assign_contents(qualifier r, qualifier v)
void area_assign_contents(area r, area v)
string storage_tag_as_string(enum storage_utype tag)
bool persistant_statement_to_int_consistent_p(persistant_statement_to_int p)
entity_to_entity read_entity_to_entity(FILE *f)
bool bound_persistant_statement_to_statement_p(persistant_statement_to_statement f, statement k)
void sizeofexpression_non_recursive_free(sizeofexpression p)
void preference_assign_contents(preference r, preference v)
storage make_storage_rom(void)
entity gen_find_entity(char *s)
void multitest_non_recursive_free(multitest p)
value make_value_constant(constant _field_)
void free_entity(entity p)
functional check_functional(functional p)
syntax make_syntax_sizeofexpression(sizeofexpression _field_)
qualifier make_qualifier_thread(void)
synchronization make_synchronization(enum synchronization_utype tag, void *val)
language read_language(FILE *f)
void extension_non_recursive_free(extension p)
bool persistant_statement_to_cluster_defined_p(persistant_statement_to_cluster p)
bool pragma_defined_p(pragma p)
application check_application(application p)
list gen_language_cons(language p, list l)
void application_assign_contents(application r, application v)
mode make_mode_reference(void)
list gen_parameter_cons(parameter p, list l)
forloop check_forloop(forloop p)
test copy_test(test p)
TEST.
statement apply_persistant_statement_to_statement(persistant_statement_to_statement f, statement k)
predicate make_predicate(Psysteme a1)
type copy_type(type p)
TYPE.
list gen_callees_cons(callees p, list l)
list gen_variable_cons(variable p, list l)
constant make_constant_logical(intptr_t _field_)
void sequence_assign_contents(sequence r, sequence v)
void persistant_statement_to_cluster_non_recursive_free(persistant_statement_to_cluster p)
void free_entity_to_entity(entity_to_entity p)
qualifier read_qualifier(FILE *f)
void free_reference(reference p)
basic copy_basic(basic p)
BASIC.
instruction make_instruction_expression(expression _field_)
language make_language(enum language_utype tag, void *val)
persistant_statement_to_control check_persistant_statement_to_control(persistant_statement_to_control p)
void callees_assign_contents(callees r, callees v)
void write_persistant_statement_to_cluster(FILE *f, persistant_statement_to_cluster p)
normalized read_normalized(FILE *f)
void statement_assign_contents(statement r, statement v)
pragma read_pragma(FILE *f)
sizeofexpression check_sizeofexpression(sizeofexpression p)
void qualifier_non_recursive_free(qualifier p)
basic make_basic_overloaded(void)
predicate read_predicate(FILE *f)
void write_controlmap(FILE *f, controlmap p)
void write_storage(FILE *f, storage p)
qualifier make_qualifier_restrict(void)
void write_mode(FILE *f, mode p)
void free_callees(callees p)
bool predicate_defined_p(predicate p)
persistant_statement_to_control copy_persistant_statement_to_control(persistant_statement_to_control p)
PERSISTANT_STATEMENT_TO_CONTROL.
list gen_controlmap_cons(controlmap p, list l)
control check_control(control p)
parameter read_parameter(FILE *f)
void entity_to_entity_assign_contents(entity_to_entity r, entity_to_entity v)
storage make_storage(enum storage_utype tag, void *val)
void write_sizeofexpression(FILE *f, sizeofexpression p)
void free_pragma(pragma p)
pragma make_pragma_expression(list _field_)
void free_constant(constant p)
language make_language_unknown(void)
type make_type_struct(list _field_)
basic make_basic_int(intptr_t _field_)
persistant_statement_to_statement make_persistant_statement_to_statement(void)
void update_persistant_statement_to_statement(persistant_statement_to_statement f, statement k, statement v)
ram make_ram(entity a1, entity a2, intptr_t a3, list a4)
bool multitest_defined_p(multitest p)
void update_entity_int(entity_int f, entity k, intptr_t v)
bool statement_defined_p(statement p)
forloop read_forloop(FILE *f)
type make_type_functional(functional _field_)
void free_qualifier(qualifier p)
synchronization make_synchronization_critical(reference _field_)
type make_type_void(list _field_)
basic make_basic_pointer(type _field_)
syntax check_syntax(syntax p)
void extensions_non_recursive_free(extensions p)
bool test_defined_p(test p)
void free_preference(preference p)
variable copy_variable(variable p)
VARIABLE.
qualifier make_qualifier(enum qualifier_utype tag, void *val)
type make_type_statement(void)
bool entity_defined_p(entity p)
bool value_consistent_p(value p)
list gen_dimension_cons(dimension p, list l)
expression copy_expression(expression p)
EXPRESSION.
constant make_constant_float(float _field_)
intptr_t delete_persistant_statement_to_cluster(persistant_statement_to_cluster f, intptr_t k)
void read_tabulated_entity(FILE *f)
statement copy_statement(statement p)
STATEMENT.
void unstructured_assign_contents(unstructured r, unstructured v)
void expression_non_recursive_free(expression p)
void write_parameter(FILE *f, parameter p)
string sizeofexpression_tag_as_string(enum sizeofexpression_utype tag)
void extend_persistant_statement_to_statement(persistant_statement_to_statement f, statement k, statement v)
string extension_tag_as_string(enum extension_utype tag)
value make_value(enum value_utype tag, void *val)
application copy_application(application p)
APPLICATION.
void dummy_assign_contents(dummy r, dummy v)
bool controlmap_defined_p(controlmap p)
list gen_ram_cons(ram p, list l)
reference make_reference(entity a1, list a2)
void persistant_statement_to_int_non_recursive_free(persistant_statement_to_int p)
list gen_dummy_cons(dummy p, list l)
list gen_persistant_statement_to_control_cons(persistant_statement_to_control p, list l)
void free_extensions(extensions p)
bool bound_entity_to_entity_p(entity_to_entity f, entity k)
bool execution_defined_p(execution p)
void predicate_non_recursive_free(predicate p)
void callees_non_recursive_free(callees p)
bool transformer_consistent_p(transformer p)
void reference_assign_contents(reference r, reference v)
subscript copy_subscript(subscript p)
SUBSCRIPT.
constant make_constant_call(entity _field_)
string constant_tag_as_string(enum constant_utype tag)
void extensions_assign_contents(extensions r, extensions v)
value make_value_reference(reference _field_)
void extend_persistant_statement_to_int(persistant_statement_to_int f, statement k, intptr_t v)
value check_value(value p)
synchronization make_synchronization_single(bool _field_)
bool persistant_statement_to_cluster_consistent_p(persistant_statement_to_cluster p)
whileloop copy_whileloop(whileloop p)
WHILELOOP.
void write_cast(FILE *f, cast p)
void instruction_non_recursive_free(instruction p)
sizeofexpression copy_sizeofexpression(sizeofexpression p)
SIZEOFEXPRESSION.
bool dimension_consistent_p(dimension p)
bool statement_consistent_p(statement p)
language copy_language(language p)
LANGUAGE.
list gen_formal_cons(formal p, list l)
void persistant_statement_to_int_assign_contents(persistant_statement_to_int r, persistant_statement_to_int v)
test make_test(expression a1, statement a2, statement a3)
forloop copy_forloop(forloop p)
FORLOOP.
void evaluation_non_recursive_free(evaluation p)
statement delete_persistant_statement_to_statement(persistant_statement_to_statement f, statement k)
bool loop_defined_p(loop p)
list gen_range_cons(range p, list l)
bool formal_defined_p(formal p)
void write_instruction(FILE *f, instruction p)
bool range_consistent_p(range p)
void loop_assign_contents(loop r, loop v)
bool forloop_consistent_p(forloop p)
preference check_preference(preference p)
void subscript_non_recursive_free(subscript p)
void multitest_assign_contents(multitest r, multitest v)
void forloop_non_recursive_free(forloop p)
void synchronization_non_recursive_free(synchronization p)
entity_to_entity check_entity_to_entity(entity_to_entity p)
entity check_entity(entity p)
intptr_t delete_persistant_statement_to_int(persistant_statement_to_int f, statement k)
list gen_sequence_cons(sequence p, list l)
bool storage_defined_p(storage p)
void symbolic_non_recursive_free(symbolic p)
void write_test(FILE *f, test p)
bool language_consistent_p(language p)
control copy_control(control p)
CONTROL.
extensions make_extensions(list a)
functional copy_functional(functional p)
FUNCTIONAL.
constant make_constant_int(intptr_t _field_)
persistant_statement_to_int check_persistant_statement_to_int(persistant_statement_to_int p)
void extension_assign_contents(extension r, extension v)
void cast_assign_contents(cast r, cast v)
basic make_basic_float(intptr_t _field_)
bool area_consistent_p(area p)
void execution_assign_contents(execution r, execution v)
void write_pragma(FILE *f, pragma p)
void synchronization_assign_contents(synchronization r, synchronization v)
void persistant_statement_to_control_non_recursive_free(persistant_statement_to_control p)
void subscript_assign_contents(subscript r, subscript v)
list gen_control_cons(control p, list l)
dimension make_dimension(expression a1, expression a2, list a3)
dimension copy_dimension(dimension p)
DIMENSION.
void write_sequence(FILE *f, sequence p)
void range_assign_contents(range r, range v)
bool value_defined_p(value p)
list gen_symbolic_cons(symbolic p, list l)
bool normalized_consistent_p(normalized p)
void syntax_non_recursive_free(syntax p)
reference read_reference(FILE *f)
string language_tag_as_string(enum language_utype tag)
extensions check_extensions(extensions p)
sizeofexpression make_sizeofexpression_type(type _field_)
void storage_assign_contents(storage r, storage v)
bool code_defined_p(code p)
void syntax_assign_contents(syntax r, syntax v)
execution make_execution_sequential(void)
string dummy_tag_as_string(enum dummy_utype tag)
statement make_statement(entity a1, intptr_t a2, intptr_t a3, string a4, instruction a5, list a6, string a7, extensions a8, synchronization a9)
symbolic make_symbolic(expression a1, constant a2)
void entity_int_assign_contents(entity_int r, entity_int v)
bool dummy_consistent_p(dummy p)
bool persistant_statement_to_int_defined_p(persistant_statement_to_int p)
bool qualifier_consistent_p(qualifier p)
variable read_variable(FILE *f)
type make_type_area(area _field_)
void constant_non_recursive_free(constant p)
instruction make_instruction_sequence(sequence _field_)
bool bound_persistant_statement_to_cluster_p(persistant_statement_to_cluster f, intptr_t k)
list gen_predicate_cons(predicate p, list l)
qualifier make_qualifier_register(void)
void free_formal(formal p)
list gen_entity_int_cons(entity_int p, list l)
bool synchronization_defined_p(synchronization p)
bool basic_defined_p(basic p)
variable make_variable(basic a1, list a2, list a3)
void preference_non_recursive_free(preference p)
evaluation copy_evaluation(evaluation p)
EVALUATION.
void ram_assign_contents(ram r, ram v)
range read_range(FILE *f)
string synchronization_tag_as_string(enum synchronization_utype tag)
extension make_extension_pragma(pragma _field_)
instruction make_instruction_test(test _field_)
dummy read_dummy(FILE *f)
mode copy_mode(mode p)
MODE.
void free_evaluation(evaluation p)
list gen_normalized_cons(normalized p, list l)
application read_application(FILE *f)
instruction make_instruction_call(call _field_)
syntax make_syntax_va_arg(list _field_)
void free_multitest(multitest p)
string instruction_tag_as_string(enum instruction_utype tag)
void persistant_statement_to_statement_assign_contents(persistant_statement_to_statement r, persistant_statement_to_statement v)
entity make_entity(string a1, type a2, storage a3, value a4, intptr_t a5)
symbolic read_symbolic(FILE *f)
persistant_statement_to_int copy_persistant_statement_to_int(persistant_statement_to_int p)
PERSISTANT_STATEMENT_TO_INT.
void free_subscript(subscript p)
value copy_value(value p)
VALUE.
list gen_transformer_cons(transformer p, list l)
bool call_consistent_p(call p)
basic make_basic_logical(intptr_t _field_)
language check_language(language p)
qualifier make_qualifier_volatile(void)
evaluation make_evaluation(enum evaluation_utype tag, void *val)
list gen_functional_cons(functional p, list l)
list gen_mode_cons(mode p, list l)
formal copy_formal(formal p)
FORMAL.
predicate check_predicate(predicate p)
bool synchronization_consistent_p(synchronization p)
bool extensions_defined_p(extensions p)
transformer check_transformer(transformer p)
variable check_variable(variable p)
formal check_formal(formal p)
void write_value(FILE *f, value p)
void write_ram(FILE *f, ram p)
expression read_expression(FILE *f)
normalized make_normalized_linear(Pvecteur _field_)
list gen_loop_cons(loop p, list l)
void free_unstructured(unstructured p)
area make_area(intptr_t a1, list a2)
string qualifier_tag_as_string(enum qualifier_utype tag)
code copy_code(code p)
CODE.
basic make_basic_string(value _field_)
void free_entity_int(entity_int p)
code make_code(list a1, string a2, sequence a3, list a4, language a5)
bool parameter_defined_p(parameter p)
qualifier check_qualifier(qualifier p)
bool expression_consistent_p(expression p)
whileloop check_whileloop(whileloop p)
bool persistant_statement_to_control_consistent_p(persistant_statement_to_control p)
list gen_execution_cons(execution p, list l)
intptr_t apply_persistant_statement_to_cluster(persistant_statement_to_cluster f, intptr_t k)
bool variable_consistent_p(variable p)
void control_non_recursive_free(control p)
whileloop read_whileloop(FILE *f)
void free_controlmap(controlmap p)
void write_evaluation(FILE *f, evaluation p)
bool basic_consistent_p(basic p)
control apply_persistant_statement_to_control(persistant_statement_to_control f, statement k)
bool control_defined_p(control p)
void statement_non_recursive_free(statement p)
persistant_statement_to_cluster make_persistant_statement_to_cluster(void)
storage make_storage_formal(formal _field_)
call copy_call(call p)
CALL.
bool area_defined_p(area p)
syntax copy_syntax(syntax p)
SYNTAX.
bool symbolic_defined_p(symbolic p)
void free_expression(expression p)
void extend_entity_int(entity_int f, entity k, intptr_t v)
bool cast_consistent_p(cast p)
storage read_storage(FILE *f)
void free_instruction(instruction p)
void free_storage(storage p)
void write_statement(FILE *f, statement p)
void write_subscript(FILE *f, subscript p)
sequence copy_sequence(sequence p)
SEQUENCE.
void free_dimension(dimension p)
intptr_t apply_persistant_statement_to_int(persistant_statement_to_int f, statement k)
value make_value_intrinsic(void)
bool constant_defined_p(constant p)
language make_language_c(void)
multitest check_multitest(multitest p)
string mode_tag_as_string(enum mode_utype tag)
controlmap check_controlmap(controlmap p)
value read_value(FILE *f)
void free_predicate(predicate p)
void code_non_recursive_free(code p)
bool callees_defined_p(callees p)
type make_type_unknown(void)
void update_entity_to_entity(entity_to_entity f, entity k, entity v)
synchronization read_synchronization(FILE *f)
storage copy_storage(storage p)
STORAGE.
list gen_cast_cons(cast p, list l)
unstructured copy_unstructured(unstructured p)
UNSTRUCTURED.
instruction make_instruction(enum instruction_utype tag, void *val)
bool storage_consistent_p(storage p)
void unstructured_non_recursive_free(unstructured p)
void cast_non_recursive_free(cast p)
bool bound_persistant_statement_to_int_p(persistant_statement_to_int f, statement k)
entity_int make_entity_int(void)
reference copy_reference(reference p)
REFERENCE.
void write_range(FILE *f, range p)
control apply_controlmap(controlmap f, statement k)
bool control_consistent_p(control p)
bool bound_persistant_statement_to_control_p(persistant_statement_to_control f, statement k)
syntax make_syntax_cast(cast _field_)
void basic_assign_contents(basic r, basic v)
void variable_assign_contents(variable r, variable v)
list gen_instruction_cons(instruction p, list l)
void free_execution(execution p)
bool subscript_defined_p(subscript p)
bool entity_to_entity_defined_p(entity_to_entity p)
bool dimension_defined_p(dimension p)
string basic_tag_as_string(enum basic_utype tag)
void forloop_assign_contents(forloop r, forloop v)
constant make_constant_litteral(void)
persistant_statement_to_statement copy_persistant_statement_to_statement(persistant_statement_to_statement p)
PERSISTANT_STATEMENT_TO_STATEMENT.
void type_non_recursive_free(type p)
void functional_non_recursive_free(functional p)
extension copy_extension(extension p)
EXTENSION.
void free_persistant_statement_to_int(persistant_statement_to_int p)
list gen_persistant_statement_to_cluster_cons(persistant_statement_to_cluster p, list l)
string execution_tag_as_string(enum execution_utype tag)
bool bound_entity_int_p(entity_int f, entity k)
bool range_defined_p(range p)
entity copy_entity(entity p)
ENTITY.
bool loop_consistent_p(loop p)
type make_type_varargs(type _field_)
statement check_statement(statement p)
bool sizeofexpression_consistent_p(sizeofexpression p)
void extend_entity_to_entity(entity_to_entity f, entity k, entity v)
basic check_basic(basic p)
sizeofexpression make_sizeofexpression(enum sizeofexpression_utype tag, void *val)
list gen_statement_cons(statement p, list l)
bool instruction_defined_p(instruction p)
bool ram_defined_p(ram p)
subscript read_subscript(FILE *f)
bool qualifier_defined_p(qualifier p)
bool call_defined_p(call p)
void write_symbolic(FILE *f, symbolic p)
list gen_call_cons(call p, list l)
void write_tabulated_entity(FILE *f)
constant make_constant_unknown(void)
void write_loop(FILE *f, loop p)
normalized make_normalized_complex(void)
void free_syntax(syntax p)
syntax make_syntax(enum syntax_utype tag, void *val)
void whileloop_assign_contents(whileloop r, whileloop v)
string value_tag_as_string(enum value_utype tag)
unstructured check_unstructured(unstructured p)
void entity_to_entity_non_recursive_free(entity_to_entity p)
controlmap copy_controlmap(controlmap p)
CONTROLMAP.
qualifier make_qualifier_auto(void)
dummy make_dummy_unknown(void)
synchronization make_synchronization_none(void)
extension check_extension(extension p)
list gen_persistant_statement_to_statement_cons(persistant_statement_to_statement p, list l)
bool extensions_consistent_p(extensions p)
execution copy_execution(execution p)
EXECUTION.
instruction make_instruction_unstructured(unstructured _field_)
entity_int check_entity_int(entity_int p)
void pragma_non_recursive_free(pragma p)
void evaluation_assign_contents(evaluation r, evaluation v)
type make_type_enum(list _field_)
storage make_storage_ram(ram _field_)
instruction make_instruction_multitest(multitest _field_)
area copy_area(area p)
AREA.
persistant_statement_to_cluster copy_persistant_statement_to_cluster(persistant_statement_to_cluster p)
PERSISTANT_STATEMENT_TO_CLUSTER.
sizeofexpression read_sizeofexpression(FILE *f)
mode make_mode_value(void)
pragma make_pragma(enum pragma_utype tag, void *val)
extension read_extension(FILE *f)
void write_persistant_statement_to_statement(FILE *f, persistant_statement_to_statement p)
list gen_preference_cons(preference p, list l)
void transformer_non_recursive_free(transformer p)
sequence make_sequence(list a)
void write_dummy(FILE *f, dummy p)
entity_int copy_entity_int(entity_int p)
ENTITY_INT.
list gen_sizeofexpression_cons(sizeofexpression p, list l)
persistant_statement_to_int make_persistant_statement_to_int(void)
list gen_reference_cons(reference p, list l)
void symbolic_assign_contents(symbolic r, symbolic v)
extensions copy_extensions(extensions p)
EXTENSIONS.
qualifier copy_qualifier(qualifier p)
QUALIFIER.
storage make_storage_return(entity _field_)
callees copy_callees(callees p)
CALLEES.
list gen_syntax_cons(syntax p, list l)
qualifier make_qualifier_const(void)
dummy check_dummy(dummy p)
sequence check_sequence(sequence p)
void code_assign_contents(code r, code v)
execution make_execution_parallel(void)
control make_control(statement a1, list a2, list a3)
void instruction_assign_contents(instruction r, instruction v)
bool type_consistent_p(type p)
instruction make_instruction_whileloop(whileloop _field_)
pragma make_pragma_string(string _field_)
void persistant_statement_to_cluster_assign_contents(persistant_statement_to_cluster r, persistant_statement_to_cluster v)
evaluation check_evaluation(evaluation p)
bool variable_defined_p(variable p)
callees read_callees(FILE *f)
void control_assign_contents(control r, control v)
void free_statement(statement p)
void application_non_recursive_free(application p)
multitest make_multitest(expression a1, statement a2)
constant copy_constant(constant p)
CONSTANT.
void write_extension(FILE *f, extension p)
void write_predicate(FILE *f, predicate p)
bool normalized_defined_p(normalized p)
string type_tag_as_string(enum type_utype tag)
bool dummy_defined_p(dummy p)
void write_execution(FILE *f, execution p)
execution read_execution(FILE *f)
void write_basic(FILE *f, basic p)
forloop make_forloop(expression a1, expression a2, expression a3, statement a4)
void write_control(FILE *f, control p)
list gen_unstructured_cons(unstructured p, list l)
void controlmap_assign_contents(controlmap r, controlmap v)
persistant_statement_to_control read_persistant_statement_to_control(FILE *f)
instruction make_instruction_goto(statement _field_)
evaluation make_evaluation_after(void)
qualifier make_qualifier_global(void)
syntax read_syntax(FILE *f)
transformer read_transformer(FILE *f)
bool sequence_defined_p(sequence p)
void write_persistant_statement_to_control(FILE *f, persistant_statement_to_control p)
syntax make_syntax_range(range _field_)
void write_unstructured(FILE *f, unstructured p)
void free_synchronization(synchronization p)
bool extension_consistent_p(extension p)
dimension check_dimension(dimension p)
bool entity_consistent_p(entity p)
void free_variable(variable p)
type make_type(enum type_utype tag, void *val)
constant check_constant(constant p)
transformer copy_transformer(transformer p)
TRANSFORMER.
void write_syntax(FILE *f, syntax p)
void free_sequence(sequence p)
persistant_statement_to_statement check_persistant_statement_to_statement(persistant_statement_to_statement p)
void parameter_non_recursive_free(parameter p)
void write_type(FILE *f, type p)
symbolic check_symbolic(symbolic p)
bool test_consistent_p(test p)
bool syntax_consistent_p(syntax p)
list gen_forloop_cons(forloop p, list l)
bool mode_consistent_p(mode p)
qualifier make_qualifier_asm(string _field_)
void extend_persistant_statement_to_control(persistant_statement_to_control f, statement k, control v)
pragma check_pragma(pragma p)
persistant_statement_to_cluster read_persistant_statement_to_cluster(FILE *f)
bool constant_consistent_p(constant p)
callees make_callees(list a)
bool persistant_statement_to_statement_defined_p(persistant_statement_to_statement p)
void write_constant(FILE *f, constant p)
preference make_preference(reference a1)
void expression_assign_contents(expression r, expression v)
control read_control(FILE *f)
void dimension_assign_contents(dimension r, dimension v)
void controlmap_non_recursive_free(controlmap p)
controlmap read_controlmap(FILE *f)
list gen_whileloop_cons(whileloop p, list l)
control delete_persistant_statement_to_control(persistant_statement_to_control f, statement k)
syntax make_syntax_subscript(subscript _field_)
bool functional_defined_p(functional p)
list gen_type_cons(type p, list l)
void call_assign_contents(call r, call v)
control delete_controlmap(controlmap f, statement k)
void value_assign_contents(value r, value v)
range make_range(expression a1, expression a2, expression a3)
entity delete_entity_to_entity(entity_to_entity f, entity k)
void type_assign_contents(type r, type v)
void test_assign_contents(test r, test v)
void free_persistant_statement_to_control(persistant_statement_to_control p)
list gen_synchronization_cons(synchronization p, list l)
void extend_controlmap(controlmap f, statement k, control v)
bool callees_consistent_p(callees p)
sequence read_sequence(FILE *f)
list gen_test_cons(test p, list l)
bool ram_consistent_p(ram p)
synchronization make_synchronization_barrier(void)
formal make_formal(entity a1, intptr_t a2)
functional read_functional(FILE *f)
void write_qualifier(FILE *f, qualifier p)
list gen_storage_cons(storage p, list l)
void write_callees(FILE *f, callees p)
void write_transformer(FILE *f, transformer p)
bool extension_defined_p(extension p)
void write_persistant_statement_to_int(FILE *f, persistant_statement_to_int p)
value make_value_symbolic(symbolic _field_)
bool subscript_consistent_p(subscript p)
void write_forloop(FILE *f, forloop p)
extension make_extension_unknown(void)
void write_multitest(FILE *f, multitest p)
bool application_consistent_p(application p)
void dimension_non_recursive_free(dimension p)
void free_language(language p)
entity apply_entity_to_entity(entity_to_entity f, entity k)
syntax make_syntax_reference(reference _field_)
parameter check_parameter(parameter p)
void area_non_recursive_free(area p)
string pragma_tag_as_string(enum pragma_utype tag)
void persistant_statement_to_control_assign_contents(persistant_statement_to_control r, persistant_statement_to_control v)
bool cast_defined_p(cast p)
statement read_statement(FILE *f)
dummy copy_dummy(dummy p)
DUMMY.
bool preference_defined_p(preference p)
void mode_non_recursive_free(mode p)
synchronization make_synchronization_spawn(entity _field_)
#define ENTITY_NEWGEN_DOMAIN
#define EXPRESSION_NEWGEN_DOMAIN
#define QUALIFIER_NEWGEN_DOMAIN
#define STORAGE_NEWGEN_DOMAIN
#define TYPE_NEWGEN_DOMAIN
#define STATEMENT_NEWGEN_DOMAIN
#define REFERENCE_NEWGEN_DOMAIN
int dummy
A dummy file, to prevent empty libraries from breaking builds.
#define PREFERENCE_NEWGEN_DOMAIN
void gen_free(gen_chunk *obj)
version without shared_pointers.
gen_chunk * gen_alloc(int size, int gen_check_p, int dom,...)
allocates something in newgen.
int gen_write_tabulated(FILE *fd, int domain)
GEN_WRITE_TABULATED writes the tabulated object TABLE on FD.
int gen_read_tabulated(FILE *file, int create_p)
GEN_READ_TABULATED reads FILE to update the Gen_tabulated_ table.
int gen_consistent_p(gen_chunk *obj)
GEN_CONSISTENT_P dynamically checks the type correctness of OBJ.
int gen_defined_p(gen_chunk *obj)
gen_chunk * gen_check(gen_chunk *obj, int t)
GEN_CHECK checks that the gen_chunk received OBJ is of the appropriate TYPE.
gen_chunk * gen_read(FILE *file)
GEN_READ reads any object from the FILE stream.
gen_chunk * gen_copy_tree(gen_chunk *obj)
void gen_write(FILE *fd, gen_chunk *obj)
GEN_WRITE writes the OBJect on the stream FD.
list gen_typed_cons(_int type, const void *item, const list next)
CONS a list with minimal type checking this cannot be done within the CONS macro because possible fun...
#define ENTITY_INT_NEWGEN_DOMAIN
#define CONTROL_NEWGEN_DOMAIN
#define RANGE_NEWGEN_DOMAIN
#define message_assert(msg, ex)
void * gen_find_tabulated(const char *, int)
#define HASH_GET(start, image, h, k)
#define HASH_EXTEND(start, image, h, k, v)
#define HASH_DELETE(start, image, h, k)
#define HASH_UPDATE(start, image, h, k, v)
#define HASH_BOUND_P(start, image, h, k)
int f(int off1, int off2, int n, float r[n], float a[n], float b[n])
#define LOOP_NEWGEN_DOMAIN
#define PREDICATE_NEWGEN_DOMAIN
#define CONSTANT_NEWGEN_DOMAIN
#define CALL_NEWGEN_DOMAIN
#define forloop_domain
newgen_extensions_domain_defined
#define APPLICATION_NEWGEN_DOMAIN
#define language_domain
newgen_instruction_domain_defined
#define persistant_statement_to_int_hash_table(x)
#define PERSISTANT_STATEMENT_TO_CONTROL_NEWGEN_DOMAIN
#define test_domain
newgen_entity_domain_defined
#define entity_to_entity_domain
newgen_entity_int_domain_defined
#define controlmap_hash_table(x)
@ is_sizeofexpression_expression
@ is_sizeofexpression_type
#define mode_domain
newgen_loop_domain_defined
#define expression_domain
newgen_execution_domain_defined
#define VARIABLE_NEWGEN_DOMAIN
#define INSTRUCTION_NEWGEN_DOMAIN
#define SUBSCRIPT_NEWGEN_DOMAIN
#define normalized_domain
newgen_multitest_domain_defined
#define unstructured_domain
newgen_type_domain_defined
#define CONTROLMAP_NEWGEN_DOMAIN
#define ENTITY_TO_ENTITY_NEWGEN_DOMAIN
#define formal_domain
newgen_forloop_domain_defined
#define SIZEOFEXPRESSION_NEWGEN_DOMAIN
@ is_synchronization_single
@ is_synchronization_barrier
@ is_synchronization_spawn
@ is_synchronization_critical
@ is_synchronization_none
#define parameter_domain
newgen_normalized_domain_defined
#define persistant_statement_to_statement_hash_table(x)
#define cast_domain
newgen_call_domain_defined
#define PERSISTANT_STATEMENT_TO_CLUSTER_NEWGEN_DOMAIN
#define FORMAL_NEWGEN_DOMAIN
#define loop_domain
newgen_language_domain_defined
#define BASIC_NEWGEN_DOMAIN
#define AREA_NEWGEN_DOMAIN
#define persistant_statement_to_cluster_hash_table(x)
#define FUNCTIONAL_NEWGEN_DOMAIN
#define CODE_NEWGEN_DOMAIN
#define pragma_domain
newgen_persistant_statement_to_statement_domain_defined
#define transformer_domain
newgen_test_domain_defined
#define area_domain
newgen_application_domain_defined
#define persistant_statement_to_control_domain
newgen_persistant_statement_to_cluster_domain_defined
#define DIMENSION_NEWGEN_DOMAIN
#define subscript_domain
newgen_storage_domain_defined
#define TEST_NEWGEN_DOMAIN
#define variable_domain
newgen_value_domain_defined
#define TRANSFORMER_NEWGEN_DOMAIN
#define persistant_statement_to_control_hash_table(x)
#define callees_domain
newgen_basic_domain_defined
#define statement_domain
newgen_sizeofexpression_domain_defined
#define control_domain
newgen_controlmap_domain_defined
#define MODE_NEWGEN_DOMAIN
#define persistant_statement_to_statement_domain
newgen_persistant_statement_to_int_domain_defined
#define SYNCHRONIZATION_NEWGEN_DOMAIN
#define ram_domain
newgen_qualifier_domain_defined
@ is_syntax_sizeofexpression
#define instruction_domain
newgen_functional_domain_defined
#define LANGUAGE_NEWGEN_DOMAIN
#define call_domain
newgen_callees_domain_defined
#define PRAGMA_NEWGEN_DOMAIN
#define NORMALIZED_NEWGEN_DOMAIN
#define value_domain
newgen_unstructured_domain_defined
#define storage_domain
newgen_statement_domain_defined
#define DUMMY_NEWGEN_DOMAIN
#define reference_domain
newgen_range_domain_defined
#define basic_domain
newgen_area_domain_defined
#define dummy_domain
newgen_dimension_domain_defined
@ is_instruction_unstructured
@ is_instruction_whileloop
@ is_instruction_expression
@ is_instruction_multitest
@ is_instruction_sequence
#define SYMBOLIC_NEWGEN_DOMAIN
#define sizeofexpression_domain
newgen_sequence_domain_defined
#define evaluation_domain
newgen_entity_to_entity_domain_defined
#define extension_domain
newgen_expression_domain_defined
#define PERSISTANT_STATEMENT_TO_INT_NEWGEN_DOMAIN
#define dimension_domain
newgen_control_domain_defined
#define FORLOOP_NEWGEN_DOMAIN
#define predicate_domain
newgen_pragma_domain_defined
#define type_domain
newgen_transformer_domain_defined
#define multitest_domain
newgen_mode_domain_defined
#define entity_to_entity_hash_table(x)
#define RAM_NEWGEN_DOMAIN
#define entity_int_hash_table(x)
#define CAST_NEWGEN_DOMAIN
#define UNSTRUCTURED_NEWGEN_DOMAIN
#define SYNTAX_NEWGEN_DOMAIN
#define constant_domain
newgen_code_domain_defined
#define whileloop_domain
newgen_variable_domain_defined
#define symbolic_domain
newgen_subscript_domain_defined
#define MULTITEST_NEWGEN_DOMAIN
#define EXTENSIONS_NEWGEN_DOMAIN
@ is_execution_sequential
#define qualifier_domain
newgen_preference_domain_defined
@ is_qualifier_static_dimension
#define EXECUTION_NEWGEN_DOMAIN
#define VALUE_NEWGEN_DOMAIN
#define execution_domain
newgen_evaluation_domain_defined
#define sequence_domain
newgen_reference_domain_defined
#define range_domain
newgen_ram_domain_defined
#define EVALUATION_NEWGEN_DOMAIN
#define PERSISTANT_STATEMENT_TO_STATEMENT_NEWGEN_DOMAIN
#define synchronization_domain
newgen_symbolic_domain_defined
#define WHILELOOP_NEWGEN_DOMAIN
#define extensions_domain
newgen_extension_domain_defined
#define CALLEES_NEWGEN_DOMAIN
#define code_domain
newgen_cast_domain_defined
#define persistant_statement_to_int_domain
newgen_persistant_statement_to_control_domain_defined
#define functional_domain
newgen_formal_domain_defined
#define application_domain
newgen_Psysteme_domain_defined
#define preference_domain
newgen_predicate_domain_defined
#define entity_domain
newgen_syntax_domain_defined
#define PARAMETER_NEWGEN_DOMAIN
#define SEQUENCE_NEWGEN_DOMAIN
#define entity_int_domain
newgen_dummy_domain_defined
#define EXTENSION_NEWGEN_DOMAIN
#define persistant_statement_to_cluster_domain
newgen_parameter_domain_defined
#define syntax_domain
newgen_synchronization_domain_defined
#define controlmap_domain
newgen_constant_domain_defined
int fprintf()
test sc_min : ce test s'appelle par : programme fichier1.data fichier2.data ...
le type des coefficients dans les vecteurs: Value est defini dans le package arithmetique
The structure used to build lists in NewGen.
A DOMAIN union describes the structure of a user type.
A gen_chunk is used to store every object.