authorgravatar for hello@nektro.netMeghan Denny <hello@nektro.net> 2024-06-04 12:43:20 -07:00
committergravatar for hello@nektro.netMeghan Denny <hello@nektro.net> 2024-06-04 12:43:20 -07:00
log6f4a3c90e438793bcf44a88c1404839ac01e04e9
tree309c24694c3b2ec1842ff46b8ee824b089cb3b37

intial commit

7 files changed, 516 insertions(+), 0 deletions(-)

.gitattributes created+3
...@@ -0,0 +1,3 @@
1* text=auto
2*.zig text eol=lf
3zigmod.* text eol=lf
.gitignore created+5
...@@ -0,0 +1,5 @@
1zig-*
2.zigmod
3deps.zig
4files.zig
5zigmod.lock
LICENSE created+307
...@@ -0,0 +1,307 @@
1Mozilla Public License Version 2.0
2
31. Definitions
4
5 1.1. "Contributor" means each individual or legal entity that creates,
6contributes to the creation of, or owns Covered Software.
7
8 1.2. "Contributor Version" means the combination of the Contributions of
9others (if any) used by a Contributor and that particular Contributor's
10Contribution.
11
12 1.3. "Contribution" means Covered Software of a particular Contributor.
13
14 1.4. "Covered Software" means Source Code Form to which the initial
15Contributor has attached the notice in Exhibit A, the Executable Form of such
16Source Code Form, and Modifications of such Source Code Form, in each case
17including portions thereof.
18
19 1.5. "Incompatible With Secondary Licenses" means
20
21 (a) that the initial Contributor has attached the notice described
22in Exhibit B to the Covered Software; or
23
24 (b) that the Covered Software was made available under the terms of
25version 1.1 or earlier of the License, but not also under the terms of a
26Secondary License.
27
28 1.6. "Executable Form" means any form of the work other than Source Code
29Form.
30
31 1.7. "Larger Work" means a work that combines Covered Software with other
32material, in a separate file or files, that is not Covered Software.
33
34 1.8. "License" means this document.
35
36 1.9. "Licensable" means having the right to grant, to the maximum extent
37possible, whether at the time of the initial grant or subsequently, any and
38all of the rights conveyed by this License.
39
40 1.10. "Modifications" means any of the following:
41
42 (a) any file in Source Code Form that results from an addition to,
43deletion from, or modification of the contents of Covered Software; or
44
45 (b) any new file in Source Code Form that contains any Covered
46Software.
47
48 1.11. "Patent Claims" of a Contributor means any patent claim(s),
49including without limitation, method, process, and apparatus claims, in any
50patent Licensable by such Contributor that would be infringed, but for the
51grant of the License, by the making, using, selling, offering for sale, having
52made, import, or transfer of either its Contributions or its Contributor
53Version.
54
55 1.12. "Secondary License" means either the GNU General Public License,
56Version 2.0, the GNU Lesser General Public License, Version 2.1, the GNU
57Affero General Public License, Version 3.0, or any later versions of those
58licenses.
59
60 1.13. "Source Code Form" means the form of the work preferred for making
61modifications.
62
63 1.14. "You" (or "Your") means an individual or a legal entity exercising
64rights under this License. For legal entities, "You" includes any entity that
65controls, is controlled by, or is under common control with You. For purposes
66of this definition, "control" means (a) the power, direct or indirect, to
67cause the direction or management of such entity, whether by contract or
68otherwise, or (b) ownership of more than fifty percent (50%) of the
69outstanding shares or beneficial ownership of such entity.
70
712. License Grants and Conditions
72
73 2.1. Grants
74 Each Contributor hereby grants You a world-wide, royalty-free,
75non-exclusive license:
76
77 (a) under intellectual property rights (other than patent or
78trademark) Licensable by such Contributor to use, reproduce, make available,
79modify, display, perform, distribute, and otherwise exploit its Contributions,
80either on an unmodified basis, with Modifications, or as part of a Larger
81Work; and
82
83 (b) under Patent Claims of such Contributor to make, use, sell,
84offer for sale, have made, import, and otherwise transfer either its
85Contributions or its Contributor Version.
86
87 2.2. Effective Date
88 The licenses granted in Section 2.1 with respect to any Contribution
89become effective for each Contribution on the date the Contributor first
90distributes such Contribution.
91
92 2.3. Limitations on Grant Scope
93 The licenses granted in this Section 2 are the only rights granted under
94this License. No additional rights or licenses will be implied from the
95distribution or licensing of Covered Software under this License.
96Notwithstanding Section 2.1(b) above, no patent license is granted by a
97Contributor:
98
99 (a) for any code that a Contributor has removed from Covered
100Software; or
101
102 (b) for infringements caused by: (i) Your and any other third
103party's modifications of Covered Software, or (ii) the combination of its
104Contributions with other software (except as part of its Contributor Version);
105or
106
107 (c) under Patent Claims infringed by Covered Software in the absence
108of its Contributions.
109
110 This License does not grant any rights in the trademarks, service marks,
111or logos of any Contributor (except as may be necessary to comply with the
112notice requirements in Section 3.4).
113
114 2.4. Subsequent Licenses
115 No Contributor makes additional grants as a result of Your choice to
116distribute the Covered Software under a subsequent version of this License
117(see Section 10.2) or under the terms of a Secondary License (if permitted
118under the terms of Section 3.3).
119
120 2.5. Representation
121 Each Contributor represents that the Contributor believes its
122Contributions are its original creation(s) or it has sufficient rights to
123grant the rights to its Contributions conveyed by this License.
124
125 2.6. Fair Use
126 This License is not intended to limit any rights You have under
127applicable copyright doctrines of fair use, fair dealing, or other
128equivalents.
129
130 2.7. Conditions
131 Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in
132Section 2.1.
133
1343. Responsibilities
135
136 3.1. Distribution of Source Form
137 All distribution of Covered Software in Source Code Form, including any
138Modifications that You create or to which You contribute, must be under the
139terms of this License. You must inform recipients that the Source Code Form of
140the Covered Software is governed by the terms of this License, and how they
141can obtain a copy of this License. You may not attempt to alter or restrict
142the recipients' rights in the Source Code Form.
143
144 3.2. Distribution of Executable Form
145 If You distribute Covered Software in Executable Form then:
146
147 (a) such Covered Software must also be made available in Source Code
148Form, as described in Section 3.1, and You must inform recipients of the
149Executable Form how they can obtain a copy of such Source Code Form by
150reasonable means in a timely manner, at a charge no more than the cost of
151distribution to the recipient; and
152
153 (b) You may distribute such Executable Form under the terms of this
154License, or sublicense it under different terms, provided that the license for
155the Executable Form does not attempt to limit or alter the recipients' rights
156in the Source Code Form under this License.
157
158 3.3. Distribution of a Larger Work
159 You may create and distribute a Larger Work under terms of Your choice,
160provided that You also comply with the requirements of this License for the
161Covered Software. If the Larger Work is a combination of Covered Software with
162a work governed by one or more Secondary Licenses, and the Covered Software is
163not Incompatible With Secondary Licenses, this License permits You to
164additionally distribute such Covered Software under the terms of such
165Secondary License(s), so that the recipient of the Larger Work may, at their
166option, further distribute the Covered Software under the terms of either this
167License or such Secondary License(s).
168
169 3.4. Notices
170 You may not remove or alter the substance of any license notices
171(including copyright notices, patent notices, disclaimers of warranty, or
172limitations of liability) contained within the Source Code Form of the Covered
173Software, except that You may alter any license notices to the extent required
174to remedy known factual inaccuracies.
175
176 3.5. Application of Additional Terms
177 You may choose to offer, and to charge a fee for, warranty, support,
178indemnity or liability obligations to one or more recipients of Covered
179Software. However, You may do so only on Your own behalf, and not on behalf of
180any Contributor. You must make it absolutely clear that any such warranty,
181support, indemnity, or liability obligation is offered by You alone, and You
182hereby agree to indemnify every Contributor for any liability incurred by such
183Contributor as a result of warranty, support, indemnity or liability terms You
184offer. You may include additional disclaimers of warranty and limitations of
185liability specific to any jurisdiction.
186
1874. Inability to Comply Due to Statute or Regulation
188If it is impossible for You to comply with any of the terms of this License
189with respect to some or all of the Covered Software due to statute, judicial
190order, or regulation then You must: (a) comply with the terms of this License
191to the maximum extent possible; and (b) describe the limitations and the code
192they affect. Such description must be placed in a text file included with all
193distributions of the Covered Software under this License. Except to the extent
194prohibited by statute or regulation, such description must be sufficiently
195detailed for a recipient of ordinary skill to be able to understand it.
196
1975. Termination
198
199 5.1. The rights granted under this License will terminate automatically
200if You fail to comply with any of its terms. However, if You become compliant,
201then the rights granted under this License from a particular Contributor are
202reinstated (a) provisionally, unless and until such Contributor explicitly and
203finally terminates Your grants, and (b) on an ongoing basis, if such
204Contributor fails to notify You of the non-compliance by some reasonable means
205prior to 60 days after You have come back into compliance. Moreover, Your
206grants from a particular Contributor are reinstated on an ongoing basis if
207such Contributor notifies You of the non-compliance by some reasonable means,
208this is the first time You have received notice of non-compliance with this
209License from such Contributor, and You become compliant prior to 30 days after
210Your receipt of the notice.
211
212 5.2. If You initiate litigation against any entity by asserting a patent
213infringement claim (excluding declaratory judgment actions, counter-claims,
214and cross-claims) alleging that a Contributor Version directly or indirectly
215infringes any patent, then the rights granted to You by any and all
216Contributors for the Covered Software under Section 2.1 of this License shall
217terminate.
218
219 5.3. In the event of termination under Sections 5.1 or 5.2 above, all end
220user license agreements (excluding distributors and resellers) which have been
221validly granted by You or Your distributors under this License prior to
222termination shall survive termination.
223
2246. Disclaimer of Warranty
225Covered Software is provided under this License on an "as is" basis, without
226warranty of any kind, either expressed, implied, or statutory, including,
227without limitation, warranties that the Covered Software is free of defects,
228merchantable, fit for a particular purpose or non-infringing. The entire risk
229as to the quality and performance of the Covered Software is with You. Should
230any Covered Software prove defective in any respect, You (not any Contributor)
231assume the cost of any necessary servicing, repair, or correction. This
232disclaimer of warranty constitutes an essential part of this License. No use
233of any Covered Software is authorized under this License except under this
234disclaimer.
235
2367. Limitation of Liability
237Under no circumstances and under no legal theory, whether tort (including
238negligence), contract, or otherwise, shall any Contributor, or anyone who
239distributes Covered Software as permitted above, be liable to You for any
240direct, indirect, special, incidental, or consequential damages of any
241character including, without limitation, damages for lost profits, loss of
242goodwill, work stoppage, computer failure or malfunction, or any and all other
243commercial damages or losses, even if such party shall have been informed of
244the possibility of such damages. This limitation of liability shall not apply
245to liability for death or personal injury resulting from such party's
246negligence to the extent applicable law prohibits such limitation. Some
247jurisdictions do not allow the exclusion or limitation of incidental or
248consequential damages, so this exclusion and limitation may not apply to You.
249
2508. Litigation
251Any litigation relating to this License may be brought only in the courts of a
252jurisdiction where the defendant maintains its principal place of business and
253such litigation shall be governed by laws of that jurisdiction, without
254reference to its conflict-of-law provisions. Nothing in this Section shall
255prevent a party's ability to bring cross-claims or counter-claims.
256
2579. Miscellaneous
258This License represents the complete agreement concerning the subject matter
259hereof. If any provision of this License is held to be unenforceable, such
260provision shall be reformed only to the extent necessary to make it
261enforceable. Any law or regulation which provides that the language of a
262contract shall be construed against the drafter shall not be used to construe
263this License against a Contributor.
264
26510. Versions of the License
266
267 10.1. New Versions
268 Mozilla Foundation is the license steward. Except as provided in Section
26910.3, no one other than the license steward has the right to modify or publish
270new versions of this License. Each version will be given a distinguishing
271version number.
272
273 10.2. Effect of New Versions
274 You may distribute the Covered Software under the terms of the version of
275the License under which You originally received the Covered Software, or under
276the terms of any subsequent version published by the license steward.
277
278 10.3. Modified Versions
279 If you create software not governed by this License, and you want to
280create a new license for such software, you may create and use a modified
281version of this License if you rename the license and remove any references to
282the name of the license steward (except to note that such modified license
283differs from this License).
284
285 10.4. Distributing Source Code Form that is Incompatible With Secondary
286Licenses
287 If You choose to distribute Source Code Form that is Incompatible With
288Secondary Licenses under the terms of this version of the License, the notice
289described in Exhibit B of this License must be attached.
290
291Exhibit A - Source Code Form License Notice
292
293 This Source Code Form is subject to the terms of the Mozilla Public
294License, v. 2.0. If a copy of the MPL was not distributed with this file, You
295can obtain one at http://mozilla.org/MPL/2.0/.
296
297If it is not possible or desirable to put the notice in a particular file,
298then You may include the notice in a location (such as a LICENSE file in a
299relevant directory) where a recipient would be likely to look for such a
300notice.
301
302You may add additional accurate notices of copyright ownership.
303
304Exhibit B - "Incompatible With Secondary Licenses" Notice
305
306 This Source Code Form is "Incompatible With Secondary Licenses", as
307defined by the Mozilla Public License, v. 2.0.
build.zig created+6
...@@ -0,0 +1,6 @@
1const std = @import("std");
2
3pub fn build(b: *std.Build) void {
4 const test_step = b.step("test", "Run unit tests");
5 _ = test_step;
6}
intrusive_parser.zig created+181
...@@ -0,0 +1,181 @@
1const std = @import("std");
2const string = []const u8;
3const extras = @import("extras");
4
5pub const Parser = struct {
6 any: std.io.AnyReader,
7 allocator: std.mem.Allocator,
8 temp: std.ArrayListUnmanaged(u8) = .{},
9 idx: usize = 0,
10 end: bool = false,
11 line: usize = 1,
12 col: usize = 1,
13 data: std.ArrayListUnmanaged(u8) = .{},
14 strings_map: std.StringArrayHashMapUnmanaged(usize) = .{},
15 string_tag: u8,
16
17 pub fn init(allocator: std.mem.Allocator, any: std.io.AnyReader, string_tag: u8) Parser {
18 return .{
19 .any = any,
20 .allocator = allocator,
21 .string_tag = string_tag,
22 };
23 }
24
25 pub fn deinit(p: *Parser) void {
26 p.temp.deinit(p.allocator);
27 p.data.deinit(p.allocator);
28 p.strings_map.deinit(p.allocator);
29 }
30
31 pub fn avail(p: *Parser) usize {
32 return p.temp.items.len - p.idx;
33 }
34
35 pub fn slice(p: *Parser) []const u8 {
36 return p.temp.items[p.idx..];
37 }
38
39 pub fn eat(p: *Parser, comptime test_s: string) !?void {
40 if (test_s.len == 1) {
41 _ = try p.eatByte(test_s[0]);
42 return;
43 }
44 try p.peekAmt(test_s.len) orelse return null;
45 if (std.mem.eql(u8, p.slice()[0..test_s.len], test_s)) {
46 p.idx += test_s.len;
47 return;
48 }
49 return null;
50 }
51
52 fn peekAmt(p: *Parser, amt: usize) !?void {
53 if (p.avail() >= amt) return;
54 const buf_size = std.mem.page_size;
55 const diff_amt = amt - p.avail();
56 std.debug.assert(diff_amt <= buf_size);
57 var buf: [buf_size]u8 = undefined;
58 const len = try p.any.readAll(&buf);
59 if (len == 0) p.end = true;
60 if (len == 0) return null;
61 try p.temp.appendSlice(p.allocator, buf[0..len]);
62 if (amt > len) return null;
63 }
64
65 pub fn eatByte(p: *Parser, test_c: u8) !?u8 {
66 try p.peekAmt(1) orelse return null;
67 if (p.slice()[0] == test_c) {
68 p.idx += 1;
69 return test_c;
70 }
71 return null;
72 }
73
74 pub fn eatRange(p: *Parser, comptime from: u8, comptime to: u8) !?u8 {
75 try p.peekAmt(1) orelse return null;
76 if (p.slice()[0] >= from and p.slice()[0] <= to) {
77 defer p.idx += 1;
78 return p.slice()[0];
79 }
80 return null;
81 }
82
83 pub fn eatAnyScalar(p: *Parser, test_s: string) !?u8 {
84 std.debug.assert(extras.matchesAll(u8, test_s, std.ascii.isASCII));
85 try p.peekAmt(1) orelse return null;
86 if (std.mem.indexOfScalar(u8, test_s, p.slice()[0])) |idx| {
87 p.idx += 1;
88 return test_s[idx];
89 }
90 return null;
91 }
92
93 pub fn shift(p: *Parser) !u21 {
94 try p.peekAmt(1) orelse return error.EndOfStream;
95 const len = std.unicode.utf8ByteSequenceLength(p.slice()[0]) catch return error.MalformedJson;
96 try p.peekAmt(len) orelse return error.EndOfStream;
97 defer p.idx += len;
98 return std.unicode.utf8Decode(p.slice()[0..len]) catch return error.MalformedJson;
99 }
100
101 pub fn shiftBytesN(p: *Parser, comptime n: usize) ![n]u8 {
102 try p.peekAmt(n) orelse return error.EndOfStream;
103 defer p.idx += n;
104 return p.slice()[0..n].*;
105 }
106
107 // tag(u8) + len(u32) + bytes(N)
108 pub fn addStr(p: *Parser, alloc: std.mem.Allocator, str: string) !usize {
109 const adapter: AdapterStr = .{ .p = p };
110 const res = try p.strings_map.getOrPutAdapted(alloc, str, adapter);
111 if (res.found_existing) return res.value_ptr.*;
112 errdefer p.strings_map.orderedRemoveAt(res.index);
113 const r = p.data.items.len;
114 const l = str.len;
115 try p.data.ensureUnusedCapacity(alloc, 1 + 4 + l);
116 p.data.appendAssumeCapacity(p.string_tag);
117 p.data.appendSliceAssumeCapacity(&std.mem.toBytes(@as(u32, @intCast(l))));
118 p.data.appendSliceAssumeCapacity(str);
119 res.value_ptr.* = r;
120 return r;
121 }
122
123 const AdapterStr = struct {
124 p: *const Parser,
125
126 pub fn hash(ctx: @This(), a: string) u32 {
127 _ = ctx;
128 var hasher = std.hash.Wyhash.init(0);
129 hasher.update(a);
130 return @truncate(hasher.final());
131 }
132
133 pub fn eql(ctx: @This(), a: string, _: string, b_index: usize) bool {
134 const i = ctx.p.strings_map.values()[b_index];
135 std.debug.assert(ctx.p.data.items[i] == ctx.p.string_tag);
136 const l: u32 = @bitCast(ctx.p.data.items[i..][1..][0..4].*);
137 const b = ctx.p.data.items[i..][1..][4..][0..l];
138 return std.mem.eql(u8, a, b);
139 }
140 };
141};
142
143pub fn Mixin(comptime T: type) type {
144 return struct {
145 pub fn avail(pp: *T) usize {
146 return pp.parser.avail();
147 }
148
149 pub fn slice(pp: *T) []const u8 {
150 return pp.parser.slice();
151 }
152
153 pub fn eat(pp: *T, comptime test_s: string) !?void {
154 return pp.parser.eat(test_s);
155 }
156
157 fn peekAmt(pp: *T, amt: usize) !?void {
158 return pp.parser.peekAmt(amt);
159 }
160
161 pub fn eatByte(pp: *T, test_c: u8) !?u8 {
162 return pp.parser.eatByte(test_c);
163 }
164
165 pub fn eatRange(pp: *T, comptime from: u8, comptime to: u8) !?u8 {
166 return pp.parser.eatRange(from, to);
167 }
168
169 pub fn eatAnyScalar(pp: *T, test_s: string) !?u8 {
170 return pp.parser.eatAnyScalar(test_s);
171 }
172
173 pub fn shift(pp: *T) !u21 {
174 return pp.parser.shift();
175 }
176
177 pub fn shiftBytesN(pp: *T, comptime n: usize) ![n]u8 {
178 return pp.parser.shiftBytesN(n);
179 }
180 };
181}
licenses.txt created+7
...@@ -0,0 +1,7 @@
1MPL-2.0:
2= https://spdx.org/licenses/MPL-2.0
3- This
4
5MIT:
6= https://spdx.org/licenses/MIT
7- git https://github.com/nektro/zig-extras
zigmod.yml created+7
...@@ -0,0 +1,7 @@
1id: 7l3oxw6nqqws638zsz6w1kiexnyi1yqevu0mgybmlods5i1d
2name: intrusive-parser
3main: intrusive_parser.zig
4license: MPL-2.0
5description: Core plumbing to make text or binary document parsers with Data Oriented Design
6dependencies:
7 - src: git https://github.com/nektro/zig-extras