39 #undef gen_context_recurse
42 #define STRUCT "_newgen_struct_"
44 #define OPTIMIZE_NEWGEN "OPTIMIZE_NEWGEN"
46 #define IS_TAB(x) ((x)==Tabulated_bp)
50 #define TYPE(bp) (bp-Domains-Number_imports-Current_start)
52 #define DomainNumberError \
53 "\"[newgen internal error]\"" \
54 "\"inconsistent domain number for %s: %%d (expecting %%d)\\n\""
90 for( size=0 ; dlp != NULL ; dlp=dlp->cdr, size++ );
91 return overhead + size;
97 fatal(
"gen_size: unknown constructed domain operator %d\n",
112 string r =
strdup(s), p=r;
113 while (*p) *p=toupper(*p), p++;
117 #define same_size(t) (sizeof(t)==sizeof(gen_chunk))
161 case SET_DT:
return "set";
172 fatal(
"[newgen_type_name] unexpected domain type %d\n", dp->
ba.
type);
188 case SET_DT:
return "set";
190 default:
fatal(
"[newgen_argument_type_name] unexpected domain type %d\n",
237 struct domainlist * dlp;
243 fprintf(header,
"extern %s make_%s(", name, name);
245 switch (domain_type) {
249 for (i=1, dlp=dom->
co.
components; dlp!=NULL; dlp=dlp->cdr, i++)
250 fprintf(header,
"%s%s%s", i==1?
"":
", ",
255 fprintf(header,
"enum %s_utype, void *", name);
270 fatal(
"[generate_make] unexpected domain type tag %d\n", domain_type);
278 switch (domain_type) {
282 for (i=1, dlp=dom->
co.
components; dlp!=NULL; dlp=dlp->cdr, i++)
288 fprintf(
code,
"enum %s_utype tag, void * val", name);
307 "gen_alloc(%d*sizeof(gen_chunk), GEN_CHECK_ALLOC, %s_domain",
309 switch (domain_type) {
313 for (i=1, dlp=dom->
co.
components; dlp!=NULL; dlp=dlp->cdr, i++)
337 string field = dlp->domain->ba.constructor;
343 "extern %s make_%s_%s(void);\n",
347 "%s make_%s_%s(void) {\n"
348 " return make_%s(is_%s_%s, UU);\n"
350 name, name, field, name, name, field);
354 fprintf(header,
"extern %s make_%s_%s(%s);\n",
355 name, name, field, typen);
358 "%s make_%s_%s(%s _field_) {\n"
359 " return make_%s(is_%s_%s, (void*)(intptr_t) _field_);\n"
361 name, name, field, typen,
377 struct domainlist * dlp;
383 "struct " STRUCT "%s_ {\n"
391 " %s _%s_index__;\n",
396 " enum %s_utype _%s_tag__;\n"
406 " %s _%s_holder_;\n",
416 bp->
name, dlp->domain->ba.constructor,
417 dlp->domain->ba.constructor,
418 dlp->domain->ba.constructand->name,
435 struct domainlist * dlp;
436 string name=bp->
name;
443 string field = dlp->domain->ba.constructor;
446 name, field, (dlp->cdr == NULL)?
"":
",");
462 struct domainlist * dlp;
463 string name=bp->
name;
468 fprintf(header,
"extern string %s_tag_as_string(enum %s_utype);\n",
470 fprintf(
code,
"string %s_tag_as_string(enum %s_utype tag) {\n"
474 string field = dlp->domain->ba.constructor;
476 " case is_%s_%s: return \"%s\";\n",
480 " default: return string_undefined;\n"
497 struct domainlist * dlp;
499 string name=bp->
name;
502 "#define %s_domain_number(x) ((x)->_type_%s)\n",
508 "#define %s_tag(x) ((x)->_%s_tag__%s)\n",
511 else in_between =
false;
514 fprintf(
out,
"#define %s_hash_table(x) ((x)->_%s_holder_)\n",
518 fprintf(
out,
"#define %s_%s(x) ((x)->_%s_holder_)\n",
531 if(
operator==
OR_OP) {
532 string field = dlp->domain->ba.constructor;
534 "#define %s_%s_p(x) (%s_tag(x)==is_%s_%s)\n",
535 name, field, name, name, field);
538 "#define %s_%s_(x) %s_%s(x) /* old hack compatible */\n"
539 "#define %s_%s(x) ((x)->",
540 name, dlp->domain->ba.constructor,
541 name, dlp->domain->ba.constructor,
542 name, dlp->domain->ba.constructor);
543 if (in_between)
fprintf(
out,
"_%s_union_.", name);
590 union domain * dom, * key, * val;
591 string name, kname, vname, Name;
607 if (kc==
'\0') kc =
'p';
609 if (vc==
'\0') vc =
'p';
613 "#define %s_key_type %s\n"
614 "#define %s_value_type %s\n"
615 "#define %s_MAP(k,v,c,f) FUNCTION_MAP(%s,%c,%c,k,v,c,f)\n"
616 "#define %s_FOREACH(k,v,f) FUNCTION_FOREACH(%s,%c,%c,k,v,f)\n"
617 "extern %s apply_%s(%s, %s);\n"
618 "extern void update_%s(%s, %s, %s);\n"
619 "extern void extend_%s(%s, %s, %s);\n"
620 "extern %s delete_%s(%s, %s);\n"
621 "extern bool bound_%s_p(%s, %s);\n",
626 vname, name, name, kname,
627 name, name, kname, vname,
628 name, name, kname, vname,
629 vname, name, name, kname,
634 "%s apply_%s(%s f, %s k) {\n"
635 " return (%s) (intptr_t)HASH_GET(%c, %c, %s_hash_table(f), k);\n"
637 "void update_%s(%s f, %s k, %s v) {\n"
638 " HASH_UPDATE(%c, %c, %s_hash_table(f), k, (intptr_t)v);\n"
640 "void extend_%s(%s f, %s k, %s v) {\n"
641 " HASH_EXTEND(%c, %c, %s_hash_table(f), k, (intptr_t)v);\n"
643 "%s delete_%s(%s f, %s k) {\n"
644 " return (%s)(intptr_t) HASH_DELETE(%c, %c, %s_hash_table(f), k);\n"
646 "bool bound_%s_p(%s f, %s k) {\n"
647 " return (intptr_t)HASH_BOUND_P(%c, %c, %s_hash_table(f), k);\n"
649 vname, name, name, kname, vname, kc, vc, name,
650 name, name, kname, vname, kc, vc, name,
651 name, name, kname, vname, kc, vc, name,
652 vname, name, name, kname, vname, kc, vc, name,
653 name, name, kname, kc, vc, name );
666 string name = bp->
name, Name =
strup(name);
667 int index =
TYPE(bp);
671 "#define %s_domain (_gen_%s_start+%d)\n",
675 "#if !defined(_newgen_%s_domain_defined_)\n"
676 "#define _newgen_%s_domain_defined_\n",
686 "#define newgen_%s(p) (p) /* old hack compatible */\n"
687 "#define %s_NEWGEN_EXTERNAL (_gen_%s_start+%d)\n"
688 "#define %s_NEWGEN_DOMAIN (%s_NEWGEN_EXTERNAL)\n"
689 "#define %s_NEWGEN_DOMAIN (%s_NEWGEN_EXTERNAL)\n",
697 "#define %s_NEWGEN_DOMAIN (%s_domain)\n"
698 "#define %s_NEWGEN_DOMAIN (%s_domain)\n"
699 "typedef struct " STRUCT "%s_ * %s;\n",
704 fprintf(
out,
"#endif /* _newgen_%s_domain_defined_ */\n\n", name);
725 "#define %s(x) ((%s)((x).p))\n"
727 "#define %s_CAST(x) %s(x)\n"
728 "#define %s_CAST(x) %s(x)\n"
729 "#define %s_(x) ((x).e)\n"
731 "#define %s_TYPE %s\n"
732 "#define %s_TYPE %s\n"
733 "#define %s_undefined ((%s)gen_chunk_undefined)\n"
734 "#define %s_undefined_p(x) ((x)==%s_undefined)\n"
744 "extern %s copy_%s(%s);\n"
745 "extern void free_%s(%s);\n"
746 "extern %s check_%s(%s);\n"
747 "extern bool %s_consistent_p(%s);\n"
748 "extern bool %s_defined_p(%s);\n"
749 "#define gen_%s_cons gen_%s_cons\n"
750 "extern list gen_%s_cons(%s, list);\n"
751 "extern void %s_assign_contents(%s, %s);\n"
752 "extern void %s_non_recursive_free(%s);\n",
775 "%s copy_%s(%s p) {\n"
776 " return (%s) gen_copy_tree((gen_chunk*) p);\n"
778 "void free_%s(%s p) {\n"
779 " gen_free((gen_chunk*) p);\n"
781 "%s check_%s(%s p) {\n"
782 " return (%s) gen_check((gen_chunk*) p, %s_domain);\n"
784 "bool %s_consistent_p(%s p) {\n"
786 " return gen_consistent_p((gen_chunk*) p);\n"
788 "bool %s_defined_p(%s p) {\n"
789 " return gen_defined_p((gen_chunk*) p);\n"
791 "list gen_%s_cons(%s p, list l) {\n"
792 " return gen_typed_cons(%s_NEWGEN_DOMAIN, p, l);\n"
794 "void %s_assign_contents(%s r, %s v) {\n"
797 " message_assert(\"defined references to domain %s\",\n"
798 " %s_defined_p(r) && %s_defined_p(v));\n"
799 " memcpy(r, v, sizeof(struct " STRUCT "%s_));\n"
801 "void %s_non_recursive_free(%s p) {\n"
802 " // should clear up contents...\n"
806 name, name, name, name,
808 name, name, name, name, name,
813 name, name, name, name, name, name,
820 "extern %s gen_find_%s(char *);\n"
821 "extern void write_tabulated_%s(FILE *);\n"
822 "extern void read_tabulated_%s(FILE *);\n",
827 "%s gen_find_%s(char* s) {\n"
828 " return (%s) gen_find_tabulated(s, %s_domain);\n"
830 "void write_tabulated_%s(FILE* f) {\n"
831 " (void) gen_write_tabulated(f, %s_domain);\n"
833 "void read_tabulated_%s(FILE* f) {\n"
834 " int domain = gen_read_tabulated(f, 0);\n"
835 " if (domain!=%s_domain) {\n"
837 " domain, %s_domain);\n"
841 name, name, name, name,
843 name, name, name, name );
848 "extern void write_%s(FILE*, %s);\n"
849 "extern %s read_%s(FILE*);\n",
853 "void write_%s(FILE* f, %s p) {\n"
854 " gen_write(f, (gen_chunk*) p);\n"
856 "%s read_%s(FILE* f) {\n"
857 " return (%s) gen_read(f);\n"
878 fatal(
"[generate_domain] unexpected constructed %d\n", dp->
co.
op);
894 fatal(
"[generate_domain] unexpected domain type %d\n", dp->
ba.
type);
909 if (r==NULL)
fatal(
"[fopen_suffix] no more memory\n");
913 if (
f==NULL)
fatal(
"[fopen_suffix] of %s failed\n", r);
920 " * THIS FILE HAS BEEN AUTOMATICALLY GENERATED BY NEWGEN.\n" \
922 " * PLEASE DO NOT MODIFY IT.\n" \
933 FILE * header, *
code;
936 fatal(
"[gencode] no file name specified (%p)\n", no_warning);
939 fatal(
"[gencode] newgen fundamental layout hypothesis broken\n");
957 "#include <stdio.h>\n"
958 "#include <stdlib.h>\n"
959 "#include <string.h>\n"
960 "#include \"genC.h\"\n"
961 "#include \"%s.h\"\n"
static bool inline_directly(union domain *dp)
static int sharp_ifopt(FILE *out)
Might be used to generate optimized versions (say macros instead of functions).
static string int_type(void)
bof...
static int sharp_endif(FILE *out)
int gen_size(int domain)
GEN_SIZE returns the size (in gen_chunks) of an object of type defined by the BP type.
#define TYPE(bp)
non user domain must be taken care from outside?
static string int_type_access_complement(void)
static string strup(string s)
returns s duplicated and case-uppered.
void gencode(string file)
generate the code necessary to manipulate every internal non-inlinable type in the Domains table.
static void generate_safe_definition(FILE *out, struct gen_binding *bp, string file)
generates a needed type declaration.
static void generate_struct_members(FILE *out, struct gen_binding *bp, int domain_type, int operator)
generate the struct for bp.
static int sharp_else(FILE *out)
static string newgen_kind_label(union domain *dp)
just to generate comprehensive comments.
static string newgen_type_name(union domain *dp)
newgen type name for holder.
static void generate_arrow(FILE *header, FILE *code, struct gen_binding *bp)
newgen function (->) specific stuff
#define DomainNumberError
static void generate_union_as_string(FILE *header, FILE *code, struct gen_binding *bp, int domain_type, int operator)
introspection function.
static string newgen_argument_type_name(union domain *dp)
C type name for generated function arguments.
static void generate_union_type_descriptor(FILE *out, struct gen_binding *bp, int domain_type, int operator)
static void generate_make(FILE *header, FILE *code, struct gen_binding *bp, int domain_type, int operator)
make is bigger, thus I put it in a separate function.
static void generate_domain(FILE *header, FILE *code, struct gen_binding *bp)
generate the needed stuff for bp.
static void generate_not_constructed(FILE *header, FILE *code, struct gen_binding *bp, int domain_type)
other types (direct * {} [])
static void generate_access_members(FILE *out, struct gen_binding *bp, int domain_type, int operator)
access to members are managed thru macros.
static string newgen_type_name_close(union domain *dp)
static void generate_constructed(FILE *header, FILE *code, struct gen_binding *bp, int operator)
constructed types: + x (and ->...)
static FILE * fopen_suffix(string prefix, string suffix)
fopen prefix + suffix.
static char newgen_access_name(union domain *dp)
what to add to the field to access a given primitive type, which was typically declared as a gen_chun...
#define GEN_HEADER
include <sys/stdtypes.h>
struct gen_binding Domains[MAX_DOMAIN]
in build.c
char * i2a(int)
I2A (Integer TO Ascii) yields a string for a given Integer.
#define IS_INLINABLE(bp)
Different kinds of BINDING structure pointers.
#define MAX_DOMAIN
MAX_DOMAIN is the maximum number of entries in the DOMAINS table.
#define same_string_p(s1, s2)
#define UNIT_TYPE_NAME
The UNIT_TYPE_NAME is the used to type expressions which only perform side-effects.
int f(int off1, int off2, int n, float r[n], float a[n], float b[n])
static const char * prefix
struct _newgen_struct_code_ * code
int fprintf()
test sc_min : ce test s'appelle par : programme fichier1.data fichier2.data ...
A DOMAIN union describes the structure of a user type.
struct gen_binding * element
struct domainlist * components
struct gen_binding * constructand
A gen_chunk is used to store every object.