1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863
extern crate libc; use libc::{c_int, c_uint, c_ulong, c_void, c_char, c_uchar}; pub type OnigCodePoint = c_ulong; pub type OnigOptions = c_uint; pub type OnigSyntaxOp = c_uint; pub type OnigSyntaxOp2 = c_uint; pub type OnigSyntaxBehavior = c_uint; pub type OnigCaseFoldType = c_uint; pub type OnigEncoding = c_void; pub type OnigRegex = *const c_void; /// Warning Callback /// /// `void (*func)(char* warning_message)` pub type OnigWarnFunc = extern "C" fn(*const c_char); /// Foreach Callback /// /// This callback will be invoked for each name when calling /// [`onig_foreach_name`](fn.onig_foreach_name.html). The /// final argument to that function is passed back to this callback. pub type OnigForeachCallback = extern "C" fn(*const c_uchar, *const c_uchar, c_int, *const c_int, OnigRegex, *mut c_void) -> c_int; /// Capture Tree Callback /// /// ```c /// int(*func)(int,int,int,int,int,void*) /// ``` /// /// This callback will be invoked for each node in the capture tree /// being traversed. See /// [`onig_capture_tree_traverse`](fn.onig_capture_tree_traverse.html) /// for more information about parameters and use. pub type OnigCaptureTreeCallback = extern "C" fn(c_int, c_int, c_int, c_int, c_int, *mut c_void) -> c_int; #[repr(C)] #[derive(Debug)] pub struct OnigRegion { pub allocated: c_int, pub num_regs: c_int, pub beg: *const c_int, pub end: *const c_int, pub history_root: *const OnigCaptureTreeNode, } #[repr(C)] #[derive(Debug)] pub struct OnigCaptureTreeNode { pub group: c_int, pub beg: c_int, pub end: c_int, pub allocated: c_int, pub num_childs: c_int, pub childs: *const *const OnigCaptureTreeNode, } #[repr(C)] #[derive(Debug, Clone, Copy)] pub struct OnigSyntax { pub op: c_uint, pub op2: c_uint, pub behavior: c_uint, pub options: c_uint, pub meta_char_table: OnigMetaCharTable, } #[repr(C)] #[derive(Debug)] pub struct OnigCompileInfo { pub num_of_elements: c_int, pub pattern_enc: *const OnigEncoding, pub target_enc: *const OnigEncoding, pub syntax: *const OnigSyntax, pub option: OnigOptions, pub case_fold_flag: OnigCaseFoldType, } #[repr(C)] #[derive(Debug, Clone, Copy)] pub struct OnigMetaCharTable { pub esc: OnigCodePoint, pub anychar: OnigCodePoint, pub anytime: OnigCodePoint, pub zero_or_one_time: OnigCodePoint, pub one_or_more_time: OnigCodePoint, pub anychar_anytime: OnigCodePoint, } #[repr(C)] #[derive(Debug)] pub struct OnigErrorInfo { pub enc: *const OnigEncoding, pub par: *const c_uchar, pub par_end: *const c_uchar, } extern "C" { pub static OnigEncodingASCII: OnigEncoding; pub static OnigEncodingISO_8859_1: OnigEncoding; pub static OnigEncodingISO_8859_2: OnigEncoding; pub static OnigEncodingISO_8859_3: OnigEncoding; pub static OnigEncodingISO_8859_4: OnigEncoding; pub static OnigEncodingISO_8859_5: OnigEncoding; pub static OnigEncodingISO_8859_6: OnigEncoding; pub static OnigEncodingISO_8859_7: OnigEncoding; pub static OnigEncodingISO_8859_8: OnigEncoding; pub static OnigEncodingISO_8859_9: OnigEncoding; pub static OnigEncodingISO_8859_10: OnigEncoding; pub static OnigEncodingISO_8859_11: OnigEncoding; pub static OnigEncodingISO_8859_13: OnigEncoding; pub static OnigEncodingISO_8859_14: OnigEncoding; pub static OnigEncodingISO_8859_15: OnigEncoding; pub static OnigEncodingISO_8859_16: OnigEncoding; pub static OnigEncodingUTF8: OnigEncoding; pub static OnigEncodingUTF16_BE: OnigEncoding; pub static OnigEncodingUTF16_LE: OnigEncoding; pub static OnigEncodingUTF32_BE: OnigEncoding; pub static OnigEncodingUTF32_LE: OnigEncoding; pub static OnigEncodingEUC_JP: OnigEncoding; pub static OnigEncodingEUC_TW: OnigEncoding; pub static OnigEncodingEUC_KR: OnigEncoding; pub static OnigEncodingEUC_CN: OnigEncoding; pub static OnigEncodingSJIS: OnigEncoding; pub static OnigEncodingKOI8: OnigEncoding; pub static OnigEncodingKOI8_R: OnigEncoding; pub static OnigEncodingCP1251: OnigEncoding; pub static OnigEncodingBIG5: OnigEncoding; pub static OnigEncodingGB18030: OnigEncoding; pub static OnigSyntaxASIS: OnigSyntax; pub static OnigSyntaxPosixBasic: OnigSyntax; pub static OnigSyntaxPosixExtended: OnigSyntax; pub static OnigSyntaxEmacs: OnigSyntax; pub static OnigSyntaxGrep: OnigSyntax; pub static OnigSyntaxGnuRegex: OnigSyntax; pub static OnigSyntaxJava: OnigSyntax; pub static OnigSyntaxPerl: OnigSyntax; pub static OnigSyntaxPerl_NG: OnigSyntax; pub static OnigSyntaxRuby: OnigSyntax; pub static OnigDefaultSyntax: *mut OnigSyntax; // Oniguruma API Version 5.9.2 2008/02/19 /// Initialize library. /// /// `int onig_init(void)` /// /// You don't have to call it explicitly, because it is called in onig_new(). pub fn onig_init() -> c_int; /// Get error message string. /// If this function is used for onig_new(), /// don't call this after the pattern argument of onig_new() is freed. /// /// `int onig_error_code_to_str(UChar* err_buf, int err_code, ...)` /// /// normal return: error message string length /// /// # Arguments /// /// 1. err_buf: error message string buffer. /// (required size: ONIG_MAX_ERROR_MESSAGE_LEN) /// 2. err_code: error code returned by other API functions. /// 3. err_info (optional): error info returned by onig_new(). pub fn onig_error_code_to_str(err_buff: *mut c_uchar, err_code: c_int, ...) -> c_int; /// Set warning function. /// /// `void onig_set_warn_func(OnigWarnFunc func)` /// /// WARNING: /// '[', '-', ']' in character class without escape. /// ']' in pattern without escape. /// /// arguments /// 1 func: function pointer. void (*func)(char* warning_message) pub fn onig_set_warn_func(func: OnigWarnFunc); /// Set verbose warning function. /// /// `void onig_set_verb_warn_func(OnigWarnFunc func)` /// /// WARNING: /// redundant nested repeat operator. /// /// arguments /// 1 func: function pointer. void (*func)(char* warning_message) pub fn onig_set_verb_warn_func(func: OnigWarnFunc); /// Create a regex object. /// /// `int onig_new(regex_t** reg, const UChar* pattern, const UChar* pattern_end, /// OnigOptionType option, OnigEncoding enc, OnigSyntaxType* syntax, /// OnigErrorInfo* err_info)` /// /// normal return: ONIG_NORMAL /// /// # Arguments /// /// 1. `reg`: return regex object's address. /// 2. `pattern`: regex pattern string. /// 3. `pattern_end`: terminate address of pattern. (pattern + pattern length) /// 4. `option`: compile time options. /// /// * ONIG_OPTION_NONE no option /// * ONIG_OPTION_SINGLELINE '^' -> '\A', '$' -> '\Z' /// * ONIG_OPTION_MULTILINE '.' match with newline /// * ONIG_OPTION_IGNORECASE ambiguity match on /// * ONIG_OPTION_EXTEND extended pattern form /// * ONIG_OPTION_FIND_LONGEST find longest match /// * ONIG_OPTION_FIND_NOT_EMPTY ignore empty match /// * ONIG_OPTION_NEGATE_SINGLELINE /// clear ONIG_OPTION_SINGLELINE which is enabled on /// ONIG_SYNTAX_POSIX_BASIC, ONIG_SYNTAX_POSIX_EXTENDED, /// ONIG_SYNTAX_PERL, ONIG_SYNTAX_PERL_NG, ONIG_SYNTAX_JAVA /// /// * ONIG_OPTION_DONT_CAPTURE_GROUP only named group captured. /// * ONIG_OPTION_CAPTURE_GROUP named and no-named group captured. /// /// 5. `enc`: character encoding. /// /// * ONIG_ENCODING_ASCII ASCII /// * ONIG_ENCODING_ISO_8859_1 ISO 8859-1 /// * ONIG_ENCODING_ISO_8859_2 ISO 8859-2 /// * ONIG_ENCODING_ISO_8859_3 ISO 8859-3 /// * ONIG_ENCODING_ISO_8859_4 ISO 8859-4 /// * ONIG_ENCODING_ISO_8859_5 ISO 8859-5 /// * ONIG_ENCODING_ISO_8859_6 ISO 8859-6 /// * ONIG_ENCODING_ISO_8859_7 ISO 8859-7 /// * ONIG_ENCODING_ISO_8859_8 ISO 8859-8 /// * ONIG_ENCODING_ISO_8859_9 ISO 8859-9 /// * ONIG_ENCODING_ISO_8859_10 ISO 8859-10 /// * ONIG_ENCODING_ISO_8859_11 ISO 8859-11 /// * ONIG_ENCODING_ISO_8859_13 ISO 8859-13 /// * ONIG_ENCODING_ISO_8859_14 ISO 8859-14 /// * ONIG_ENCODING_ISO_8859_15 ISO 8859-15 /// * ONIG_ENCODING_ISO_8859_16 ISO 8859-16 /// * ONIG_ENCODING_UTF8 UTF-8 /// * ONIG_ENCODING_UTF16_BE UTF-16BE /// * ONIG_ENCODING_UTF16_LE UTF-16LE /// * ONIG_ENCODING_UTF32_BE UTF-32BE /// * ONIG_ENCODING_UTF32_LE UTF-32LE /// * ONIG_ENCODING_EUC_JP EUC-JP /// * ONIG_ENCODING_EUC_TW EUC-TW /// * ONIG_ENCODING_EUC_KR EUC-KR /// * ONIG_ENCODING_EUC_CN EUC-CN /// * ONIG_ENCODING_SJIS Shift_JIS /// * ONIG_ENCODING_KOI8_R KOI8-R /// * ONIG_ENCODING_CP1251 CP1251 /// * ONIG_ENCODING_BIG5 Big5 /// * ONIG_ENCODING_GB18030 GB18030 /// /// /// or any OnigEncoding data address defined by user. /// /// /// /// 6. `syntax`: address of pattern syntax definition. /// /// /// * ONIG_SYNTAX_ASIS plain text /// * ONIG_SYNTAX_POSIX_BASIC POSIX Basic RE /// * ONIG_SYNTAX_POSIX_EXTENDED POSIX Extended RE /// * ONIG_SYNTAX_EMACS Emacs /// * ONIG_SYNTAX_GREP grep /// * ONIG_SYNTAX_GNU_REGEX GNU regex /// * ONIG_SYNTAX_JAVA Java (Sun java.util.regex) /// * ONIG_SYNTAX_PERL Perl /// * ONIG_SYNTAX_PERL_NG Perl + named group /// * ONIG_SYNTAX_RUBY Ruby /// * ONIG_SYNTAX_DEFAULT default (== Ruby) /// onig_set_default_syntax() /// /// /// or any OnigSyntaxType data address defined by user. /// /// /// /// 7. `err_info`: address for return optional error info. /// /// Use this value as 3rd argument of onig_error_code_to_str(). /// pub fn onig_new(reg: *mut OnigRegex, pattern: *const c_uchar, pattern_end: *const c_uchar, option: OnigOptions, enc: *const OnigEncoding, syntax: *const OnigSyntax, err_info: *mut OnigErrorInfo) -> c_int; /// Create a regex object. /// reg object area is not allocated in this function. /// /// `int onig_new_without_alloc(regex_t* reg, const UChar* pattern, /// const UChar* pattern_end, /// OnigOptionType option, OnigEncoding enc, OnigSyntaxType* syntax, /// OnigErrorInfo* err_info)` /// /// normal return: ONIG_NORMAL pub fn onig_new_without_alloc(reg: OnigRegex, pattern: *const c_uchar, pattern_end: *const c_uchar, option: OnigOptions, enc: *const OnigEncoding, syntax: *const OnigSyntax, err_info: *mut OnigErrorInfo) -> c_int; /// Create a regex object. /// This function is deluxe version of onig_new(). /// /// `int onig_new_deluxe(regex_t** reg, const UChar* pattern, const UChar* pattern_end, /// OnigCompileInfo* ci, OnigErrorInfo* einfo)` /// /// normal return: ONIG_NORMAL /// /// arguments /// 1 reg: return address of regex object. /// 2 pattern: regex pattern string. /// 3 pattern_end: terminate address of pattern. (pattern + pattern length) /// 4 ci: compile time info. /// /// ci->num_of_elements: number of elements in ci. (current version: 5) /// ci->pattern_enc: pattern string character encoding. /// ci->target_enc: target string character encoding. /// ci->syntax: address of pattern syntax definition. /// ci->option: compile time option. /// ci->case_fold_flag: character matching case fold bit flag for /// ONIG_OPTION_IGNORECASE mode. /// /// ONIGENC_CASE_FOLD_MIN: minimum /// ONIGENC_CASE_FOLD_DEFAULT: minimum (onig_set_default_case_fold_flag()) /// /// 5 err_info: address for return optional error info. /// Use this value as 3rd argument of onig_error_code_to_str(). /// /// /// Different character encoding combination is allowed for /// the following cases only. /// /// pattern_enc: ASCII, ISO_8859_1 /// target_enc: UTF16_BE, UTF16_LE, UTF32_BE, UTF32_LE /// /// pattern_enc: UTF16_BE/LE /// target_enc: UTF16_LE/BE /// /// pattern_enc: UTF32_BE/LE /// target_enc: UTF32_LE/BE pub fn onig_new_deluxe(reg: *mut OnigRegex, pattern: *const c_uchar, pattern_end: *const c_uchar, ci: *const OnigCompileInfo, einfo: *mut OnigErrorInfo) -> c_int; /// Free memory used by regex object. /// /// `void onig_free(regex_t* reg)` /// /// # Arguments /// /// 1. `reg`: regex object. pub fn onig_free(reg: OnigRegex); /// Free memory used by regex object. (Except reg oneself.) /// /// `void onig_free_body(regex_t* reg)` /// /// arguments /// 1 reg: regex object. pub fn onig_free_body(reg: OnigRegex); /// Search string and return search result and matching region. /// /// `int onig_search(regex_t* reg, const UChar* str, const UChar* end, const UChar* start, /// const UChar* range, OnigRegion* region, OnigOptionType option)` /// /// # Returns /// /// normal return: match position offset (i.e. p - str >= 0) /// not found: ONIG_MISMATCH (< 0) /// /// # Arguments /// /// 1. `reg`: regex object /// 2. `str`: target string /// 3. `end`: terminate address of target string /// 4. `start`: search start address of target string /// 5. `range`: search terminate address of target string /// in forward search (start <= searched string < range) /// in backward search (range <= searched string <= start) /// 6. `region`: address for return group match range info (NULL is allowed) /// 7. `option`: search time option /// /// * ONIG_OPTION_NOTBOL string head(str) isn't considered as begin of line /// * ONIG_OPTION_NOTEOL string end (end) isn't considered as end of line /// * ONIG_OPTION_POSIX_REGION region argument is regmatch_t[] of POSIX API. pub fn onig_search(reg: OnigRegex, str: *const c_uchar, end: *const c_uchar, start: *const c_uchar, range: *const c_uchar, region: *mut OnigRegion, option: OnigOptions) -> c_int; /// Match string and return result and matching region. /// /// `int onig_match(regex_t* reg, const UChar* str, const UChar* end, const UChar* at, /// OnigRegion* region, OnigOptionType option)` /// /// # Returns /// /// normal return: match length (>= 0) /// not match: ONIG_MISMATCH ( < 0) /// /// # Arguments /// /// 1. `reg`: regex object /// 2. `str`: target string /// 3. `end`: terminate address of target string /// 4. `at`: match address of target string /// 5. `region`: address for return group match range info (NULL is allowed) /// 6. `option`: search time option /// /// * ONIG_OPTION_NOTBOL string head(str) isn't considered as begin of line /// * ONIG_OPTION_NOTEOL string end (end) isn't considered as end of line /// * ONIG_OPTION_POSIX_REGION region argument is regmatch_t[] type of POSIX API. pub fn onig_match(reg: OnigRegex, str: *const c_uchar, end: *const c_uchar, at: *const c_uchar, region: *mut OnigRegion, option: OnigOptions) -> c_int; /// Create a region. /// /// `OnigRegion* onig_region_new(void)` pub fn onig_region_new() -> *mut OnigRegion; /// Free memory used by region. /// /// `void onig_region_free(OnigRegion* region, int free_self)` /// /// # Arguments /// /// 1. `region`: target region /// 2. `free_self`: [1: free all, 0: free memory used in region /// but not self] /// pub fn onig_region_free(region: *mut OnigRegion, free_self: c_int); /// Copy contents of region. /// /// `void onig_region_copy(OnigRegion* to, OnigRegion* from)` /// /// # Arguments /// /// 1. `to`: target region /// 2. `from`: source region pub fn onig_region_copy(to: *mut OnigRegion, from: *mut OnigRegion); /// Clear contents of region. /// /// `void onig_region_clear(OnigRegion* region)` /// /// # Arguments /// /// 1. `region`: target region pub fn onig_region_clear(region: *const OnigRegion); /// Resize group range area of region. /// /// `int onig_region_resize(OnigRegion* region, int n)` /// /// # Returns /// /// normal return: ONIG_NORMAL /// /// # Arguments /// /// 1. `region`: target region /// 2. `n`: new size pub fn onig_region_resize(region: *const OnigRegion, n: c_int) -> c_int; /// Return the group number list of the name. /// Named subexp is defined by (?<name>....). /// /// `int onig_name_to_group_numbers(regex_t* reg, const UChar* name, const UChar* name_end, /// int** num_list)` /// /// normal return: number of groups for the name. /// (ex. /(?<x>..)(?<x>..)/ ==> 2) /// name not found: -1 /// /// arguments /// 1 reg: regex object. /// 2 name: group name. /// 3 name_end: terminate address of group name. /// 4 num_list: return list of group number. pub fn onig_name_to_group_numbers(reg: OnigRegex, name: *const c_uchar, name_end: *const c_uchar, num_list: *mut *const c_int) -> c_int; /// Return the group number corresponding to the named backref (\k<name>). /// If two or more regions for the groups of the name are effective, /// the greatest number in it is obtained. /// /// `int onig_name_to_backref_number(regex_t* reg, const UChar* name, const UChar* name_end, /// OnigRegion *region)` /// /// normal return: group number. /// /// arguments /// 1 reg: regex object. /// 2 name: group name. /// 3 name_end: terminate address of group name. /// 4 region: search/match result region. pub fn onig_name_to_backref_number(reg: OnigRegex, name: *const c_uchar, name_end: *const c_uchar, region: *const OnigRegion) -> c_int; /// Iterate function call for all names. /// /// `int onig_foreach_name(regex_t* reg, /// int (*func)(const UChar*, const UChar*, int,int*,regex_t*,void*), /// void* arg)` /// /// # Returns /// /// * normal return: 0 /// * error: func's return value. /// /// # Arguments /// /// 1. reg: regex object. /// 2. func: callback function. /// /// ```c /// func(name, name_end, <number of groups>, <group number's list>, /// reg, arg); /// ``` /// /// if func does not return 0, then iteration is stopped. /// 3. arg: argument for func. pub fn onig_foreach_name(reg: OnigRegex, func: OnigForeachCallback, arg: *mut c_void) -> c_int; /// Return the number of names defined in the pattern. /// Multiple definitions of one name is counted as one. /// /// `int onig_number_of_names(regex_t* reg)` /// /// # Arguments /// /// 1. `reg`: regex object. pub fn onig_number_of_names(reg: OnigRegex) -> c_int; /// `OnigEncoding onig_get_encoding(regex_t* reg)` pub fn onig_get_encoding(reg: OnigRegex) -> *const OnigEncoding; /// `OnigOptionType onig_get_options(regex_t* reg)` pub fn onig_get_options(reg: OnigRegex) -> OnigOptions; /// `OnigCaseFoldType onig_get_case_fold_flag(regex_t* reg)` pub fn onig_get_case_fold_flag(reg: OnigRegex) -> OnigCaseFoldType; /// `OnigSyntaxType* onig_get_syntax(regex_t* reg)` pub fn onig_get_syntax(reg: OnigRegex) -> *const OnigSyntax; /// Return the number of capture group in the pattern. /// /// `int onig_number_of_captures(regex_t* reg)` /// /// # Arguments /// /// 1. `reg`: regex object. pub fn onig_number_of_captures(reg: OnigRegex) -> c_int; /// Return the number of capture history defined in the pattern. /// /// `int onig_number_of_capture_histories(regex_t* reg)` /// /// You can't use capture history if ONIG_SYN_OP2_ATMARK_CAPTURE_HISTORY /// is disabled in the pattern syntax.(disabled in the default syntax) /// /// # arguments /// /// 1. `reg`: regex object. pub fn onig_number_of_capture_histories(reg: OnigRegex) -> c_int; /// Return the root node of capture history data tree. /// /// `OnigCaptureTreeNode* onig_get_capture_tree(OnigRegion* region)` /// /// This value is undefined if matching has faild. /// /// # Arguments /// /// 1. `region`: matching result. pub fn onig_get_capture_tree(region: *const OnigRegion) -> *const OnigCaptureTreeNode; /// Traverse and callback in capture history data tree. /// /// `int onig_capture_tree_traverse(OnigRegion* region, int at, /// int(*func)(int,int,int,int,int,void*), void* arg)` /// /// # Returns /// /// normal return: 0 /// error: callback func's return value. /// /// # Arguments /// /// 1. region: match region data. /// 2. at: callback position. /// /// * ONIG_TRAVERSE_CALLBACK_AT_FIRST: callback first, then traverse childs. /// * ONIG_TRAVERSE_CALLBACK_AT_LAST: traverse childs first, then callback. /// * ONIG_TRAVERSE_CALLBACK_AT_BOTH: callback first, then traverse childs, /// and at last callback again. /// /// 3. func: callback function. /// if func does not return 0, then traverse is stopped. /// /// ```c /// int func(int group, int beg, int end, int level, int at, /// void* arg) /// ``` /// /// * group: group number /// * beg: capture start position /// * end: capture end position /// * level: nest level (from 0) /// * at: callback position /// * ONIG_TRAVERSE_CALLBACK_AT_FIRST /// * ONIG_TRAVERSE_CALLBACK_AT_LAST /// * arg: optional callback argument /// /// 4. arg; optional callback argument. pub fn onig_capture_tree_traverse(region: *const OnigRegion, at: c_int, func: OnigCaptureTreeCallback, arg: c_void) -> c_int; /// Return noname group capture activity. /// /// `int onig_noname_group_capture_is_active(regex_t* reg)` /// /// active: 1 /// inactive: 0 /// /// # Arguments /// /// 1. reg: regex object. /// /// > if option ONIG_OPTION_DONT_CAPTURE_GROUP == ON /// > --> inactive /// > /// > if the regex pattern have named group /// > and syntax ONIG_SYN_CAPTURE_ONLY_NAMED_GROUP == ON /// > and option ONIG_OPTION_CAPTURE_GROUP == OFF /// > --> inactive /// > /// > else --> active pub fn onig_noname_group_capture_is_active(reg: OnigRegex) -> c_int; /// Return previous character head address. /// /// `UChar* onigenc_get_prev_char_head(OnigEncoding enc, const UChar* start, const UChar* s)` /// /// arguments /// 1 enc: character encoding /// 2 start: string address /// 3 s: target address of string pub fn onigenc_get_prev_char_head(enc: *const OnigEncoding, start: *const c_uchar, s: *const c_uchar) -> *const c_uchar; /// Return left-adjusted head address of a character. /// /// `UChar* onigenc_get_left_adjust_char_head(OnigEncoding enc, /// const UChar* start, const UChar* s)` /// /// # Arguments /// /// 1. enc: character encoding /// 2. start: string address /// 3. s: target address of string pub fn onigenc_get_left_adjust_char_head(enc: *const OnigEncoding, start: *const c_uchar, s: *const c_uchar) -> *const c_uchar; /// Return right-adjusted head address of a character. /// /// `UChar* onigenc_get_right_adjust_char_head(OnigEncoding enc, /// const UChar* start, const UChar* s)` /// /// # Arguments /// /// 1. enc: character encoding /// 2. start: string address /// 3. s: target address of string pub fn onigenc_get_right_adjust_char_head(enc: *const OnigEncoding, start: *const c_uchar, s: *const c_uchar) -> *const c_uchar; /// Return number of characters in the string. /// /// `int onigenc_strlen(OnigEncoding enc, const UChar* s, const UChar* end)` pub fn onigenc_strlen(enc: *const OnigEncoding, s: *const c_uchar, end: *const c_uchar) -> c_int; /// Return number of characters in the string. /// /// `int onigenc_strlen_null(OnigEncoding enc, const UChar* s)` pub fn onigenc_strlen_null(enc: *const OnigEncoding, s: *const c_uchar) -> c_int; /// Return number of bytes in the string. /// /// `int onigenc_str_bytelen_null(OnigEncoding enc, const UChar* s)` pub fn onigenc_str_bytelen_null(enc: *const OnigEncoding, s: *const c_uchar) -> c_int; /// Set default syntax. /// /// `int onig_set_default_syntax(OnigSyntaxType* syntax)` /// /// arguments /// 1 syntax: address of pattern syntax definition. pub fn onig_set_default_syntax(syntax: *const OnigSyntax) -> c_int; /// Copy syntax. /// /// `void onig_copy_syntax(OnigSyntaxType* to, OnigSyntaxType* from)` /// /// # Arguments /// /// 1. `to`: destination address. /// 2. `from`: source address. pub fn onig_copy_syntax(to: *const OnigSyntax, from: *const OnigSyntax); /// `unsigned int onig_get_syntax_op(OnigSyntaxType* syntax)` pub fn onig_get_syntax_op(syntax: *const OnigSyntax) -> OnigSyntaxOp; /// `unsigned int onig_get_syntax_op2(OnigSyntaxType* syntax)` pub fn onig_get_syntax_op2(syntax: *const OnigSyntax) -> OnigSyntaxOp2; /// `unsigned int onig_get_syntax_behavior(OnigSyntaxType* syntax)` pub fn onig_get_syntax_behavior(syntax: *const OnigSyntax) -> OnigSyntaxBehavior; /// `OnigOptionType onig_get_syntax_options(OnigSyntaxType* syntax)` pub fn onig_get_syntax_options(syntax: *const OnigSyntax) -> OnigOptions; /// `void onig_set_syntax_op(OnigSyntaxType* syntax, unsigned int op)` pub fn onig_set_syntax_op(syntax: *mut OnigSyntax, op: OnigSyntaxOp); /// `void onig_set_syntax_op2(OnigSyntaxType* syntax, unsigned int op2)` pub fn onig_set_syntax_op2(syntax: *mut OnigSyntax, op2: OnigSyntaxOp2); /// `void onig_set_syntax_behavior(OnigSyntaxType* syntax, unsigned int behavior)` pub fn onig_set_syntax_behavior(syntax: *mut OnigSyntax, behavior: OnigSyntaxBehavior); /// `void onig_set_syntax_options(OnigSyntaxType* syntax, OnigOptionType options)` pub fn onig_set_syntax_options(syntax: *mut OnigSyntax, options: OnigOptions); /// Copy encoding. /// /// `void onig_copy_encoding(OnigEncoding to, OnigOnigEncoding from)` /// /// arguments /// 1 to: destination address. /// 2 from: source address. pub fn onig_copy_encoding(to: *mut OnigEncoding, from: *const OnigEncoding); /// Set a variable meta character to the code point value. /// Except for an escape character, this meta characters specification /// is not work, if ONIG_SYN_OP_VARIABLE_META_CHARACTERS is not effective /// by the syntax. (Build-in syntaxes are not effective.) /// /// `int onig_set_meta_char(OnigSyntaxType* syntax, unsigned int what, /// OnigCodePoint code)` /// /// normal return: ONIG_NORMAL /// /// arguments /// 1 syntax: target syntax /// 2 what: specifies which meta character it is. /// /// ```c /// ONIG_META_CHAR_ESCAPE /// ONIG_META_CHAR_ANYCHAR /// ONIG_META_CHAR_ANYTIME /// ONIG_META_CHAR_ZERO_OR_ONE_TIME /// ONIG_META_CHAR_ONE_OR_MORE_TIME /// ONIG_META_CHAR_ANYCHAR_ANYTIME /// ``` /// /// 3 code: meta character or `ONIG_INEFFECTIVE_META_CHAR`. pub fn onig_set_meta_char(syntax: *mut OnigSyntax, what: c_uint, code: OnigCodePoint) -> c_int; /// Get default case fold flag. /// /// `OnigCaseFoldType onig_get_default_case_fold_flag()` pub fn onig_get_default_case_fold_flag() -> OnigCaseFoldType; /// Set default case fold flag. /// /// `int onig_set_default_case_fold_flag(OnigCaseFoldType case_fold_flag)` /// /// 1 case_fold_flag: case fold flag pub fn onig_set_default_case_fold_flag(case_fold_flag: OnigCaseFoldType) -> c_int; /// Return the maximum number of stack size. /// (default: 0 == unlimited) /// /// `unsigned int onig_get_match_stack_limit_size(void)` pub fn onig_get_match_stack_limit_size() -> c_uint; /// Set the maximum number of stack size. /// /// `int onig_set_match_stack_limit_size(unsigned int size)` /// /// (size = 0: unlimited) /// normal return: ONIG_NORMAL pub fn onig_set_match_stack_limit_size(size: c_uint) -> c_int; /// The use of this library is finished. /// /// `int onig_end(void)` /// /// normal return: ONIG_NORMAL /// /// It is not allowed to use regex objects which created /// before onig_end() call. pub fn onig_end() -> c_int; /// Return version string. (ex. "5.0.3") /// /// `const char* onig_version(void)` pub fn onig_version() -> *const c_char; }