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 | |
| parent | 55c138263e190a1e79d4b997bfb9397306c0ec1f (diff) | |
feat: finish ghostty pane backend integration
Diffstat (limited to 'vendor/libghostty-vt/pkg/oniguruma')
| -rw-r--r-- | vendor/libghostty-vt/pkg/oniguruma/build.zig | 171 | ||||
| -rw-r--r-- | vendor/libghostty-vt/pkg/oniguruma/build.zig.zon | 16 | ||||
| -rw-r--r-- | vendor/libghostty-vt/pkg/oniguruma/c.zig | 3 | ||||
| -rw-r--r-- | vendor/libghostty-vt/pkg/oniguruma/errors.zig | 201 | ||||
| -rw-r--r-- | vendor/libghostty-vt/pkg/oniguruma/init.zig | 16 | ||||
| -rw-r--r-- | vendor/libghostty-vt/pkg/oniguruma/main.zig | 21 | ||||
| -rw-r--r-- | vendor/libghostty-vt/pkg/oniguruma/match_param.zig | 23 | ||||
| -rw-r--r-- | vendor/libghostty-vt/pkg/oniguruma/regex.zig | 152 | ||||
| -rw-r--r-- | vendor/libghostty-vt/pkg/oniguruma/region.zig | 51 | ||||
| -rw-r--r-- | vendor/libghostty-vt/pkg/oniguruma/testing.zig | 15 | ||||
| -rw-r--r-- | vendor/libghostty-vt/pkg/oniguruma/types.zig | 96 |
11 files changed, 765 insertions, 0 deletions
diff --git a/vendor/libghostty-vt/pkg/oniguruma/build.zig b/vendor/libghostty-vt/pkg/oniguruma/build.zig new file mode 100644 index 00000000..efc013b4 --- /dev/null +++ b/vendor/libghostty-vt/pkg/oniguruma/build.zig @@ -0,0 +1,171 @@ +const std = @import("std"); +const NativeTargetInfo = std.zig.system.NativeTargetInfo; + +pub fn build(b: *std.Build) !void { + const target = b.standardTargetOptions(.{}); + const optimize = b.standardOptimizeOption(.{}); + + const module = b.addModule("oniguruma", .{ + .root_source_file = b.path("main.zig"), + .target = target, + .optimize = optimize, + }); + + // For dynamic linking, we prefer dynamic linking and to search by + // mode first. Mode first will search all paths for a dynamic library + // before falling back to static. + const dynamic_link_opts: std.Build.Module.LinkSystemLibraryOptions = .{ + .preferred_link_mode = .dynamic, + .search_strategy = .mode_first, + }; + + var test_exe: ?*std.Build.Step.Compile = null; + if (target.query.isNative()) { + test_exe = b.addTest(.{ + .name = "test", + .root_module = b.createModule(.{ + .root_source_file = b.path("main.zig"), + .target = target, + .optimize = optimize, + }), + }); + const tests_run = b.addRunArtifact(test_exe.?); + const test_step = b.step("test", "Run tests"); + test_step.dependOn(&tests_run.step); + + // Uncomment this if we're debugging tests + b.installArtifact(test_exe.?); + } + + if (b.systemIntegrationOption("oniguruma", .{})) { + module.linkSystemLibrary("oniguruma", dynamic_link_opts); + + if (test_exe) |exe| { + exe.linkSystemLibrary2("oniguruma", dynamic_link_opts); + } + } else { + const lib = try buildLib(b, module, .{ + .target = target, + .optimize = optimize, + }); + + if (test_exe) |exe| { + exe.linkLibrary(lib); + } + } +} + +fn buildLib(b: *std.Build, module: *std.Build.Module, options: anytype) !*std.Build.Step.Compile { + const target = options.target; + const optimize = options.optimize; + + const lib = b.addLibrary(.{ + .name = "oniguruma", + .root_module = b.createModule(.{ + .target = target, + .optimize = optimize, + }), + .linkage = .static, + }); + const t = target.result; + const is_windows = t.os.tag == .windows; + lib.linkLibC(); + + if (target.result.os.tag.isDarwin()) { + const apple_sdk = @import("apple_sdk"); + try apple_sdk.addPaths(b, lib); + } + + if (b.lazyDependency("oniguruma", .{})) |upstream| { + lib.addIncludePath(upstream.path("src")); + module.addIncludePath(upstream.path("src")); + + lib.addConfigHeader(b.addConfigHeader(.{ + .style = .{ .cmake = upstream.path("src/config.h.cmake.in") }, + }, .{ + .PACKAGE = "oniguruma", + .PACKAGE_VERSION = "6.9.9", + .VERSION = "6.9.9", + .HAVE_ALLOCA = true, + .HAVE_ALLOCA_H = !is_windows, + .USE_CRNL_AS_LINE_TERMINATOR = is_windows, + .HAVE_STDINT_H = true, + .HAVE_SYS_TIMES_H = !is_windows, + .HAVE_SYS_TIME_H = !is_windows, + .HAVE_SYS_TYPES_H = true, + .HAVE_UNISTD_H = !is_windows, + .HAVE_INTTYPES_H = true, + .SIZEOF_INT = t.cTypeByteSize(.int), + .SIZEOF_LONG = t.cTypeByteSize(.long), + .SIZEOF_LONG_LONG = t.cTypeByteSize(.longlong), + .SIZEOF_VOIDP = t.ptrBitWidth() / t.cTypeBitSize(.char), + })); + + var flags: std.ArrayList([]const u8) = .empty; + defer flags.deinit(b.allocator); + lib.addCSourceFiles(.{ + .root = upstream.path(""), + .flags = flags.items, + .files = &.{ + "src/regerror.c", + "src/regparse.c", + "src/regext.c", + "src/regcomp.c", + "src/regexec.c", + "src/reggnu.c", + "src/regenc.c", + "src/regsyntax.c", + "src/regtrav.c", + "src/regversion.c", + "src/st.c", + "src/onig_init.c", + "src/unicode.c", + "src/ascii.c", + "src/utf8.c", + "src/utf16_be.c", + "src/utf16_le.c", + "src/utf32_be.c", + "src/utf32_le.c", + "src/euc_jp.c", + "src/sjis.c", + "src/iso8859_1.c", + "src/iso8859_2.c", + "src/iso8859_3.c", + "src/iso8859_4.c", + "src/iso8859_5.c", + "src/iso8859_6.c", + "src/iso8859_7.c", + "src/iso8859_8.c", + "src/iso8859_9.c", + "src/iso8859_10.c", + "src/iso8859_11.c", + "src/iso8859_13.c", + "src/iso8859_14.c", + "src/iso8859_15.c", + "src/iso8859_16.c", + "src/euc_tw.c", + "src/euc_kr.c", + "src/big5.c", + "src/gb18030.c", + "src/koi8_r.c", + "src/cp1251.c", + "src/euc_jp_prop.c", + "src/sjis_prop.c", + "src/unicode_unfold_key.c", + "src/unicode_fold1_key.c", + "src/unicode_fold2_key.c", + "src/unicode_fold3_key.c", + }, + }); + + lib.installHeadersDirectory( + upstream.path("src"), + "", + .{ .include_extensions = &.{".h"} }, + ); + } + + b.installArtifact(lib); + + return lib; +} diff --git a/vendor/libghostty-vt/pkg/oniguruma/build.zig.zon b/vendor/libghostty-vt/pkg/oniguruma/build.zig.zon new file mode 100644 index 00000000..10ec786c --- /dev/null +++ b/vendor/libghostty-vt/pkg/oniguruma/build.zig.zon @@ -0,0 +1,16 @@ +.{ + .name = .oniguruma, + .version = "6.9.9", + .fingerprint = 0xe3b537b18c5785a8, + .paths = .{""}, + .dependencies = .{ + // kkos/oniguruma + .oniguruma = .{ + .url = "https://deps.files.ghostty.org/oniguruma-1220c15e72eadd0d9085a8af134904d9a0f5dfcbed5f606ad60edc60ebeccd9706bb.tar.gz", + .hash = "N-V-__8AAHjwMQDBXnLq3Q2QhaivE0kE2aD138vtX2Bq1g7c", + .lazy = true, + }, + + .apple_sdk = .{ .path = "../apple-sdk" }, + }, +} diff --git a/vendor/libghostty-vt/pkg/oniguruma/c.zig b/vendor/libghostty-vt/pkg/oniguruma/c.zig new file mode 100644 index 00000000..73732f90 --- /dev/null +++ b/vendor/libghostty-vt/pkg/oniguruma/c.zig @@ -0,0 +1,3 @@ +pub const c = @cImport({ + @cInclude("oniguruma.h"); +}); diff --git a/vendor/libghostty-vt/pkg/oniguruma/errors.zig b/vendor/libghostty-vt/pkg/oniguruma/errors.zig new file mode 100644 index 00000000..d63a481b --- /dev/null +++ b/vendor/libghostty-vt/pkg/oniguruma/errors.zig @@ -0,0 +1,201 @@ +const c = @import("c.zig").c; +const Encoding = @import("types.zig").Encoding; + +/// Maximum error message length. +pub const MAX_ERROR_LEN = c.ONIG_MAX_ERROR_MESSAGE_LEN; + +/// Convert an Oniguruma error to an error. +pub fn convertError(code: c_int) !c_int { + if (code >= 0) return code; + inline for (error_code_map) |m| { + if (m[1] == code) return m[0]; + } + + return Error.Unknown; +} + +/// Convert an error code to a string. buf must be at least +/// MAX_ERROR_LEN bytes long. +pub fn errorString(buf: []u8, code: c_int) ![]u8 { + const len = c.onig_error_code_to_str(buf.ptr, code); + return buf[0..@intCast(len)]; +} + +/// The Oniguruma error info type, matching the C type exactly. +pub const ErrorInfo = extern struct { + encoding: *Encoding, + par: [*]u8, + par_end: [*]u8, +}; + +/// All possible Oniguruma errors. +pub const Error = error{ + Mismatch, + NoSupportConfig, + Abort, + Memory, + TypeBug, + ParserBug, + StackBug, + UndefinedBytecode, + UnexpectedBytecode, + MatchStackLimitOver, + ParseDepthLimitOver, + RetryLimitInMatchOver, + RetryLimitInSearchOver, + SubexpCallLimitInSearchOver, + DefaultEncodingIsNotSet, + SpecifiedEncodingCantConvertToWideChar, + FailToInitialize, + InvalidArgument, + EndPatternAtLeftBrace, + EndPatternAtLeftBracket, + EmptyCharClass, + PrematureEndOfCharClass, + EndPatternAtEscape, + EndPatternAtMeta, + EndPatternAtControl, + MetaCodeSyntax, + ControlCodeSyntax, + CharClassValueAtEndOfRange, + CharClassValueAtStartOfRange, + UnmatchedRangeSpecifierInCharClass, + TargetOfRepeatOperatorNotSpecified, + TargetOfRepeatOperatorInvalid, + NestedRepeatOperator, + UnmatchedCloseParenthesis, + EndPatternWithUnmatchedParenthesis, + EndPatternInGroup, + UndefinedGroupOption, + InvalidGroupOption, + InvalidPosixBracketType, + InvalidLookBehindPattern, + InvalidRepeatRangePattern, + TooBigNumber, + TooBigNumberForRepeatRange, + UpperSmallerThanLowerInRepeatRange, + EmptyRangeInCharClass, + MismatchCodeLengthInClassRange, + TooManyMultiByteRanges, + TooShortMultiByteString, + TooBigBackrefNumber, + InvalidBackref, + NumberedBackrefOrCallNotAllowed, + TooManyCaptures, + TooLongWideCharValue, + UndefinedOperator, + EmptyGroupName, + InvalidGroupName, + InvalidCharInGroupName, + UndefinedNameReference, + UndefinedGroupReference, + MultiplexDefinedName, + MultiplexDefinitionNameCall, + NeverEndingRecursion, + GroupNumberOverForCaptureHistory, + InvalidCharPropertyName, + InvalidIfElseSyntax, + InvalidAbsentGroupPattern, + InvalidAbsentGroupGeneratorPattern, + InvalidCalloutPattern, + InvalidCalloutName, + UndefinedCalloutName, + InvalidCalloutBody, + InvalidCalloutTagName, + InvalidCalloutArg, + InvalidCodePointValue, + InvalidWideCharValue, + TooBigWideCharValue, + NotSupportedEncodingCombination, + InvalidCombinationOfOptions, + TooManyUserDefinedObjects, + TooLongPropertyName, + VeryInefficientPattern, + LibraryIsNotInitialized, + Unknown, +}; + +const error_code_map: []const struct { Error, c_int } = &.{ + .{ Error.Mismatch, c.ONIG_MISMATCH }, + .{ Error.NoSupportConfig, c.ONIG_NO_SUPPORT_CONFIG }, + .{ Error.Abort, c.ONIG_ABORT }, + .{ Error.Memory, c.ONIGERR_MEMORY }, + .{ Error.TypeBug, c.ONIGERR_TYPE_BUG }, + .{ Error.ParserBug, c.ONIGERR_PARSER_BUG }, + .{ Error.StackBug, c.ONIGERR_STACK_BUG }, + .{ Error.UndefinedBytecode, c.ONIGERR_UNDEFINED_BYTECODE }, + .{ Error.UnexpectedBytecode, c.ONIGERR_UNEXPECTED_BYTECODE }, + .{ Error.MatchStackLimitOver, c.ONIGERR_MATCH_STACK_LIMIT_OVER }, + .{ Error.ParseDepthLimitOver, c.ONIGERR_PARSE_DEPTH_LIMIT_OVER }, + .{ Error.RetryLimitInMatchOver, c.ONIGERR_RETRY_LIMIT_IN_MATCH_OVER }, + .{ Error.RetryLimitInSearchOver, c.ONIGERR_RETRY_LIMIT_IN_SEARCH_OVER }, + .{ Error.SubexpCallLimitInSearchOver, c.ONIGERR_SUBEXP_CALL_LIMIT_IN_SEARCH_OVER }, + .{ Error.DefaultEncodingIsNotSet, c.ONIGERR_DEFAULT_ENCODING_IS_NOT_SET }, + .{ Error.SpecifiedEncodingCantConvertToWideChar, c.ONIGERR_SPECIFIED_ENCODING_CANT_CONVERT_TO_WIDE_CHAR }, + .{ Error.FailToInitialize, c.ONIGERR_FAIL_TO_INITIALIZE }, + .{ Error.InvalidArgument, c.ONIGERR_INVALID_ARGUMENT }, + .{ Error.EndPatternAtLeftBrace, c.ONIGERR_END_PATTERN_AT_LEFT_BRACE }, + .{ Error.EndPatternAtLeftBracket, c.ONIGERR_END_PATTERN_AT_LEFT_BRACKET }, + .{ Error.EmptyCharClass, c.ONIGERR_EMPTY_CHAR_CLASS }, + .{ Error.PrematureEndOfCharClass, c.ONIGERR_PREMATURE_END_OF_CHAR_CLASS }, + .{ Error.EndPatternAtEscape, c.ONIGERR_END_PATTERN_AT_ESCAPE }, + .{ Error.EndPatternAtMeta, c.ONIGERR_END_PATTERN_AT_META }, + .{ Error.EndPatternAtControl, c.ONIGERR_END_PATTERN_AT_CONTROL }, + .{ Error.MetaCodeSyntax, c.ONIGERR_META_CODE_SYNTAX }, + .{ Error.ControlCodeSyntax, c.ONIGERR_CONTROL_CODE_SYNTAX }, + .{ Error.CharClassValueAtEndOfRange, c.ONIGERR_CHAR_CLASS_VALUE_AT_END_OF_RANGE }, + .{ Error.CharClassValueAtStartOfRange, c.ONIGERR_CHAR_CLASS_VALUE_AT_START_OF_RANGE }, + .{ Error.UnmatchedRangeSpecifierInCharClass, c.ONIGERR_UNMATCHED_RANGE_SPECIFIER_IN_CHAR_CLASS }, + .{ Error.TargetOfRepeatOperatorNotSpecified, c.ONIGERR_TARGET_OF_REPEAT_OPERATOR_NOT_SPECIFIED }, + .{ Error.TargetOfRepeatOperatorInvalid, c.ONIGERR_TARGET_OF_REPEAT_OPERATOR_INVALID }, + .{ Error.NestedRepeatOperator, c.ONIGERR_NESTED_REPEAT_OPERATOR }, + .{ Error.UnmatchedCloseParenthesis, c.ONIGERR_UNMATCHED_CLOSE_PARENTHESIS }, + .{ Error.EndPatternWithUnmatchedParenthesis, c.ONIGERR_END_PATTERN_WITH_UNMATCHED_PARENTHESIS }, + .{ Error.EndPatternInGroup, c.ONIGERR_END_PATTERN_IN_GROUP }, + .{ Error.UndefinedGroupOption, c.ONIGERR_UNDEFINED_GROUP_OPTION }, + .{ Error.InvalidGroupOption, c.ONIGERR_INVALID_GROUP_OPTION }, + .{ Error.InvalidPosixBracketType, c.ONIGERR_INVALID_POSIX_BRACKET_TYPE }, + .{ Error.InvalidLookBehindPattern, c.ONIGERR_INVALID_LOOK_BEHIND_PATTERN }, + .{ Error.InvalidRepeatRangePattern, c.ONIGERR_INVALID_REPEAT_RANGE_PATTERN }, + .{ Error.TooBigNumber, c.ONIGERR_TOO_BIG_NUMBER }, + .{ Error.TooBigNumberForRepeatRange, c.ONIGERR_TOO_BIG_NUMBER_FOR_REPEAT_RANGE }, + .{ Error.UpperSmallerThanLowerInRepeatRange, c.ONIGERR_UPPER_SMALLER_THAN_LOWER_IN_REPEAT_RANGE }, + .{ Error.EmptyRangeInCharClass, c.ONIGERR_EMPTY_RANGE_IN_CHAR_CLASS }, + .{ Error.MismatchCodeLengthInClassRange, c.ONIGERR_MISMATCH_CODE_LENGTH_IN_CLASS_RANGE }, + .{ Error.TooManyMultiByteRanges, c.ONIGERR_TOO_MANY_MULTI_BYTE_RANGES }, + .{ Error.TooShortMultiByteString, c.ONIGERR_TOO_SHORT_MULTI_BYTE_STRING }, + .{ Error.TooBigBackrefNumber, c.ONIGERR_TOO_BIG_BACKREF_NUMBER }, + .{ Error.InvalidBackref, c.ONIGERR_INVALID_BACKREF }, + .{ Error.NumberedBackrefOrCallNotAllowed, c.ONIGERR_NUMBERED_BACKREF_OR_CALL_NOT_ALLOWED }, + .{ Error.TooManyCaptures, c.ONIGERR_TOO_MANY_CAPTURES }, + .{ Error.TooLongWideCharValue, c.ONIGERR_TOO_LONG_WIDE_CHAR_VALUE }, + .{ Error.UndefinedOperator, c.ONIGERR_UNDEFINED_OPERATOR }, + .{ Error.EmptyGroupName, c.ONIGERR_EMPTY_GROUP_NAME }, + .{ Error.InvalidGroupName, c.ONIGERR_INVALID_GROUP_NAME }, + .{ Error.InvalidCharInGroupName, c.ONIGERR_INVALID_CHAR_IN_GROUP_NAME }, + .{ Error.UndefinedNameReference, c.ONIGERR_UNDEFINED_NAME_REFERENCE }, + .{ Error.UndefinedGroupReference, c.ONIGERR_UNDEFINED_GROUP_REFERENCE }, + .{ Error.MultiplexDefinedName, c.ONIGERR_MULTIPLEX_DEFINED_NAME }, + .{ Error.MultiplexDefinitionNameCall, c.ONIGERR_MULTIPLEX_DEFINITION_NAME_CALL }, + .{ Error.NeverEndingRecursion, c.ONIGERR_NEVER_ENDING_RECURSION }, + .{ Error.GroupNumberOverForCaptureHistory, c.ONIGERR_GROUP_NUMBER_OVER_FOR_CAPTURE_HISTORY }, + .{ Error.InvalidCharPropertyName, c.ONIGERR_INVALID_CHAR_PROPERTY_NAME }, + .{ Error.InvalidIfElseSyntax, c.ONIGERR_INVALID_IF_ELSE_SYNTAX }, + .{ Error.InvalidAbsentGroupPattern, c.ONIGERR_INVALID_ABSENT_GROUP_PATTERN }, + .{ Error.InvalidAbsentGroupGeneratorPattern, c.ONIGERR_INVALID_ABSENT_GROUP_GENERATOR_PATTERN }, + .{ Error.InvalidCalloutPattern, c.ONIGERR_INVALID_CALLOUT_PATTERN }, + .{ Error.InvalidCalloutName, c.ONIGERR_INVALID_CALLOUT_NAME }, + .{ Error.UndefinedCalloutName, c.ONIGERR_UNDEFINED_CALLOUT_NAME }, + .{ Error.InvalidCalloutBody, c.ONIGERR_INVALID_CALLOUT_BODY }, + .{ Error.InvalidCalloutTagName, c.ONIGERR_INVALID_CALLOUT_TAG_NAME }, + .{ Error.InvalidCalloutArg, c.ONIGERR_INVALID_CALLOUT_ARG }, + .{ Error.InvalidCodePointValue, c.ONIGERR_INVALID_CODE_POINT_VALUE }, + .{ Error.InvalidWideCharValue, c.ONIGERR_INVALID_WIDE_CHAR_VALUE }, + .{ Error.TooBigWideCharValue, c.ONIGERR_TOO_BIG_WIDE_CHAR_VALUE }, + .{ Error.NotSupportedEncodingCombination, c.ONIGERR_NOT_SUPPORTED_ENCODING_COMBINATION }, + .{ Error.InvalidCombinationOfOptions, c.ONIGERR_INVALID_COMBINATION_OF_OPTIONS }, + .{ Error.TooManyUserDefinedObjects, c.ONIGERR_TOO_MANY_USER_DEFINED_OBJECTS }, + .{ Error.TooLongPropertyName, c.ONIGERR_TOO_LONG_PROPERTY_NAME }, + .{ Error.VeryInefficientPattern, c.ONIGERR_VERY_INEFFICIENT_PATTERN }, + .{ Error.LibraryIsNotInitialized, c.ONIGERR_LIBRARY_IS_NOT_INITIALIZED }, +}; diff --git a/vendor/libghostty-vt/pkg/oniguruma/init.zig b/vendor/libghostty-vt/pkg/oniguruma/init.zig new file mode 100644 index 00000000..ea64724c --- /dev/null +++ b/vendor/libghostty-vt/pkg/oniguruma/init.zig @@ -0,0 +1,16 @@ +const c = @import("c.zig").c; +const Encoding = @import("types.zig").Encoding; +const errors = @import("errors.zig"); + +/// Call once per process to initialize Oniguruma. This should be given +/// the encodings that the program will use. +pub fn init(encs: []const *Encoding) !void { + _ = try errors.convertError(c.onig_initialize( + @ptrCast(@alignCast(@constCast(encs.ptr))), + @intCast(encs.len), + )); +} + +pub fn deinit() void { + _ = c.onig_end(); +} diff --git a/vendor/libghostty-vt/pkg/oniguruma/main.zig b/vendor/libghostty-vt/pkg/oniguruma/main.zig new file mode 100644 index 00000000..2541cc35 --- /dev/null +++ b/vendor/libghostty-vt/pkg/oniguruma/main.zig @@ -0,0 +1,21 @@ +const initpkg = @import("init.zig"); +const match_param = @import("match_param.zig"); +const regex = @import("regex.zig"); +const region = @import("region.zig"); +const types = @import("types.zig"); + +pub const c = @import("c.zig"); +pub const testing = @import("testing.zig"); +pub const errors = @import("errors.zig"); + +pub const init = initpkg.init; +pub const deinit = initpkg.deinit; +pub const Encoding = types.Encoding; +pub const MatchParam = match_param.MatchParam; +pub const Regex = regex.Regex; +pub const Region = region.Region; +pub const Syntax = types.Syntax; + +test { + @import("std").testing.refAllDecls(@This()); +} diff --git a/vendor/libghostty-vt/pkg/oniguruma/match_param.zig b/vendor/libghostty-vt/pkg/oniguruma/match_param.zig new file mode 100644 index 00000000..b28258ff --- /dev/null +++ b/vendor/libghostty-vt/pkg/oniguruma/match_param.zig @@ -0,0 +1,23 @@ +const c = @import("c.zig").c; +const errors = @import("errors.zig"); +const Error = errors.Error; + +pub const MatchParam = struct { + value: *c.OnigMatchParam, + + pub fn init() !MatchParam { + const value = c.onig_new_match_param() orelse return Error.Memory; + return .{ .value = value }; + } + + pub fn deinit(self: *MatchParam) void { + c.onig_free_match_param(self.value); + } + + pub fn setRetryLimitInSearch(self: *MatchParam, limit: usize) !void { + _ = try errors.convertError(c.onig_set_retry_limit_in_search_of_match_param( + self.value, + @intCast(limit), + )); + } +}; 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()); +} diff --git a/vendor/libghostty-vt/pkg/oniguruma/region.zig b/vendor/libghostty-vt/pkg/oniguruma/region.zig new file mode 100644 index 00000000..8c5c7a52 --- /dev/null +++ b/vendor/libghostty-vt/pkg/oniguruma/region.zig @@ -0,0 +1,51 @@ +const std = @import("std"); +const c = @import("c.zig").c; + +pub const Region = extern struct { + allocated: c_int = 0, + num_regs: c_int = 0, + beg: ?[*]c_int = null, + end: ?[*]c_int = null, + history_root: ?*c.OnigCaptureTreeNode = null, // TODO: convert to Zig + + pub fn deinit(self: *Region) void { + // We never free ourself because allocation of Region in the Zig + // bindings is handled by the Zig program. + c.onig_region_free(@ptrCast(self), 0); + } + + /// Count the number of matches + pub fn count(self: *const Region) usize { + return @intCast(self.num_regs); + } + + /// Iterate over the matched ranges. + pub fn iterator(self: *const Region) Iterator { + return .{ .region = self }; + } + + pub fn starts(self: *const Region) []const c_int { + if (self.num_regs == 0) return &.{}; + return self.beg.?[0..@intCast(self.num_regs)]; + } + + pub fn ends(self: *const Region) []const c_int { + if (self.num_regs == 0) return &.{}; + return self.end.?[0..@intCast(self.num_regs)]; + } + + pub const Iterator = struct { + region: *const Region, + i: usize = 0, + + /// The next range + pub fn next(self: *Iterator) ?[2]usize { + if (self.i >= self.region.num_regs) return null; + defer self.i += 1; + return .{ + @intCast(self.region.beg.?[self.i]), + @intCast(self.region.end.?[self.i]), + }; + } + }; +}; diff --git a/vendor/libghostty-vt/pkg/oniguruma/testing.zig b/vendor/libghostty-vt/pkg/oniguruma/testing.zig new file mode 100644 index 00000000..234b5e75 --- /dev/null +++ b/vendor/libghostty-vt/pkg/oniguruma/testing.zig @@ -0,0 +1,15 @@ +const init = @import("init.zig"); +const Encoding = @import("types.zig").Encoding; + +var initialized: bool = false; + +/// Call this function before any other tests in this package to ensure that +/// the oni library is initialized. This should only be used for tests +/// and only when you're sure this is the ONLY way that oni is being +/// initialized. +/// +/// This always only initializes the encodings the tests use. +pub fn ensureInit() !void { + if (initialized) return; + try init.init(&.{Encoding.utf8}); +} diff --git a/vendor/libghostty-vt/pkg/oniguruma/types.zig b/vendor/libghostty-vt/pkg/oniguruma/types.zig new file mode 100644 index 00000000..84a0a7c9 --- /dev/null +++ b/vendor/libghostty-vt/pkg/oniguruma/types.zig @@ -0,0 +1,96 @@ +const std = @import("std"); +const c = @import("c.zig").c; + +pub const Encoding = opaque { + pub const ascii: *Encoding = @ptrCast(c.ONIG_ENCODING_ASCII()); + pub const iso_8859_1: *Encoding = @ptrCast(c.ONIG_ENCODING_ISO_8859_1()); + pub const iso_8859_2: *Encoding = @ptrCast(c.ONIG_ENCODING_ISO_8859_2()); + pub const iso_8859_3: *Encoding = @ptrCast(c.ONIG_ENCODING_ISO_8859_3()); + pub const iso_8859_4: *Encoding = @ptrCast(c.ONIG_ENCODING_ISO_8859_4()); + pub const iso_8859_5: *Encoding = @ptrCast(c.ONIG_ENCODING_ISO_8859_5()); + pub const iso_8859_6: *Encoding = @ptrCast(c.ONIG_ENCODING_ISO_8859_6()); + pub const iso_8859_7: *Encoding = @ptrCast(c.ONIG_ENCODING_ISO_8859_7()); + pub const iso_8859_8: *Encoding = @ptrCast(c.ONIG_ENCODING_ISO_8859_8()); + pub const iso_8859_9: *Encoding = @ptrCast(c.ONIG_ENCODING_ISO_8859_9()); + pub const iso_8859_10: *Encoding = @ptrCast(c.ONIG_ENCODING_ISO_8859_10()); + pub const iso_8859_11: *Encoding = @ptrCast(c.ONIG_ENCODING_ISO_8859_11()); + pub const iso_8859_13: *Encoding = @ptrCast(c.ONIG_ENCODING_ISO_8859_13()); + pub const iso_8859_14: *Encoding = @ptrCast(c.ONIG_ENCODING_ISO_8859_14()); + pub const iso_8859_15: *Encoding = @ptrCast(c.ONIG_ENCODING_ISO_8859_15()); + pub const iso_8859_16: *Encoding = @ptrCast(c.ONIG_ENCODING_ISO_8859_16()); + pub const utf8: *Encoding = @ptrCast(c.ONIG_ENCODING_UTF8()); + pub const utf16_be: *Encoding = @ptrCast(c.ONIG_ENCODING_UTF16_BE()); + pub const utf16_le: *Encoding = @ptrCast(c.ONIG_ENCODING_UTF16_LE()); + pub const utf32_be: *Encoding = @ptrCast(c.ONIG_ENCODING_UTF32_BE()); + pub const utf32_le: *Encoding = @ptrCast(c.ONIG_ENCODING_UTF32_LE()); + pub const euc_jp: *Encoding = @ptrCast(c.ONIG_ENCODING_EUC_JP()); + pub const euc_tw: *Encoding = @ptrCast(c.ONIG_ENCODING_EUC_TW()); + pub const euc_kr: *Encoding = @ptrCast(c.ONIG_ENCODING_EUC_KR()); + pub const euc_cn: *Encoding = @ptrCast(c.ONIG_ENCODING_EUC_CN()); + pub const sjis: *Encoding = @ptrCast(c.ONIG_ENCODING_SJIS()); + pub const koi8: *Encoding = @ptrCast(c.ONIG_ENCODING_KOI8()); + pub const koi8_r: *Encoding = @ptrCast(c.ONIG_ENCODING_KOI8_R()); + pub const cp1251: *Encoding = @ptrCast(c.ONIG_ENCODING_CP1251()); + pub const big5: *Encoding = @ptrCast(c.ONIG_ENCODING_BIG5()); + pub const gb18030: *Encoding = @ptrCast(c.ONIG_ENCODING_GB18030()); +}; + +pub const Syntax = opaque { + pub const default: *Syntax = @ptrCast(c.ONIG_SYNTAX_ONIGURUMA()); + pub const asis: *Syntax = @ptrCast(c.ONIG_SYNTAX_ASIS()); + pub const posix_basic: *Syntax = @ptrCast(c.ONIG_SYNTAX_POSIX_BASIC()); + pub const posix_extended: *Syntax = @ptrCast(c.ONIG_SYNTAX_POSIX_EXTENDED()); + pub const emacs: *Syntax = @ptrCast(c.ONIG_SYNTAX_EMACS()); + pub const grep: *Syntax = @ptrCast(c.ONIG_SYNTAX_GREP()); + pub const gnu_regex: *Syntax = @ptrCast(c.ONIG_SYNTAX_GNU_REGEX()); + pub const java: *Syntax = @ptrCast(c.ONIG_SYNTAX_JAVA()); + pub const perl: *Syntax = @ptrCast(c.ONIG_SYNTAX_PERL()); + pub const perl_ng: *Syntax = @ptrCast(c.ONIG_SYNTAX_PERL_NG()); + pub const ruby: *Syntax = @ptrCast(c.ONIG_SYNTAX_RUBY()); + pub const oniguruma: *Syntax = @ptrCast(c.ONIG_SYNTAX_ONIGURUMA()); +}; + +pub const Option = packed struct(c_uint) { + ignorecase: bool = false, + extend: bool = false, + multiline: bool = false, + singleline: bool = false, + find_longest: bool = false, + find_not_empty: bool = false, + negate_singleline: bool = false, + dont_capture_group: bool = false, + capture_group: bool = false, + // search time + notbol: bool = false, + noteol: bool = false, + posix_region: bool = false, + check_validity_of_string: bool = false, + // compile time + ignorecase_is_ascii: bool = false, + word_is_ascii: bool = false, + digit_is_ascii: bool = false, + space_is_ascii: bool = false, + posix_is_ascii: bool = false, + text_segment_extended_grapheme_cluster: bool = false, + text_segment_word: bool = false, + // search time + not_begin_string: bool = false, + not_end_string: bool = false, + not_begin_position: bool = false, + callback_each_match: bool = false, + match_whole_string: bool = false, + + _padding: u7 = 0, + + pub fn int(self: Option) c_uint { + return @bitCast(self); + } + + test "order" { + const testing = std.testing; + const opt: Option = .{ .extend = true }; + try testing.expectEqual(c.ONIG_OPTION_EXTEND, opt.int()); + } +}; + +test {} |
