diff options
| author | Can Celik <ogulcancelik@gmail.com> | 2026-04-04 19:22:04 +0300 |
|---|---|---|
| committer | Can Celik <ogulcancelik@gmail.com> | 2026-04-05 01:23:06 +0300 |
| commit | 41dd733ca7123c9ac4bfc6c781697a660e95b052 (patch) | |
| tree | 3fc91815ca139ef2e0b281bba0abda4ef15175f4 /vendor/libghostty-vt/pkg/oniguruma/regex.zig | |
| parent | 55c138263e190a1e79d4b997bfb9397306c0ec1f (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.zig | 152 |
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, + ®ion, + 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()); +} |
