first tiny program's types are all inferred

global.c

 	}
 
 	n->type = t;
-	return sym_add(prog->locals, n->ident, t);
+	return sym_add(prog->locals, n->ident, t, &n->sym);
 }
 
 int global_probe(prog_t *prog)

kprobe.c

 		return -ENOENT;
 
 	n->type = t;
-	return sym_add(prog->locals, n->ident, t);
+	return sym_add(prog->locals, n->ident, t, &n->sym);
 }
 
 int kprobe_probe(prog_t *prog)

node.c

 	node_t *n = __node(N_LIST);
 
 	n->list = head;
+	head->up = n;
 	return n;
 }
 
         va_start(ap, head);
         while ((next = va_arg(ap, node_t *))) {
 		insque(next, head);
+		next->up = n;
 		head = next;
         }
         va_end(ap);

node.h

 #include <stdint.h>
 #include <stdio.h>
 
+#include "sym.h"
 #include "type.h"
 
 typedef struct node node_t;
 } ntype_t;
 
 struct node {
-	node_t *next, *prev;
+	node_t *next, *prev, *up;
 
 	ntype_t ntype;
 	union {
 	};
 
 	type_t *type;
+	sym_t *sym;
 };
 
 /* debug */
 	return n ? n->next : NULL;
 }
 
+static inline node_t *node_up(node_t *n)
+{
+	return n ? n->up : NULL;
+}
+
 #endif	/* _PLY_NODE_H */

ply.c

 
 	/* neither provider identifier nor global ditto => user
 	 * variable, add it as a global symbol of unknown type. */
-	return sym_add(prog->globals, n->ident, NULL);
+	return sym_add(prog->globals, n->ident, NULL, &n->sym);
 }
 
 int infer_type_list(prog_t *prog, node_t *n)
 
 int infer_type_keyword(prog_t *prog, node_t *n)
 {
-	node_t *c;
+	node_t *dst, *src;
 
 	switch (n->keyword) {
-	case KW_SUBSCRIPT:
-		c = node_next(node_next(n));
-		assert(c);
-		n->type = c->type;
-		return 0;
 	case KW_ASSIGN:
+		dst = node_next(n);
+		src = node_next(dst);
+		assert(dst && src);
+
+		if (!src->type)
+			return 0;
+
+		if (!dst->type)
+			dst->type = src->type;
+
 		/* TODO: assignment is statement for now. do we need
 		 * c-style assignment expressions? e.g `a = b = 2;` */
 		n->type = &t_v;
 		return 0;
+
+	default:
+		return 0;
 	}
 
 	return -ENOSYS;
 
 int infer_type_sym(prog_t *prog, node_t *n)
 {
-	printf("WKZ\n");
+	node_t *parent, *key;
+
+	if (n->sym->type)
+		return 0;
+
+	parent = node_up(n);
+	key = node_next(n);
+
+	/* match `somemap[somekey]` where the type of the entire
+	 * expression and the type of the key is known, since that
+	 * means the type of the map itself is also known. */
+	if (parent && parent->type
+	    && (parent->list->ntype == N_KEYWORD)
+	    && (parent->list->keyword == KW_SUBSCRIPT)
+	    && key && key->type) {
+		n->type = type_get_map_of(key->type, parent->type);
+
+		return sym_add(n->sym->st, n->ident, n->type, NULL);
+	}
 
 	return 0;
 }

sym.c

 	return NULL;
 }
 
-int sym_add(symtab_t *st, const char *name, type_t *type)
+int sym_add(symtab_t *st, const char *name, type_t *type, sym_t **new)
 {
 	sym_t *sym;
 
 		else if (type && !type_equal(sym->type, type))
 			return -EINVAL;
 
-		return 0;
+		goto found;
 	}
 
 	st->sym = realloc(st->sym, ++st->len * sizeof(*st->sym));
 	assert(st->sym);
 
 	sym = &st->sym[st->len-1];
+	sym->st   = st;
 	sym->name = name;
 	sym->type = type;
+found:
+	if (new)
+		*new = sym;
 	return 0;
 }
 

sym.h

 
 #include "type.h"
 
+typedef struct symtab symtab_t;
+
 typedef struct sym {
+	symtab_t *st;
 	const char *name;
 	type_t *type;
 } sym_t;
 
-typedef struct symtab {
+struct symtab {
 	sym_t *sym;
 	size_t len;
-} symtab_t;
+};
 
 sym_t *sym_get(symtab_t *st, const char *name);
-int    sym_add(symtab_t *st, const char *name, type_t *type);
+int    sym_add(symtab_t *st, const char *name, type_t *type, sym_t **new);
 
 void sym_dump(sym_t *sym, FILE *fp);
 void symtab_dump(symtab_t *st, FILE *fp);

type.c

 		type_dump_func(t, fp);
 		break;
 	case T_MAP:
-		/* TODO */
-		assert(0);
+		fputs("map [", fp);
+		type_dump(t->t.map.ktype, fp);
+		fputs("] ", fp);
+		type_dump(t->t.map.vtype, fp);
 		break;
 	}
 }
 	}
 }
 
+type_t *type_get_map_of(type_t *ktype, type_t *vtype)
+{
+	type_t *t;
+	size_t i;
+
+	for (i = 0; i < types.len; i++) {
+		t = types.type[i];
+		if ((t->ttype == T_MAP)
+		    && (t->t.map.ktype == ktype)
+		    && (t->t.map.vtype == vtype))
+			return t;
+	}
+
+	t = calloc(1, sizeof(*t));
+	t->ttype = T_MAP;
+	t->t.map.vtype = vtype;
+	t->t.map.ktype = ktype;
+	type_add(t);
+	return t;
+}
+
 int type_equal(type_t *a, type_t *b)
 {
 	/* TODO */
 	case T_ARRAY:
 		t->size = t->t.array.len * t->t.array.type->size;
 		break;
-
 	case T_MAP:
-		/* TODO */
-		assert(0);
+		/* map fds are s64:s */
+		t->size = 8;
 		break;
 	}
 }

type.h

 extern type_t t_ull;
 extern type_t t_ullp;
 
+type_t *type_get_map_of(type_t *ktype, type_t *vtype);
 
 int type_equal(type_t *a, type_t *b);
 int type_add(type_t *t);