object literals

include/lang2/bytecode.h

 	 */
 	L2_OP_NAMESPACE_SET,
 
+	/*
+	 * Set a namespace's name to a value.
+	 * Pop <key>
+	 * Pop <ns>
+	 * Push <ns[<key>]>
+	 */
+	L2_OP_NAMESPACE_LOOKUP,
+
 	/*
 	 * Halt execution.
 	 */

include/lang2/gen/gen.h

 void l2_gen_string(struct l2_generator *gen, char **str);
 void l2_gen_atom(struct l2_generator *gen, char **ident);
 void l2_gen_function(struct l2_generator *gen, l2_word pos);
+void l2_gen_namespace(struct l2_generator *gen);
+void l2_gen_namespace_set(struct l2_generator *gen, char **ident);
 void l2_gen_namespace_lookup(struct l2_generator *gen, char **ident);
+void l2_gen_stack_frame_lookup(struct l2_generator *gen, char **ident);
 void l2_gen_func_call(struct l2_generator *gen);
 
 #endif

include/lang2/parse/lex.h

 	L2_TOK_QUOT,
 	L2_TOK_COMMA,
 	L2_TOK_PERIOD,
+	L2_TOK_COLON,
 	L2_TOK_COLON_EQ,
 	L2_TOK_EOL,
 	L2_TOK_EOF,

lib/gen/gen.c

 	put(gen, L2_OP_ALLOC_FUNCTION);
 }
 
+void l2_gen_namespace(struct l2_generator *gen) {
+	put(gen, L2_OP_ALLOC_NAMESPACE);
+}
+
+void l2_gen_namespace_set(struct l2_generator *gen, char **ident) {
+	size_t atom_id = l2_strset_put(&gen->atomset, ident);
+	put(gen, L2_OP_PUSH);
+	put(gen, atom_id);
+	put(gen, L2_OP_NAMESPACE_SET);
+}
+
 void l2_gen_namespace_lookup(struct l2_generator *gen, char **ident) {
+	size_t atom_id = l2_strset_put(&gen->atomset, ident);
+	put(gen, L2_OP_PUSH);
+	put(gen, atom_id);
+	put(gen, L2_OP_NAMESPACE_LOOKUP);
+}
+
+void l2_gen_stack_frame_lookup(struct l2_generator *gen, char **ident) {
 	size_t atom_id = l2_strset_put(&gen->atomset, ident);
 	put(gen, L2_OP_PUSH);
 	put(gen, atom_id);

lib/parse/lex.c

 		return "comma";
 	case L2_TOK_PERIOD:
 		return "period";
+	case L2_TOK_COLON:
+		return "colon";
 	case L2_TOK_COLON_EQ:
 		return "colon-equals";
 	case L2_TOK_EOL:
 
 	case ':':
 		read_ch(lexer);
-		{
-			ch = read_ch(lexer);
-			switch (ch) {
-			case '=':
-				tok->kind = L2_TOK_COLON_EQ;
-				break;
+		ch = peek_ch(lexer);
+		switch (ch) {
+		case '=':
+			read_ch(lexer);
+			tok->kind = L2_TOK_COLON_EQ;
+			break;
 
-			default:
-				tok->kind = L2_TOK_ERROR;
-				tok->v.str = "Unexpected character";
-				break;
-			}
+		default:
+			tok->kind = L2_TOK_COLON;
+			break;
 		}
 		break;
 

lib/parse/parse.c

 static int parse_expression(
 		struct l2_lexer *lexer, struct l2_generator *gen, struct l2_parse_error *err);
 
+static int parse_object(
+		struct l2_lexer *lexer, struct l2_generator *gen, struct l2_parse_error *err) {
+	// { and EOL are already skipped
+
+	l2_gen_namespace(gen);
+	while (1) {
+		struct l2_token *tok = l2_lexer_peek(lexer, 1);
+		if (tok->kind == L2_TOK_EOF) {
+			l2_parse_err(err, tok, "In object literal: Unexpected EOF");
+			return -1;
+		} else if (tok->kind == L2_TOK_CLOSE_BRACE) {
+			l2_lexer_consume(lexer); // }
+			break;
+		}
+
+		if (tok->kind != L2_TOK_IDENT) {
+			l2_parse_err(err, tok, "In object literal: Expected identifier, got %s\n",
+					l2_token_kind_name(tok->kind));
+		}
+
+		char *key = l2_token_extract_str(tok);
+		l2_lexer_consume(lexer); // ident
+
+		tok = l2_lexer_peek(lexer, 1);
+		if (tok->kind != L2_TOK_COLON) {
+			l2_parse_err(err, tok, "In object literal: Expected colon, got %s\n",
+					l2_token_kind_name(tok->kind));
+		}
+
+		l2_lexer_consume(lexer); // :
+
+		if (parse_expression(lexer, gen, err) < 0) {
+			return -1;
+		}
+
+		l2_gen_namespace_set(gen, &key);
+		l2_gen_pop(gen);
+
+		tok = l2_lexer_peek(lexer, 1);
+		if (tok->kind != L2_TOK_EOL) {
+			l2_parse_err(err, tok, "In object literal: Expected EOL, got %s\n",
+					l2_token_kind_name(tok->kind));
+			return -1;
+		}
+
+		l2_lexer_consume(lexer); // EOL
+	}
+
+	return 0;
+}
+
 static int parse_function_impl(
 		struct l2_lexer *lexer, struct l2_generator *gen, struct l2_parse_error *err) {
-	l2_lexer_consume(lexer); // {
-	l2_lexer_skip_opt(lexer, L2_TOK_EOL);
+	// { and EOL are already skipped
 
 	int first = 1;
 	while (1) {
 	return 0;
 }
 
+static int parse_function_or_object(
+		struct l2_lexer *lexer, struct l2_generator *gen, struct l2_parse_error *err) {
+	l2_lexer_consume(lexer); // {
+	l2_lexer_skip_opt(lexer, L2_TOK_EOL);
+
+	struct l2_token *tok = l2_lexer_peek(lexer, 1);
+	struct l2_token *tok2 = l2_lexer_peek(lexer, 2);
+
+	if (tok->kind == L2_TOK_CLOSE_BRACE) {
+		l2_lexer_consume(lexer); // }
+		l2_gen_namespace(gen);
+		return 0;
+	} else if (tok->kind == L2_TOK_IDENT && tok2->kind == L2_TOK_COLON) {
+		return parse_object(lexer, gen, err);
+	} else {
+		return parse_function(lexer, gen, err);
+	}
+}
+
 static int parse_sub_expression(
 		struct l2_lexer *lexer, struct l2_generator *gen, struct l2_parse_error *err) {
 	struct l2_token *tok = l2_lexer_peek(lexer, 1);
 			l2_lexer_consume(lexer); // )
 
 			l2_gen_push(gen, 0); // Arg count
-			l2_gen_namespace_lookup(gen, &ident);
+			l2_gen_stack_frame_lookup(gen, &ident);
 			l2_gen_func_call(gen);
 			return 0;
 		}
 	} else if (tok->kind == L2_TOK_IDENT) {
 		char *ident = l2_token_extract_str(tok);
 		l2_lexer_consume(lexer); // ident
-		l2_gen_namespace_lookup(gen, &ident);
+		l2_gen_stack_frame_lookup(gen, &ident);
 		return 0;
 	} else if (tok->kind == L2_TOK_QUOT && tok2->kind == L2_TOK_IDENT) {
 		char *str = l2_token_extract_str(tok2);
 		l2_gen_string(gen, &str);
 		return 0;
 	} else if (tok->kind == L2_TOK_OPEN_BRACE) {
-		return parse_function(lexer, gen, err);
+		return parse_function_or_object(lexer, gen, err);
 	}
 
 	l2_parse_err(err, tok, "In expression: Unexpected token %s",
 		}
 
 		l2_gen_push(gen, count);
-		l2_gen_namespace_lookup(gen, &ident);
+		l2_gen_stack_frame_lookup(gen, &ident);
 		l2_gen_func_call(gen);
 		return 0;
 	}

lib/vm/vm.c

 
 	case L2_OP_NAMESPACE_SET:
 		{
-			l2_word key = vm->stack[vm->sptr - 1];
-			l2_word val = vm->stack[vm->sptr - 2];
-			l2_word ns = vm->stack[vm->sptr - 3];
+			l2_word key = vm->stack[--vm->sptr];
+			l2_word val = vm->stack[vm->sptr - 1];
+			l2_word ns = vm->stack[vm->sptr - 2];
 			l2_vm_namespace_set(&vm->values[ns], key, val);
-			vm->sptr -= 1;
+		}
+		break;
+
+	case L2_OP_NAMESPACE_LOOKUP:
+		{
+			l2_word key = vm->stack[--vm->sptr];
+			l2_word ns = vm->stack[--vm->sptr];
+			vm->stack[vm->sptr++] = l2_vm_namespace_get(vm, &vm->values[ns], key);
 		}
 		break;