lmfao

language.zig

@@ -299,54 +299,14 @@ fn getNull(self: *Self, index: usize) ?void {
     const entry = self.index.get(index) orelse return null;
     return entry.null;
 }
-
-fn getValue(self: *Self, allocator: std.mem.Allocator, index: usize, offset: usize) !struct { ?JsonInput, usize } {
-    const entry = self.index.get(index);
-    switch (entry) {
-        .null => return .{ .{ .null = {} }, 1 },
-        .bool => return .{ .{ .bool = entry.bool }, 1 },
-        .number => return .{ .{ .number = entry.number }, 1 },
-        .string => {
-            const str = entry.string.slice(&self.string_index);
-            return .{ .{ .string = str }, 1 };
-        },
-        .array => {
-            const res = try allocator.alloc(JsonInput, entry.array.len);
-            var idx = entry.array.start;
-            var offset_calc: usize = offset;
-
-            for (0..entry.array.len) |i| {
-                const val, const step = try self.getValue(allocator, idx, offset_calc);
-                res[i] = val.?;
-                idx += step;
-            }
-            offset_calc += entry.array.len;
-
-            return .{ .{ .array = res }, offset_calc };
-        },
-        .object => {
-            var kidx = entry.object.property_idx;
-            var vidx = entry.object.value_idx;
-            var obj: std.StringArrayHashMapUnmanaged(JsonInput) = .empty;
-            var offset_calc: usize = offset;
-
-            try obj.ensureTotalCapacity(allocator, entry.object.len);
-            for (0..entry.object.len) |_| {
-                const slice = StringIndex.slice(@enumFromInt(kidx), &self.property_index);
-                const val, const step = try self.getValue(allocator, vidx, offset_calc);
-                kidx += slice.len + 1;
-                vidx += step;
-
-                std.debug.print("putting {s} -> {d}\n", .{ slice, vidx });
-                obj.putAssumeCapacityNoClobber(slice, val.?);
-            }
-
-            offset_calc += entry.object.len;
-
-            return .{ .{ .object = obj }, offset_calc };
-        },
-    }
-}
+//
+//fn getValue(
+//    self: *Self,
+//    allocator: std.mem.Allocator,
+//    index: usize,
+//) !?JsonInput {
+//
+//}
 
 /// always returns 0 (root)
 pub fn parse(self: *Self, tokenizer: *Tokenizer) !usize {
@@ -375,6 +335,7 @@ pub fn parse(self: *Self, tokenizer: *Tokenizer) !usize {
             const scope_idx = query.get(query.len - 1);
             switch (self.index.get(scope_idx)) {
                 .object => |scope| {
+                    std.debug.print("prop: {s} \n", .{token.value.?.string});
                     const pidx = try self.addProperty(allocator, token.value.?.string);
                     self.index.set(scope_idx, .{ .object = ObjectEntry{
                         .len = scope.len + 1,
@@ -405,17 +366,19 @@ pub fn parse(self: *Self, tokenizer: *Tokenizer) !usize {
                 ptr.* = root;
                 self.index.set(root, .{ .object = ObjectEntry{
                     .len = 0,
-                    .property_idx = self.property_index.string_bytes.items.len,
+                    .property_idx = 0,
                     .value_idx = 1,
                 } });
             } else {
                 const idx_ptr = try query.addOne();
                 idx_ptr.* = try self.addEmptyObject(allocator);
-                self.index.set(idx_ptr.*, .{ .object = ObjectEntry{
-                    .len = 0,
-                    .property_idx = self.property_index.string_bytes.items.len,
-                    .value_idx = self.index.len,
-                } });
+                self.index.set(idx_ptr.*, .{
+                    .object = ObjectEntry{
+                        .len = 0,
+                        .property_idx = self.index.len, //self.property_index.string_bytes.items.len,
+                        .value_idx = self.index.len,
+                    },
+                });
             }
 
             const next = it.next() orelse return error.InvalidSyntax;
@@ -515,18 +478,45 @@ test parse {
             \\   "name": "yuzu",
             \\   "admin": true,
             \\   "address": {
-            \\      "lorem": "ipsum"
-            \\   }
+            \\      "lorem": "ipsum",
+            \\      "simple": true
+            \\   },
+            \\   "xd": true
             \\ }
         ;
         break :blk json;
     });
 
-    const root = blk: {
-        const idx = try parse(&self, &tokenizer);
-        const val, _ = try getValue(&self, allocator, idx, 0);
-        break :blk val;
-    };
+    const idx = try parse(&self, &tokenizer);
 
-    std.debug.print("root: {any}\n", .{root});
+    const keys, const values = (try getObject(&self, allocator, idx)).?;
+    for (keys, values, 0..) |k, v, i| {
+        _ = i;
+        const key = k.slice(&self.property_index);
+        const val = self.index.get(v);
+        switch (val) {
+            .object => {
+                const keys2, const values2 = (try getObject(&self, allocator, v)).?;
+                for (keys2, values2, 0..) |k2, v2, ii2| {
+                    _ = ii2;
+                    const key2 = k2.slice(&self.property_index);
+                    const val2 = self.index.get(v2);
+                    std.debug.print(
+                        \\  - "{s}": {s}
+                    , .{ key2, @tagName(val2) });
+                    if (val2 == .string) {
+                        std.debug.print(" ({s})", .{
+                            val2.string.slice(&self.string_index),
+                        });
+                    }
+                    std.debug.print("\n", .{});
+                }
+            },
+            else => {},
+        }
+        std.debug.print(
+            \\"{s}": {s}
+        , .{ key, @tagName(val) });
+        std.debug.print("\n", .{});
+    }
 }