create structs for multi-keyed maps

global.c

+#define _GNU_SOURCE 		/* asprintf */
 #include <assert.h>
 #include <errno.h>
+#include <stdlib.h>
 #include <string.h>
 
 #include "arch.h"
 {
 	struct node *map, *key;
 	struct type *ktype;
-	int nargs = node_nargs(n);
+	struct tfield *kfields, *f;
+	int i, nargs = node_nargs(n);
+	char *kname;
 
 	map = n->expr.args;
 
 	if (node_nargs(n) == 2)
 		return map->next->sym->type;
 
-	assert(0);
-	return NULL;
+	ktype = calloc(1, sizeof(*ktype));
+	assert(ktype);
+
+	kfields = calloc(nargs, sizeof(*kfields));
+	assert(kfields);
+
+	for (key = map->next, f = kfields, i = 0; key; key = key->next, f++, i++) {
+		asprintf(&f->name, "k%d", i);
+		f->type = key->sym->type;
+	}
+
+	f->type = &t_void;
+
+	asprintf(&ktype->sou.name, ":%s_key", map->ident.name);
+	ktype->ttype = T_STRUCT;
+	ktype->sou.fields = kfields;
+
+	type_add(ktype);
+	return ktype;
 }
 
 static int global_assign_type_infer_map(struct node *n)
 	map = n->expr.args;
 
 	for (key = map->next; key; key = key->next) {
-		node_print(key, stdout);printf("WKZ\n");
 		if (type_sizeof(key->sym->type) < 0)
 			return 0;
-		node_print(key, stdout);printf("WKZ\n");
 	}
 
 	map->sym->type = type_map_of(global_map_ktype(n), n->sym->type);

ply.c

 #include "node.h"
 #include "ply.h"
 #include "sym.h"
+#include "type.h"
 
 struct providers {
 	struct provider **ps;
 				    node_expr(":map",
 					      node_ident("t"),
 					      node_num(0),
+					      node_expr("pid", NULL),
 					      NULL),
 				    node_expr("time", NULL),
 				    NULL),
 	printf("\n\n-- globals\n");
 	symtab_dump(ctx->globals, stdout);
 
+	printf("\n\n-- decls\n");
+	type_dump_decls(stdout);
+
 	if (err)
 		printf("ERR: %d\n", err);
 

type.c

 
 #include "type.h"
 
+static void __sgr(FILE *fp, int sgr, const char *s)
+{
+	if (!s)
+		return;
+
+	fprintf(fp, "\e[%dm%s\e[0m", sgr, s);
+}
+
+static void __bold(FILE *fp, const char *s)
+{
+	__sgr(fp, 1, s);
+}
+
+static void __faint(FILE *fp, const char *s)
+{
+	__sgr(fp, 2, s);
+}
+
 static void type_dump_func(struct type *t, const char *name, FILE *fp)
 {
 	struct tfield *arg;
 
 	type_dump(t->func.type, NULL, fp);
-	fprintf(fp, " (*%s)(", name ? : "");
+	fprintf(fp, " (*\e[1m%s\e[0m)(", name ? : "");
 
 	if (!t->func.args) {
-		fputs("void)", fp);
+		__faint(fp, "void");
+		fputc(')', fp);
 		return;
 	}
 
 	switch (t->ttype){
 	case T_VOID:
 	print_void:
-		fprintf(fp, "\e[2mvoid\e[0m%s%s", name? " " : "", name ? : "");
+		__faint(fp, "void");
+		fputs(name ? " " : "", fp);
+		__bold(fp, name);
 		break;
 	case T_TYPEDEF:
-		fprintf(fp, "\e[2m%s\e[0m%s%s", t->tdef.name, name? " " : "", name ? : "");
+		__faint(fp, t->tdef.name);
+		fputs(name ? " " : "", fp);
+		__bold(fp, name);
 		break;
 	case T_SCALAR:
-		fprintf(fp, "\e[2m%s\e[0m%s%s", t->scalar.name, name? " " : "", name ? : "");
+		__faint(fp, t->scalar.name);
+		fputs(name ? " " : "", fp);
+		__bold(fp, name);
 		break;
 	case T_POINTER:
 		type_dump(t->ptr.type, NULL, fp);
-		fprintf(fp, " *%s", name ? : "");
+		fputs(" *", fp);
+		__bold(fp, name);
 		break;
 	case T_ARRAY:
 		type_dump(t->array.type, NULL, fp);
-		fprintf(fp, "%s%s[%zu]", name ? " " : "", name? : "", t->array.len);
+		fputs(name ? " " : "", fp);
+		__bold(fp, name);
+		fprintf(fp, "[%zu]", t->array.len);
 		break;
 	case T_STRUCT:
-		fprintf(fp, "struct %s%s%s", t->sou.name, name? " " : "", name? : "");
+		fputs("struct ", fp);
+		__faint(fp, t->sou.name);
+		__bold(fp, name);
 		break;
 	case T_FUNC:
 		type_dump_func(t, name, fp);
 		break;
 	case T_MAP:
 		type_dump(t->map.vtype, NULL, fp);
-		fprintf(fp, " %s{", name ? : "");
+		fputs(name ? " " : "", fp);		
+		__bold(fp, name);
+		fputc('{', fp);
 		type_dump(t->map.ktype, NULL, fp);
-		fputs("} ", fp);
+		fputc('}', fp);
 		break;
 	}
 }
 
 	type_dump(t, NULL, fp);
 	fputs(" {\n", fp);
-	for (f = t->sou.fields; f->type; f++) {
+	for (f = t->sou.fields; f->type->ttype != T_VOID; f++) {
 		fputc('\t', fp);
 		type_dump(f->type, NULL, fp);
 		fprintf(fp, " %s;\n", f->name);
 } all_types;
 
 #define types_foreach(_t) \
-	for ((_t) = all_types.types[0]; (_t) <= all_types.types[all_types.len]; (_t)++)
+	for ((_t) = all_types.types; (_t) < &all_types.types[all_types.len]; (_t)++)
+
+void type_dump_decls(FILE *fp)
+{
+	struct type **ti, *t;
+
+	types_foreach(ti) {
+		t = *ti;
+		if (t->ttype == T_SCALAR)
+			continue;
+
+		type_dump_decl(t, fp);
+		fputc('\n', fp);
+	}
+}
 
 int type_add(struct type *t)
 {
 
 struct type *type_array_of(struct type *type, size_t len)
 {
-	struct type *t;
+	struct type **ti, *t;
 
-	types_foreach(t) {
+	types_foreach(ti) {
+		t = *ti;
 		if ((t->ttype == T_ARRAY)
 		    && (t->array.type == type)
 		    && (t->array.len == len))
 
 struct type *type_map_of(struct type *ktype, struct type *vtype)
 {
-	struct type *t;
+	struct type **ti, *t;
 
-	types_foreach(t) {
+	types_foreach(ti) {
+		t = *ti;
 		if ((t->ttype == T_MAP)
 		    && (t->map.ktype == ktype)
 		    && (t->map.vtype == vtype))
 
 struct type *type_ptr_of(struct type *type)
 {
-	struct type *t;
+	struct type **ti, *t;
 
-	types_foreach(t) {
+	types_foreach(ti) {
+		t = *ti;
 		if ((t->ttype == T_POINTER)
 		    && (t->ptr.type == type))
 			return t;

type.h

 
 void type_dump     (struct type *t, const char *name, FILE *fp);
 void type_dump_decl(struct type *t, FILE *fp);
+void type_dump_decls(FILE *fp);
 
 ssize_t type_alignof(struct type *t);
 ssize_t type_offsetof(struct type *t, const char *field);