aboutsummaryrefslogtreecommitdiff
path: root/vendor/libghostty-vt/pkg/oniguruma/regex.zig
diff options
context:
space:
mode:
authorCan Celik <ogulcancelik@gmail.com>2026-04-04 19:22:04 +0300
committerCan Celik <ogulcancelik@gmail.com>2026-04-05 01:23:06 +0300
commit41dd733ca7123c9ac4bfc6c781697a660e95b052 (patch)
tree3fc91815ca139ef2e0b281bba0abda4ef15175f4 /vendor/libghostty-vt/pkg/oniguruma/regex.zig
parent55c138263e190a1e79d4b997bfb9397306c0ec1f (diff)
feat: finish ghostty pane backend integration
Diffstat (limited to 'vendor/libghostty-vt/pkg/oniguruma/regex.zig')
-rw-r--r--vendor/libghostty-vt/pkg/oniguruma/regex.zig152
1 files changed, 152 insertions, 0 deletions
diff --git a/vendor/libghostty-vt/pkg/oniguruma/regex.zig b/vendor/libghostty-vt/pkg/oniguruma/regex.zig
new file mode 100644
index 00000000..fd920e01
--- /dev/null
+++ b/vendor/libghostty-vt/pkg/oniguruma/regex.zig
@@ -0,0 +1,152 @@
+const std = @import("std");
+const c = @import("c.zig").c;
+const types = @import("types.zig");
+const errors = @import("errors.zig");
+const testEnsureInit = @import("testing.zig").ensureInit;
+const MatchParam = @import("match_param.zig").MatchParam;
+const Region = @import("region.zig").Region;
+const Error = errors.Error;
+const ErrorInfo = errors.ErrorInfo;
+const Encoding = types.Encoding;
+const Option = types.Option;
+const Syntax = types.Syntax;
+
+pub const Regex = struct {
+ value: c.OnigRegex,
+
+ pub fn init(
+ pattern: []const u8,
+ options: Option,
+ enc: *Encoding,
+ syntax: *Syntax,
+ err: ?*ErrorInfo,
+ ) !Regex {
+ var self: Regex = undefined;
+ _ = try errors.convertError(c.onig_new(
+ &self.value,
+ pattern.ptr,
+ pattern.ptr + pattern.len,
+ options.int(),
+ @ptrCast(@alignCast(enc)),
+ @ptrCast(@alignCast(syntax)),
+ @ptrCast(err),
+ ));
+ return self;
+ }
+
+ pub fn deinit(self: *Regex) void {
+ c.onig_free(self.value);
+ }
+
+ /// Search an entire string for matches. This always returns a region
+ /// which may heap allocate (C allocator).
+ pub fn search(
+ self: *Regex,
+ str: []const u8,
+ options: Option,
+ ) !Region {
+ return self.searchWithParam(str, options, null);
+ }
+
+ /// Search an entire string for matches. This always returns a region
+ /// which may heap allocate (C allocator).
+ pub fn searchWithParam(
+ self: *Regex,
+ str: []const u8,
+ options: Option,
+ match_param: ?*MatchParam,
+ ) !Region {
+ var region: Region = .{};
+
+ // As part of the searchAdvanced API call below, onig may allocate
+ // memory even if we fail to match. We need to deinit if there are
+ // any errors to free that memory.
+ errdefer region.deinit();
+
+ _ = try self.searchAdvancedWithParam(
+ str,
+ 0,
+ str.len,
+ &region,
+ options,
+ match_param,
+ );
+ return region;
+ }
+
+ /// onig_search directly
+ pub fn searchAdvanced(
+ self: *Regex,
+ str: []const u8,
+ start: usize,
+ end: usize,
+ region: *Region,
+ options: Option,
+ ) !usize {
+ return self.searchAdvancedWithParam(
+ str,
+ start,
+ end,
+ region,
+ options,
+ null,
+ );
+ }
+
+ /// onig_search_with_param directly
+ pub fn searchAdvancedWithParam(
+ self: *Regex,
+ str: []const u8,
+ start: usize,
+ end: usize,
+ region: *Region,
+ options: Option,
+ match_param: ?*MatchParam,
+ ) !usize {
+ const pos = try errors.convertError(if (match_param) |param|
+ c.onig_search_with_param(
+ self.value,
+ str.ptr,
+ str.ptr + str.len,
+ str.ptr + start,
+ str.ptr + end,
+ @ptrCast(region),
+ options.int(),
+ param.value,
+ )
+ else
+ c.onig_search(
+ self.value,
+ str.ptr,
+ str.ptr + str.len,
+ str.ptr + start,
+ str.ptr + end,
+ @ptrCast(region),
+ options.int(),
+ ));
+
+ return @intCast(pos);
+ }
+};
+
+test {
+ const testing = std.testing;
+
+ try testEnsureInit();
+ var re = try Regex.init("foo", .{}, Encoding.utf8, Syntax.default, null);
+ defer re.deinit();
+
+ var reg = try re.search("hello foo bar", .{});
+ defer reg.deinit();
+ try testing.expectEqual(@as(usize, 1), reg.count());
+
+ try testing.expectError(Error.Mismatch, re.search("hello", .{}));
+
+ var match_param = try MatchParam.init();
+ defer match_param.deinit();
+ try match_param.setRetryLimitInSearch(1000);
+
+ var reg_param = try re.searchWithParam("hello foo bar", .{}, &match_param);
+ defer reg_param.deinit();
+ try testing.expectEqual(@as(usize, 1), reg_param.count());
+}