void write_real_resource(FILE *f, real_resource p)
list gen_rule_cons(rule p, list l)
bool makefile_defined_p(makefile p)
bool real_resource_consistent_p(real_resource p)
owner make_owner(enum owner_utype tag, void *val)
makefile copy_makefile(makefile p)
MAKEFILE.
void rule_non_recursive_free(rule p)
makefile read_makefile(FILE *f)
virtual_resource read_virtual_resource(FILE *f)
real_resource read_real_resource(FILE *f)
owner read_owner(FILE *f)
string owner_tag_as_string(enum owner_utype tag)
bool real_resource_defined_p(real_resource p)
real_resource check_real_resource(real_resource p)
void owner_non_recursive_free(owner p)
owner make_owner_main(void)
list gen_real_resource_cons(real_resource p, list l)
owner make_owner_compilation_unit(void)
bool owner_consistent_p(owner p)
void free_real_resource(real_resource p)
owner copy_owner(owner p)
OWNER.
list gen_owner_cons(owner p, list l)
bool virtual_resource_defined_p(virtual_resource p)
void owner_assign_contents(owner r, owner v)
rule make_rule(string a1, list a2, list a3, list a4, list a5, list a6, list a7)
void write_makefile(FILE *f, makefile p)
void makefile_assign_contents(makefile r, makefile v)
makefile check_makefile(makefile p)
virtual_resource check_virtual_resource(virtual_resource p)
list gen_makefile_cons(makefile p, list l)
owner make_owner_program(void)
owner make_owner_callers(void)
void free_virtual_resource(virtual_resource p)
owner make_owner_all(void)
void makefile_non_recursive_free(makefile p)
virtual_resource make_virtual_resource(string a1, owner a2)
owner make_owner_callees(void)
bool makefile_consistent_p(makefile p)
rule copy_rule(rule p)
RULE.
void virtual_resource_assign_contents(virtual_resource r, virtual_resource v)
real_resource make_real_resource(string a1, string a2)
list gen_virtual_resource_cons(virtual_resource p, list l)
bool virtual_resource_consistent_p(virtual_resource p)
bool rule_defined_p(rule p)
bool rule_consistent_p(rule p)
virtual_resource copy_virtual_resource(virtual_resource p)
VIRTUAL_RESOURCE.
owner check_owner(owner p)
makefile make_makefile(list a1, list a2)
void rule_assign_contents(rule r, rule v)
void free_makefile(makefile p)
void real_resource_assign_contents(real_resource r, real_resource v)
void write_virtual_resource(FILE *f, virtual_resource p)
void write_rule(FILE *f, rule p)
real_resource copy_real_resource(real_resource p)
REAL_RESOURCE.
void virtual_resource_non_recursive_free(virtual_resource p)
owner make_owner_module(void)
void real_resource_non_recursive_free(real_resource p)
owner make_owner_select(void)
bool owner_defined_p(owner p)
void write_owner(FILE *f, owner p)
void gen_free(gen_chunk *obj)
version without shared_pointers.
gen_chunk * gen_alloc(int size, int gen_check_p, int dom,...)
allocates something in newgen.
int gen_consistent_p(gen_chunk *obj)
GEN_CONSISTENT_P dynamically checks the type correctness of OBJ.
int gen_defined_p(gen_chunk *obj)
gen_chunk * gen_check(gen_chunk *obj, int t)
GEN_CHECK checks that the gen_chunk received OBJ is of the appropriate TYPE.
gen_chunk * gen_read(FILE *file)
GEN_READ reads any object from the FILE stream.
gen_chunk * gen_copy_tree(gen_chunk *obj)
void gen_write(FILE *fd, gen_chunk *obj)
GEN_WRITE writes the OBJect on the stream FD.
list gen_typed_cons(_int type, const void *item, const list next)
CONS a list with minimal type checking this cannot be done within the CONS macro because possible fun...
#define RULE_NEWGEN_DOMAIN
#define virtual_resource_domain
newgen_rule_domain_defined
#define MAKEFILE_NEWGEN_DOMAIN
#define OWNER_NEWGEN_DOMAIN
@ is_owner_compilation_unit
#define REAL_RESOURCE_NEWGEN_DOMAIN
#define owner_domain
newgen_makefile_domain_defined
#define real_resource_domain
newgen_owner_domain_defined
#define VIRTUAL_RESOURCE_NEWGEN_DOMAIN
#define rule_domain
newgen_real_resource_domain_defined
#define message_assert(msg, ex)
int f(int off1, int off2, int n, float r[n], float a[n], float b[n])
The structure used to build lists in NewGen.
A gen_chunk is used to store every object.