| /external/rust/crates/regex/ |
| D | CHANGELOG.md | 1 1.7.3 (2023-03-24)
3 This is a small release that fixes a bug in `Regex::shortest_match_at` that
4 could cause it to panic, even when the offset given is valid.
8 * [BUG #969](https://github.com/rust-lang/regex/issues/969):
9 Fix a bug in how the reverse DFA was called for `Regex::shortest_match_at`.
12 1.7.2 (2023-03-21)
18 * [BUG #967](https://github.com/rust-lang/regex/issues/967):
19 Fix "no stack overflow" test which can fail due to the small stack size.
22 1.7.1 (2023-01-09)
24 This release was done principally to try and fix the doc.rs rendering for the
[all …]
|
| D | README.md | 1 regex chapter
4 syntax is similar to Perl-style regular expressions, but lacks a few features
6 linear time with respect to the size of the regular expression and search text.
10 [](https://github.com/rus…
11 [](https://crates.io/crates/regex)
12 [](https://github.com/rust…
16 [Module documentation with examples](https://docs.rs/regex).
22 [`Regex` type](https://docs.rs/regex/*/regex/struct.Regex.html).
26 To bring this crate into your repository, either add `regex` to your
27 `Cargo.toml`, or run `cargo add regex`.
[all …]
|
| D | PERFORMANCE.md | 1 Your friendly guide to understanding the performance characteristics of this
5 can be found here: https://docs.rs/regex
9 One of the design goals of this crate is to provide worst case linear time
10 behavior with respect to the text searched using finite state automata. This
12 regex implementations, which typically use backtracking which has worst case
28 or places where the current regex engine isn't quite optimal. This guide will
29 detail those cases and provide guidance on how to avoid them, among other
34 **Advice**: Use `lazy_static` to amortize the cost of `Regex` compilation.
40 microseconds to a few dozen milliseconds. Yes, milliseconds. Unicode character
42 the time of writing, for example, `\pL{100}` takes around 44ms to compile. This
[all …]
|
| D | Cargo.toml.orig | 2 name = "regex"
5 license = "MIT OR Apache-2.0"
7 repository = "https://github.com/rust-lang/regex"
8 documentation = "https://docs.rs/regex"
9 homepage = "https://github.com/rust-lang/regex"
14 categories = ["text-processing"]
21 "bench", "regex-capi", "regex-debug", "regex-syntax",
27 # Doc tests fail when some features aren't present. The easiest way to work
28 # around this is to disable automatic doc testing, but explicitly test them
29 # with `cargo test --doc`.
[all …]
|
| D | HACKING.md | 1 Your friendly guide to hacking and navigating the regex library.
14 finite automata. In particular, a design goal is to make searching linear
15 with respect to both the regular expression and the text being searched.
17 implementation of the Pike VM (similar to Thompson's construction, but supports
19 --- This library contains such an implementation in src/pikevm.rs.
24 same epsilon transitions over and over again. We can employ one trick to
26 expression and execute specialized code to quickly find matches of those
28 search, and instead only executed when a prefix is found. The code to find
29 prefixes is in the regex-syntax crate (in this repository). The code to search
31 we fall back to an Aho-Corasick DFA using the aho-corasick crate. For one
[all …]
|
| /external/rust/crates/regex/tests/ |
| D | test_default.rs | 3 use regex;
5 // Due to macro scoping rules, this definition only applies for the modules
6 // defined below. Effectively, it allows us to use the same tests for both
9 // This is also used to test the various matching engines. This one exercises
11 // regex and the input. Other dynamic tests explicitly set the engine to use.
14 use regex::Regex;
15 Regex::new($re)
19 macro_rules! regex { macro
27 use regex::RegexSet;
59 #[cfg(feature = "unicode-perl")]
[all …]
|
| /external/jazzer-api/sanitizers/src/main/java/com/code_intelligence/jazzer/sanitizers/ |
| D | RegexRoadblocks.java | 7 // http://www.apache.org/licenses/LICENSE-2.0
9 // Unless required by applicable law or agreed to in writing, software
28 import java.util.regex.Matcher;
29 import java.util.regex.Pattern;
33 * The hooks in this class extend the reach of Jazzer's string compare instrumentation to literals
39 * to match against and an index into the sequence. With a hook on this method for every subclass of
44 // The number of characters preceding one that failed a character predicate to include in the
60 // Weakly map CharPredicate instances to characters that satisfy the predicate. Since
68 @MethodHook(type = HookType.AFTER, targetClassName = "java.util.regex.Pattern$Node",
70 targetMethodDescriptor = "(Ljava/util/regex/Matcher;ILjava/lang/CharSequence;)Z",
[all …]
|
| /external/truth/core/src/main/java/com/google/common/truth/ |
| D | StringSubject.java | 8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
24 import java.util.regex.Matcher;
25 import java.util.regex.Pattern;
38 * Constructor for use by subclasses. If you want to create an instance of this class itself, call
61 /** Fails if the string is not equal to the zero-length "empty string." */
66 failWithActual(simpleFact("expected to be empty")); in isEmpty()
70 /** Fails if the string is equal to the zero-length "empty string." */
73 failWithActual(simpleFact("expected a non-empty string")); in isNotEmpty()
75 failWithoutActual(simpleFact("expected not to be empty")); in isNotEmpty()
[all …]
|
| /external/apache-commons-lang/src/main/java/org/apache/commons/lang3/ |
| D | RegExUtils.java | 2 * Licensed to the Apache Software Foundation (ASF) under one or more
5 * The ASF licenses this file to You under the Apache License, Version 2.0
9 * http://www.apache.org/licenses/LICENSE-2.0
11 * Unless required by applicable law or agreed to in writing, software
19 import java.util.regex.Pattern;
22 * Helpers to process Strings using regular expressions.
23 * @see java.util.regex.Pattern
31 * This method is a {@code null} safe equivalent to:
36 * <p>A {@code null} reference passed to this method is a no-op.</p>
48 * StringUtils.removeAll("ABCabc123abc", Pattern.compile("[a-z]")) = "ABC123"
[all …]
|
| /external/selinux/libselinux/src/ |
| D | regex.c | 7 #include "regex.h"
19 /* If the compiler doesn't define __BYTE_ORDER__, try to use the C
23 #error Neither __BYTE_ORDER__ nor __BYTE_ORDER defined. Unable to determine endianness.
34 static int match_data_key_initialized = -1;
55 "%zu-%zu-%s", sizeof(void *), in regex_arch_string()
67 pcre2_code *regex; /* compiled regular expression */ member
70 int regex_prepare_data(struct regex_data **regex, char const *pattern_string, in regex_prepare_data() argument
75 *regex = regex_data_create(); in regex_prepare_data()
76 if (!(*regex)) in regex_prepare_data()
77 return -1; in regex_prepare_data()
[all …]
|
| /external/rust/crates/bindgen-cli/ |
| D | options.rs | 14 fn rust_target_help() -> String { in rust_target_help()
16 "Version of the Rust compiler to target. Valid options are: {:?}. Defaults to {}.", in rust_target_help()
24 ) -> Result<CodegenConfig, Error> { in parse_codegen_config()
46 fn parse_rustfmt_config_path(path_str: &str) -> Result<PathBuf, Error> { in parse_rustfmt_config_path()
52 "--rustfmt-configuration-file needs to be an absolute path!", in parse_rustfmt_config_path()
59 "--rustfmt-configuration-file contains non-valid UTF8 characters.", in parse_rustfmt_config_path()
66 fn parse_abi_override(abi_override: &str) -> Result<(Abi, String), Error> { in parse_abi_override()
67 let (regex, abi_str) = abi_override in parse_abi_override()
75 Ok((abi, regex.to_owned())) in parse_abi_override()
80 ) -> Result<(Vec<String>, String), Error> { in parse_custom_derive()
[all …]
|
| /external/rust/crates/regex-automata/src/ |
| D | lib.rs | 11 * A [`Regex`](struct.Regex.html) provides a way to search for matches of a
15 compilation options for a regex.
16 * A [`DenseDFA`](enum.DenseDFA.html) provides low level access to a DFA that
23 [serialization to raw bytes](enum.DenseDFA.html#method.to_bytes_little_endian)
27 # Example: basic regex searching
29 This example shows how to compile a regex using the default configuration
30 and then use it to find matches in a byte string:
33 use regex_automata::Regex;
35 let re = Regex::new(r"[0-9]{4}-[0-9]{2}-[0-9]{2}").unwrap();
36 let text = b"2018-12-24 2016-10-08";
[all …]
|
| D | regex.rs | 17 /// match. Thus, in order to find the bounds of any given match, a forward
21 /// The type of the DFA used by a `Regex` corresponds to the `D` type
27 /// By default, a regex's DFA type parameter is set to
28 /// `DenseDFA<Vec<usize>, usize>`. For most in-memory work loads, this is the
33 /// Since a `Regex` is generic over the `DFA` trait, it can be used with any
35 /// enough to build corresponding sparse DFAs, and then build a regex from
39 /// use regex_automata::Regex;
41 /// # fn example() -> Result<(), regex_automata::Error> {
42 /// // First, build a regex that uses dense DFAs.
43 /// let dense_re = Regex::new("foo[0-9]+")?;
[all …]
|
| /external/rust/crates/which/src/ |
| D | lib.rs | 6 //! To find which rustc executable binary is using:
23 #[cfg(feature = "regex")]
39 /// If given a relative path, returns an absolute path to the file if
56 pub fn which<T: AsRef<OsStr>>(binary_name: T) -> Result<path::PathBuf> { in which()
80 pub fn which_global<T: AsRef<OsStr>>(binary_name: T) -> Result<path::PathBuf> { in which_global()
84 /// Find all binaries with `binary_name` using `cwd` to resolve relative paths.
85 pub fn which_all<T: AsRef<OsStr>>(binary_name: T) -> Result<impl Iterator<Item = path::PathBuf>> { in which_all()
98 ) -> Result<impl Iterator<Item = path::PathBuf>> { in which_all_global()
113 /// Only available when feature `regex` is enabled.
117 /// * `regex` - A regular expression to match binaries with
[all …]
|
| /external/rust/crates/regex-syntax/ |
| D | README.md | 1 regex-syntax
5 [](https://github.com/rus…
6 [](https://crates.io/crates/regex-syn…
7 [](https://github.com/rust…
12 https://docs.rs/regex-syntax
19 expressions back to their concrete syntax while mostly preserving its original
21 expression that is amenable to analysis and compilation into byte codes or
23 structure of the regular expression. While an `Hir` can be converted back to
24 its equivalent concrete syntax, the result is unlikely to resemble the original
30 This example shows how to parse a pattern string into its HIR:
[all …]
|
| /external/truth/extensions/re2j/src/main/java/com/google/common/truth/extensions/re2j/ |
| D | Re2jSubjects.java | 8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
29 * <p>Truth natively provides subjects for dealing with {@code java.util.regex} based regular
30 * expressions. This class is intended to provide {@code com.google.re2j} analogues to those
35 * Returns a subject factory for {@link String} subjects which you can use to assert things about
38 * <p>This subject does not replace Truth's built-in {@link com.google.common.truth.StringSubject}
39 * but instead provides only the methods needed to deal with regular expressions.
48 * Subject for {@link String} subjects which you can use to assert things about {@link
75 /** Fails if the string does not match the given regex. */
76 public void matches(String regex) { in matches() argument
[all …]
|
| /external/rust/crates/regex-automata/ |
| D | README.md | 1 regex-automata
8 …status](https://github.com/BurntSushi/regex-automata/workflows/ci/badge.svg)](https://github.com/B…
9 [](https://crates.io/crates/regex-a…
10 
12 Dual-licensed under MIT or the [UNLICENSE](https://unlicense.org/).
17 https://docs.rs/regex-automata
22 Add this to your `Cargo.toml`:
26 regex-automata = "0.1"
29 and this to your crate root (if you're using Rust 2015):
36 ### Example: basic regex searching
[all …]
|
| /external/rust/crates/regex/src/ |
| D | lib.rs | 3 expressions. Its syntax is similar to Perl-style regular expressions, but lacks
5 execute in linear time with respect to the size of the regular expression and
13 documentation for the [`Regex`](struct.Regex.html) type.
17 This crate is [on crates.io](https://crates.io/crates/regex) and can be
18 used by adding `regex` to your dependencies in your project's `Cargo.toml`.
22 regex = "1"
28 expression and then using it to search, split or replace text. For example,
29 to confirm that some text resembles a date:
32 use regex::Regex;
33 let re = Regex::new(r"^\d{4}-\d{2}-\d{2}$").unwrap();
[all …]
|
| /external/llvm/utils/unittest/googletest/src/ |
| D | gtest-port.cc | 15 // contributors may be used to endorse or promote products derived from
20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
32 #include "gtest/internal/gtest-port.h"
54 #include "gtest/gtest-spi.h"
55 #include "gtest/gtest-message.h"
56 #include "gtest/internal/gtest-internal.h"
57 #include "gtest/internal/gtest-string.h"
60 // implementation. It must come before gtest-internal-inl.h is
61 // included, or there will be a compiler error. This trick is to
[all …]
|
| /external/rust/crates/quiche/deps/boringssl/src/third_party/googletest/include/gtest/ |
| D | gtest-death-test.h | 15 // contributors may be used to endorse or promote products derived from
20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
34 // #included by gtest.h so a user doesn't need to include this
41 #include "gtest/internal/gtest-death-test-internal.h"
46 // meaning that the death test child process will re-execute the test binary
58 // Valgrind heap checkers may need this to modify their behavior in death
71 // thread. This is because it's safe to fork() or clone() only
74 // 2. The parent process clone()s a sub-process and runs the death
75 // test in it; the sub-process exits with code 0 at the end of the
[all …]
|
| /external/llvm/include/llvm/Support/ |
| D | Regex.h | 1 //===-- Regex.h - Regular Expression matcher implementation -*- C++ -*-----===//
8 //===----------------------------------------------------------------------===//
12 // to support backreferences in matches.
15 //===----------------------------------------------------------------------===//
28 class Regex {
34 /// Compile for newline-sensitive matching. With this flag '[^' bracket
36 /// null string after any newline in the string in addition to its normal
38 /// newline in the string in addition to its normal function.
41 /// assumed. Pass this flag to turn on basic regular expressions (BRE)
46 /// Compiles the given regular expression \p Regex.
[all …]
|
| /external/swiftshader/third_party/llvm-16.0/llvm/include/llvm/Support/ |
| D | Regex.h | 1 //===-- Regex.h - Regular Expression matcher implementation -*- C++ -*-----===//
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
11 // to support backreferences in matches.
14 //===----------------------------------------------------------------------===//
28 class Regex {
34 /// Compile for newline-sensitive matching. With this flag '[^' bracket
36 /// null string after any newline in the string in addition to its normal
38 /// newline in the string in addition to its normal function.
41 /// assumed. Pass this flag to turn on basic regular expressions (BRE)
[all …]
|
| /external/llvm/utils/unittest/googletest/include/gtest/ |
| D | gtest-death-test.h | 15 // contributors may be used to endorse or promote products derived from
20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
35 // #included by gtest.h so a user doesn't need to include this
41 #include "gtest/internal/gtest-death-test-internal.h"
46 // meaning that the death test child process will re-execute the test binary
60 // thread. This is because it's safe to fork() or clone() only
63 // 2. The parent process clone()s a sub-process and runs the death
64 // test in it; the sub-process exits with code 0 at the end of the
67 // 3. The parent process waits for the sub-process to terminate.
[all …]
|
| /external/swiftshader/third_party/llvm-subzero/include/llvm/Support/ |
| D | Regex.h | 1 //===-- Regex.h - Regular Expression matcher implementation -*- C++ -*-----===//
8 //===----------------------------------------------------------------------===//
12 // to support backreferences in matches.
15 //===----------------------------------------------------------------------===//
28 class Regex {
34 /// Compile for newline-sensitive matching. With this flag '[^' bracket
36 /// null string after any newline in the string in addition to its normal
38 /// newline in the string in addition to its normal function.
41 /// assumed. Pass this flag to turn on basic regular expressions (BRE)
46 Regex();
[all …]
|
| /external/swiftshader/third_party/llvm-10.0/llvm/include/llvm/Support/ |
| D | Regex.h | 1 //===-- Regex.h - Regular Expression matcher implementation -*- C++ -*-----===//
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
11 // to support backreferences in matches.
14 //===----------------------------------------------------------------------===//
27 class Regex {
33 /// Compile for newline-sensitive matching. With this flag '[^' bracket
35 /// null string after any newline in the string in addition to its normal
37 /// newline in the string in addition to its normal function.
40 /// assumed. Pass this flag to turn on basic regular expressions (BRE)
[all …]
|