Review syntax and add http header test for benchmarks

Author: d-plaindoux

lang/v0/macro/Cargo.toml

@@ -16,6 +16,10 @@ proc-macro2 = "1.0.93"
 [dev-dependencies]
 bencher = "0.1.5"
 
+[[bench]]
+name = "http"
+harness = false
+
 [[bench]]
 name = "json"
 harness = false

lang/v0/macro/benches/data/request.http

@@ -0,0 +1,11 @@
+GET /wp-content/uploads/2010/03/hello-kitty-darth-vader-pink.jpg HTTP/1.1
+Host: www.kittyhell.com
+User-Agent: Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.6; ja-JP-mac; rv:1.9.2.3) Gecko/20100401 Firefox/3.6.3 Pathtraq/0.9
+Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
+Accept-Language: ja,en-us;q=0.7,en;q=0.3
+Accept-Encoding: gzip,deflate
+Accept-Charset: Shift_JIS,utf-8;q=0.7,*;q=0.7
+Keep-Alive: 115
+Connection: keep-alive
+Cookie: wp_ozh_wsa_visits=2; wp_ozh_wsa_visit_lasttime=xxxxxxxxxx;__utma=xxxxxxxxx.xxxxxxxxxx.xxxxxxxxxx.xxxxxxxxxx.xxxxxxxxxx.x;__utmz=xxxxxxxxx.xxxxxxxxxx.x.x.utmccn=(referral)|utmcsr=reader.livedoor.com|utmcct=/reader/|utmcmd=referral
+

lang/v0/macro/benches/http.rs

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2019-2025 Didier Plaindoux
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+use bencher::{Bencher, benchmark_group, benchmark_main, black_box};
+use celma_v0_core::parser::and::AndOperation;
+use celma_v0_core::parser::char::{alpha, digit};
+use celma_v0_core::parser::core::eos;
+use celma_v0_core::parser::response::Response::{Reject, Success};
+use celma_v0_core::parser::specs::Parse;
+use celma_v0_core::stream::char_stream::CharStream;
+use celma_v0_core::stream::position::Position;
+use celma_v0_core::stream::specs::Stream;
+use celma_v0_macro::parsec_rules;
+
+parsec_rules!(
+    let http_header = request (header)* EOL -> {}
+    let request = VERB S URI S VERSION EOL -> {}
+    let header = NAME ':' S VALUE EOL -> {}
+);
+
+parsec_rules!(
+    let VERB = ("GET" | "POST" | "PUT" | "DELETE" | "HEAD" | "CONNECT" | "PATCH") -> {}
+    let URI  = ^(' ')+ -> {}
+    let VERSION = "HTTP/" digit+ ('.' digit+)? -> {}
+    let S  = (' ' | '\t')+ -> {}
+    let EOL = ('\r'? '\n') -> {}
+    let NAME = (alpha | '-')+ -> {}
+    let VALUE = ^EOL+ -> {} // Not precise enough
+);
+
+// -------------------------------------------------------------------------------------------------
+// HTTP benchmarks
+// -------------------------------------------------------------------------------------------------
+
+fn http_data(b: &mut Bencher) {
+    let data = include_str!("data/request.http");
+    b.bytes = data.len() as u64;
+    parse(b, data)
+}
+
+fn parse(b: &mut Bencher, buffer: &str) {
+    let stream = CharStream::new_with_position(buffer, <usize>::new());
+
+    b.iter(|| {
+        let response = http_header()
+            .and_left(eos())
+            .parse(black_box(stream.clone()));
+
+        match response {
+            Success(_, _, _) => (),
+            Reject(s, _) => panic!("parse error for {:?} at {:?}", s.next().0, s.position()),
+        }
+    });
+}
+
+benchmark_group!(benches, http_data,);
+
+benchmark_main!(benches);

lang/v1/ast/src/syntax.rs

@@ -38,7 +38,6 @@ pub enum ASTParsec<I> {
     PAtom(I),
     PAtoms(Vec<I>),
     PBind(String, Box<ASTParsec<I>>),
-    PCode(String),
     PMap(Box<ASTParsec<I>>, String),
     PSequence(Box<ASTParsec<I>>, Box<ASTParsec<I>>),
     PChoice(Box<ASTParsec<I>>, Box<ASTParsec<I>>),

lang/v1/normalizer/src/ast.rs

@@ -20,31 +20,32 @@ pub enum ASTGrammar<A> {
     Bottom(),
     Var(String),
     Token(A),
+    TokenChar(char),
     Seq(Box<AST<A>>, Box<AST<A>>),
     Choice(Box<AST<A>>, Box<AST<A>>),
     Rec(String, Box<AST<A>>),
 }
 
 /*
-   PAtom(char),                    // Single char
-   PAtoms(Vec<char>),              // Char sequence
    PBind(String, Box<ASTParsec>),  // Variable
-   PCode(String),                  // Production
-   PMap(Box<ASTParsec>, String),   // Remove?
-   PNot(Box<ASTParsec>),           // ?
-   PCheck(Box<ASTParsec>),         // No capture
+   PMap(Box<ASTParsec>, String),   // Map
+   PNot(Box<ASTParsec>),           // Negation
 
    -- Pre-normalization
 
    PN : ASTParsec -> (string -> ASTParsec) -> string list -> ASTGrammar
 
-                              / Var(n)               if n in l
-   PN[PIdent(n)]gl         = {
-                              \ mu(n,PN[g(n)]g(n::l) otherwise
+                               / Var(n)               if n in l
+   PN[PIdent(n)]gl          = {
+                               \ mu(n,PN[g(n)]g(n::l) otherwise
 
-   PN[PEpsilon()]gl        = Epsilon()
-   PN[PSequence(T1,T2]]gl  = Seq(PN[T1]gl,PN[T2]gl)
-   PN[PChoice(T1,T2)]gl    = Choice(PN[T1]gl,PN[T2]gl)
-   PN[PRepeat(T)]gl        = PN[T]gl | mu(n,Choice(Seq(PN[T]gl,Var(n)),Epsilon()))
-   PN[PTry(T)gl]           = PN[T]gl
+   PN[PAtom(c)]gl           = TokenChar(c)
+   PN[PAtoms([])]gl         = Epsilon()
+   PN[PAtoms(c::l)]gl       = Seq(TokenChar(v),PN[PAtoms(c::l)]gl)
+   PN[PEpsilon()]gl         = Epsilon()
+   PN[PSequence(T1,T2]]gl   = Seq(PN[T1]gl,PN[T2]gl)
+   PN[PChoice(T1,T2)]gl     = Choice(PN[T1]gl,PN[T2]gl)
+   PN[PRepeat(T)]gl         = PN[T]gl | mu(n,Choice(Seq(PN[T]gl,Var(n)),Epsilon()))
+   PN[PTry(T)gl]            = PN[T]gl
+   PN[PCheck(T]gl]          = PN[T]gl
 */

lang/v1/parser/src/parser.rs

@@ -19,8 +19,7 @@ use celma_v0_core::parser::literal::{delimited_char, delimited_string};
 
 use celma_v0_macro::parsec_rules;
 use celma_v1_ast::syntax::ASTParsec::{
-    PAtom, PAtoms, PBind, PCheck, PChoice, PCode, PEpsilon, PIdent, PMap, PNot, PRepeat, PSequence,
-    PTry,
+    PAtom, PAtoms, PBind, PCheck, PChoice, PEpsilon, PIdent, PMap, PNot, PRepeat, PSequence, PTry,
 };
 use celma_v1_ast::syntax::{ASTParsec, ASTParsecRule};
 
@@ -117,14 +116,13 @@ parsec_rules!(
     let additional:{(bool,ASTParsec<char>)} = (skip c='|'? skip p=parsec) -> { (c.is_some(), p) }
 
     let atom:{ASTParsec<char>} = (
-        skip o=('^'|'!'|'#')? skip p=(atom_block|atom_ident|atom_char|atom_string|atom_code) skip
+        skip o=('^'|'!'|'#')? skip p=(atom_block|atom_ident|atom_char|atom_string) skip
     ) -> { mk_atom(o, p) }
 
     let atom_block:{ASTParsec<char>} = ('(' p=parsec? ')') -> { p.unwrap_or_else(PEpsilon) }
     let atom_ident:{ASTParsec<char>} = c=ident -> { PIdent(c) }
     let atom_char:{ASTParsec<char>} = c=delimited_char -> { PAtom(c) }
     let atom_string:{ASTParsec<char>} = c=delimited_string -> { PAtoms(c.chars().collect()) }
-    let atom_code:{ASTParsec<char>} = c=code -> { PCode(c) }
 
     let transform:{String} = (skip "->" skip _=code)
 

lang/v1/parser/tests/parser_tests.rs

@@ -20,11 +20,10 @@ mod parser_tests {
     use celma_v0_core::stream::char_stream::CharStream;
     use celma_v0_core::stream::specs::Len;
     use celma_v1::parser::{
-        atom_char, atom_code, atom_ident, atom_string, code, code_content, kind, parsec, rule,
+        atom_char, atom_ident, atom_string, code, code_content, kind, parsec, rule,
     };
     use celma_v1_ast::syntax::ASTParsec::{
-        PAtom, PAtoms, PBind, PCheck, PChoice, PCode, PEpsilon, PIdent, PNot, PRepeat, PSequence,
-        PTry,
+        PAtom, PAtoms, PBind, PCheck, PChoice, PEpsilon, PIdent, PNot, PRepeat, PSequence, PTry,
     };
     use celma_v1_ast::syntax::ASTParsecRule;
     use celma_v1_ast::syntax::ASTType::{PChar, PUnit};
@@ -46,16 +45,6 @@ mod parser_tests {
         );
     }
 
-    #[test]
-    fn should_parse_atom_code() {
-        let response = atom_code().parse(CharStream::new("{hello()}"));
-
-        assert_eq!(
-            response.fold(|v, _, _| v == PCode(String::from("hello()")), |_, _| false),
-            true
-        );
-    }
-
     #[test]
     fn should_parse_atom_char() {
         let response = atom_char().parse(CharStream::new("'a'"));