#sys #onig #oniguruma

sys onig_sys

The onig_sys crate contains raw rust bindings to the oniguruma library. This crate exposes a set of unsafe functions which can then be used by other crates to create safe wrappers around Oniguruma. You probably don’t want to link to this crate directly; instead check out the onig crate.

39 releases (stable)

Uses old Rust 2015

69.7.0 Jun 9, 2021
69.6.0 Nov 22, 2020
69.5.1 Sep 9, 2020
69.5.0 May 16, 2020
0.6.0 Jan 31, 2016

#50 in Text processing

Download history 11617/week @ 2021-02-26 12230/week @ 2021-03-05 13224/week @ 2021-03-12 13629/week @ 2021-03-19 16457/week @ 2021-03-26 17422/week @ 2021-04-02 14315/week @ 2021-04-09 14609/week @ 2021-04-16 12568/week @ 2021-04-23 13633/week @ 2021-04-30 13142/week @ 2021-05-07 11380/week @ 2021-05-14 16212/week @ 2021-05-21 16118/week @ 2021-05-28 17884/week @ 2021-06-04 13060/week @ 2021-06-11

61,970 downloads per month
Used in 52 crates (via onig)

MIT license

2.5MB
86K SLoC

C 83K SLoC // 0.0% comments Rust 1.5K SLoC // 0.0% comments Python 1.5K SLoC // 0.1% comments Automake 232 SLoC // 0.0% comments Shell 63 SLoC // 0.1% comments C++ 21 SLoC // 0.5% comments Batch 15 SLoC

Rust Onig

Cargo Documentation CI Build status dependency status

Rust bindings for the Oniguruma regex library, a powerful and mature regular expression library with support for a wide range of character sets and language syntaxes. Oniguruma is written in C. This repository provides two crates: onig-sys which provides the raw Rust FFI bindings, and onig, which provides a safe Rust wrapper around them.

Documentation

Check out the module documentation to find out all the features that are available. To see some example usage of this crate take a look a the examples folder. The examples can be run from the command line with cargo run --example <examplename>.

Getting Started

Add the following to your Cargo.toml file:

[dependencies]
onig = "6"

Add the following extern to your crate root if you are not using edition 2018:

extern crate onig;

You can compile simple regular expressions with Regex::new, check if the pattern matches an entire &str with Regex::is_match and find matches within a &str with Regex::find. The onig crate also supplies more powerful versions of these methods which expose the wide range of options Oniguruma provides.

use onig::*;

let regex = Regex::new("e(l+)").unwrap();
for (i, pos) in regex.captures("hello").unwrap().iter_pos().enumerate() {
    match pos {
         Some((beg, end)) =>
             println!("Group {} captured in position {}:{}", i, beg, end),
         None =>
             println!("Group {} is not captured", i)
    }
}

Linking

If a version of Oniguruma can be found by pkg-config then that will be used. If not then Oniguruma will be compiled from source and linked to the onig-sys crate.

By default rust-onig will be statically linked to libonig. If you would rather that dynamic linking is used then the environment variables RUSTONIG_STATIC_LIBONIG and RUSTONIG_DYNAMIC_LIBONIG can be set. On *nix:

$ RUSTONIG_DYNAMIC_LIBONING=1 cargo build

Or Windows:

> set RUSTONIG_DYNAMIC_LIBONIG=1
> cargo build

Build errors caused by libclang/llvm

By default onig uses bindgen to generate bindings for libonig. If you plan to only use the bundled version of libonig, you can make compilation faster and more reliable by disabling the default generate feature:

[dependencies]
onig = { version = "6", default-features = false }

Debugging

Sometimes it's useful to debug how Oniguruma parses, compiles, optimizes or executes a particular pattern.

When activating the print-debug feature for this crate, Oniguruma is compiled with debugging. Note that it's a compile-time setting, so you also need to make rust-onig not use the system Oniguruma by using RUSTONIG_SYSTEM_LIBONIG.

With all that combined, here's an example command to debug the pattern a|b:

RUSTONIG_SYSTEM_LIBONIG=0 cargo run --features print-debug --example capturedump 'a|b'

Supported Rust Versions

Rust Onig supports Rust 1.40.0 or later for Windows, Linux, and macOS. If the minimum supported rust version is changed then the minor version number will be increased. That is v6.1.x should always compile with the same version of the compiler.

Rust-Onig is Open Source

The contents of this repository are distributed under the MIT license. See LICENSE for more details. If you'd like to contribute take a look at our open easy issues.

Dependencies