numbers

func.h

 	const char *name;
 	struct type *type;
 
+	int static_ret:1; 	/* return type is statically known */
+
 	int (*static_validate)(const struct func *, struct node *);
 	int (*type_infer)(const struct func *, struct node *);
 };

global.c

 #define _GNU_SOURCE 		/* asprintf */
 #include <assert.h>
 #include <errno.h>
+#include <limits.h>
 #include <stdlib.h>
 #include <string.h>
 
 static int global_map_static_validate(const struct func *func, struct node *n)
 {
 	if (n->expr.args->ntype != N_IDENT) {
-		_e("%#N: %N is not subscriptable.\n", n, n);
+		_e("%#N: trying to lookup a key in %N, which is not a map.\n",
+		   n, n);
 		return -EINVAL;
 	}
 
 static int global_assign_static_validate(const struct func *func, struct node *n)
 {
 	struct node *lval;
-	int nargs = node_nargs(n);
-
-	if (nargs != 2) {
-		_e("%#N: expected 2 arguments, %d given.\n", n, nargs);
-		return -EINVAL;
-	}
 
 	lval = n->expr.args;
 
 	if (node_is_map(lval) || (lval->ntype == N_IDENT))
 		return 0;
 
-	_e("%#N: %N is not assignable.\n", n, lval);
+	_e("%#N: can't assign a value to %N.\n", n, lval);
 	return -EINVAL;
 }
 
 	.func = { .type = &t_void, .vargs = 1 },
 };
 
-struct tfield f_assign[] = {
+struct tfield f_2args[] = {
+	{ .type = &t_void },
 	{ .type = &t_void },
+
+	{ .type = NULL }
+};
+
+struct type t_2args_func = {
+	.ttype = T_FUNC,
+
+	.func = { .type = &t_void, .args = f_2args },
+};
+
+struct tfield f_1arg[] = {
 	{ .type = &t_void },
 
 	{ .type = NULL }
 };
 
-struct type t_assign_func = {
+struct type t_1arg_func = {
 	.ttype = T_FUNC,
 
-	.func = { .type = &t_void, .args = f_assign },
+	.func = { .type = &t_void, .args = f_1arg },
 };
 
 static const struct func global_funcs[] = {
-	{ .name = ":block", .type = &t_block_func, },
+	{
+		.name = ":block",
+		.type = &t_block_func,
+		.static_ret = 1,
+	},
 
-	{ .name = "+", },
-	{ .name = "-", },
+	{
+		.name = "+",
+		.type = &t_2args_func,
+	},
+	{
+		.name = "-",
+		.type = &t_2args_func,
+	},
 	
 	{
-		.name = ":assign",
-		.type = &t_assign_func,
+		.name = "=",
+		.type = &t_2args_func,
 		.type_infer = global_assign_type_infer,
 		.static_validate = global_assign_static_validate,
 	},
 	{
-		.name = ":map",
+		.name = "{}",
 		/* .type = t_map_func, */
 		.type_infer = global_map_type_infer,
 		.static_validate = global_map_static_validate,
 	},
 
-	{ .name = "pid",  .type = &t_pid_func, },
-	{ .name = "time", .type = &t_time_func, },
+	{
+		.name = "pid",
+		.type = &t_pid_func,
+		.static_ret = 1,
+	},
+	{
+		.name = "time",
+		.type = &t_time_func,
+		.static_ret = 1,
+	},
 
-	{ .name = "quantize", },
+	{
+		.name = "quantize",
+		.type = &t_1arg_func,
+	},
 	
 	{ .name = NULL }
 };
 
+static struct type *global_num_type(struct node *n)
+{
+	if (n->num.unsignd) {
+		if (n->num.u64 <= INT_MAX)
+			return &t_int;
+		else if (n->num.u64 <= UINT_MAX)
+			return &t_uint;
+		else if (n->num.u64 <= LONG_MAX)
+			return &t_long;
+		else if (n->num.u64 <= ULONG_MAX)
+			return &t_ulong;
+		else if (n->num.u64 <= LLONG_MAX)
+			return &t_llong;
+		else if (n->num.u64 <= ULLONG_MAX)
+			return &t_ullong;
+	} else {
+		if (n->num.s64 >= INT_MIN && n->num.s64 <= INT_MAX)
+			return &t_int;
+		else if (n->num.s64 >= LONG_MIN && n->num.s64 <= LONG_MAX)
+			return &t_long;
+		else if (n->num.s64 >= LLONG_MIN && n->num.s64 <= LLONG_MAX)
+			return &t_llong;
+	}
+
+	assert(0);
+	return NULL;
+}
+
 static const struct func global_num_func = {
 	.name = ":num",
-	.type = &t_int,
 };
 
 struct type t_string_array = {
 static const struct func global_string_func = {
 	.name = ":string",
 	.type = &t_string,
+	.static_ret = 1,
 };
 
 static const struct func global_ident_func = {
 		return err;
 
 	n->sym = sym_alloc(st, n, func);
-	n->sym->type = func_return_type(func);
+
+	if (n->ntype == N_NUM)
+		n->sym->type = global_num_type(n);
+	else if (func->static_ret)
+		n->sym->type = func_return_type(func);
 	return 0;
 }
 

node.c

 #include <assert.h>
 #include <ctype.h>
+#include <errno.h>
 #include <inttypes.h>
 #include <search.h>
 #include <stdarg.h>
 		fputs(n->ident.name, fp);
 		break;
 	case N_NUM:
-		fprintf(fp, "%"PRId64, n->num.num);
+		if (n->num.unsignd)
+			fprintf(fp, "%"PRIu64, n->num.u64);
+		else
+			fprintf(fp, "%"PRId64, n->num.s64);
 		break;
 	case N_STRING:
 		fprintf(fp, "\"%s\"", n->string.data);
 	if (!n || (n->ntype != N_EXPR))
 		return 0;
 
-	return !strcmp(n->expr.func, ":map");
+	return !strcmp(n->expr.func, "{}");
 }
 
 
 	return n;
 }
 
-struct node *node_num(int64_t num)
+struct node *node_num(const char *numstr)
 {
 	struct node *n = node_new(N_NUM);
 
-	n->num.num = num;
-	return n;
+	if (numstr[0] == '-')
+		numstr++;
+	else
+		n->num.unsignd = 1;
+		
+	errno = 0;
+	n->num.u64 = strtoull(numstr, NULL, 0);
+	if (!errno) {
+		if (!n->num.unsignd)
+			n->num.s64 = -n->num.u64;
+		return n;
+	}
+
+	assert(0);
+	return NULL;
 }
 
 struct node *node_ident(char *name)

node.h

 			char *name;
 		} ident;
 		struct {
-			int64_t num;
+			union {
+				 int64_t s64;
+				uint64_t u64;
+			};
+			int unsignd:1;
 		} num;
 		struct {
 			char *data;
 
 /* constructors */
 struct node *node_string(char *data);
-struct node *node_num   (int64_t num);
+struct node *node_num   (const char *numstr);
 struct node *node_ident (char *name);
 struct node *node_append(struct node *n, struct node *arg);
 struct node *node_expr  (char *func, ...);

ply.c

 
 	/* { 
 	 * 	us = pid();
-	 * 	@t[0] = time();
-	 * 	@reads[pid()] = quantize(arg2);
+	 * 	t[0, pid()] = time();
+	 * 	reads[pid()] = quantize(arg2);
 	 * }
 	 */
 	prog->ast =
 		node_expr(":block",
-			  node_expr(":assign",
+			  node_expr("=",
 				    node_ident("us"),
-				    node_expr("pid", NULL), node_num(0),
+				    node_expr("pid", NULL),
 				    NULL),
-			  node_expr(":assign",
-				    node_expr(":map",
+			  node_expr("=",
+				    node_expr("{}",
 					      node_ident("t"),
-					      node_num(0),
+					      node_num("0"),
 					      node_expr("pid", NULL),
 					      NULL),
 				    node_expr("time", NULL),
 				    NULL),
-			  node_expr(":assign",
-				    node_expr(":map",
+			  node_expr("=",
+				    node_expr("{}",
 					      node_ident("reads"),
 					      node_expr("pid", NULL),
 					      NULL),
 
 	/* TODO: k -> kret */
 	prog->probe = "k:SyS_read2"; 
-	/* { @times[pid()] = quantize(time() - t0) } */
+	/* { times[pid()] = quantize(time() - t[0, pid()]) } */
 	prog->ast =
-		node_expr(":assign",
-			  node_expr(":map",
+		node_expr("=",
+			  node_expr("{}",
 				    node_ident("times"),
 				    node_expr("pid", NULL),
 				    NULL),
 			  node_expr("quantize",
 				    node_expr("-",
 					      node_expr("time", NULL),
-					      node_ident("t0"),
+					      node_expr("{}",
+							node_ident("t"),
+							node_num("0"),
+							node_expr("pid", NULL),
+							NULL),
 					      NULL),
 				    NULL),
 			  NULL);