chore: Rebase lu-zero's code onto winnow-rs/main

There are three repositories (and three branches):
* winnow-rs/winnow:main
* ssmendon/winnow:ssmendon-pratt-pr (PR winnow-rs#804)
* lu-zero/winnow:ssmendon-pratt-pr (newest changes)

I'm starting this branch by rebasing lu-zero's work
on top of winnow-rs's main. This is just a rote copy
of the files explicitly changed (to keep the diff tidy).

Co-authored-by: Igor <[email protected]>
Co-authored-by: Luca Barbato <[email protected]>

Author: 3 people

Cargo.toml

@@ -161,6 +161,10 @@ name = "arithmetic"
 test = true
 required-features = ["alloc"]
 
+[[example]]
+name = "c_expression"
+required-features = ["std"]
+
 [[example]]
 name = "css"
 test = true
@@ -211,6 +215,12 @@ path = "examples/arithmetic/bench.rs"
 harness = false
 required-features = ["alloc"]
 
+[[bench]]
+name = "c_expression"
+path = "examples/c_expression/bench.rs"
+harness = false
+required-features = ["std"]
+
 [[bench]]
 name = "contains_token"
 harness = false

examples/c_expression/bench.rs

@@ -0,0 +1,16 @@
+mod parser;
+
+use criterion::black_box;
+use winnow::prelude::*;
+
+fn pratt(c: &mut criterion::Criterion) {
+    let i =
+        "a = 2*-2 / ( &**foo.a->p! -+1) + 3^1 / 4 == 1 * (2 - 7 + 567 *12 /2) + 3*(1+2*( 45 /2))";
+    parser::pratt_parser.parse(i).expect("should parse");
+    c.bench_function("pratt_parser", |b| {
+        b.iter(|| black_box(parser::pratt_parser.parse(i).unwrap()));
+    });
+}
+
+criterion::criterion_group!(benches, pratt);
+criterion::criterion_main!(benches);

examples/c_expression/main.rs

@@ -0,0 +1,44 @@
+use winnow::prelude::*;
+
+mod parser;
+
+fn main() -> Result<(), lexopt::Error> {
+    let args = Args::parse()?;
+
+    let input = args.input.as_deref().unwrap_or("1 + 1");
+    match parser::pratt_parser.parse(input) {
+        Ok(result) => {
+            println!("{result}");
+        }
+        Err(err) => {
+            println!("FAILED");
+            println!("{err}");
+        }
+    }
+
+    Ok(())
+}
+
+#[derive(Default)]
+struct Args {
+    input: Option<String>,
+}
+
+impl Args {
+    fn parse() -> Result<Self, lexopt::Error> {
+        use lexopt::prelude::*;
+
+        let mut res = Args::default();
+
+        let mut args = lexopt::Parser::from_env();
+        while let Some(arg) = args.next()? {
+            match arg {
+                Value(input) => {
+                    res.input = Some(input.string()?);
+                }
+                _ => return Err(arg.unexpected()),
+            }
+        }
+        Ok(res)
+    }
+}