minor update

SchrodingerZhu · Jul 25, 2023 · 4e87b65 · 4e87b65
1 parent 6386241
commit 4e87b65
Show file tree

Hide file tree

Showing 11 changed files with 67 additions and 42 deletions.
diff --git a/pag-parser/src/frontend/mod.rs b/pag-parser/src/frontend/mod.rs
@@ -493,7 +493,9 @@ mod test {
         dbg!(size_of::<NormalForm>());
         let pairs = GrammarParser::parse(Rule::grammar, TEST).unwrap();
         let tree = parse_surface_syntax(pairs, &PRATT_PARSER, TEST).unwrap();
-        let Grammar { lexer, parser } = &tree.node else { unreachable!() };
+        let Grammar { lexer, parser } = &tree.node else {
+            unreachable!()
+        };
 
         println!("\n---------< construct lexer database >----------");
         let database = construct_lexer_database(lexer).unwrap();

diff --git a/pag-parser/src/frontend/syntax.rs b/pag-parser/src/frontend/syntax.rs
@@ -71,7 +71,7 @@ pub fn construct_parser<'src, 'arena>(
     };
     let mut errs = Vec::new();
     for rule in rules {
-        let ParserRuleDef { active, name, expr, } = &rule.node else {
+        let ParserRuleDef { active, name, expr } = &rule.node else {
             unreachable_branch!("parser should only contain rule definitions")
         };
         match construct_core_syntax_tree(&parser, expr) {

diff --git a/pag-parser/src/fusion.rs b/pag-parser/src/fusion.rs
@@ -199,7 +199,9 @@ fn generate_children<'src>(
         .iter()
         .filter(|x| !matches!(x, NormalForm::Empty(..)))
         .map(|nf| {
-            let NormalForm::Sequence { nonterminals, .. } = nf else { unreachable!() };
+            let NormalForm::Sequence { nonterminals, .. } = nf else {
+                unreachable!()
+            };
 
             let mut add_continue = false;
             let mut actions = Vec::new();

diff --git a/pag-parser/src/nf.rs b/pag-parser/src/nf.rs
@@ -297,7 +297,10 @@ pub fn merge_inactive_rules<'src, 'nf>(
                 let NormalForm::Sequence {
                     terminal,
                     nonterminals,
-                } = j else { continue };
+                } = j
+                else {
+                    continue;
+                };
                 if nonterminals.contains(&Action::Subroutine(tag)) {
                     *j = &*arena.alloc(NormalForm::Sequence {
                         terminal: *terminal,
@@ -328,9 +331,13 @@ pub fn remove_unreachable_rules<'src>(nfs: &mut NormalForms<'src, '_>, parser: &
             return;
         }
         visited.insert(current);
-        let Some(tag) = nfs.entries.get(&current) else { return };
+        let Some(tag) = nfs.entries.get(&current) else {
+            return;
+        };
         for i in tag {
-            let NormalForm::Sequence { nonterminals, .. } = i else { continue };
+            let NormalForm::Sequence { nonterminals, .. } = i else {
+                continue;
+            };
             for i in nonterminals {
                 let Action::Subroutine(x) = i else { continue };
                 dfs(nfs, *x, visited);

diff --git a/pag-parser/src/type_system/fixpoint.rs b/pag-parser/src/type_system/fixpoint.rs
@@ -39,7 +39,9 @@ fn find_neighbors(
         Term::Fix(_, expr) => find_neighbors(expr, neighbors, sym_to_id),
         Term::ParserRef(symbol) => {
             // unexisted IDs refer to implicit fixpoints
-            let Some(&id) = sym_to_id.get(symbol) else { return };
+            let Some(&id) = sym_to_id.get(symbol) else {
+                return;
+            };
             neighbors.push(id);
         }
         _ => {}

diff --git a/pag-parser/src/utilities.rs b/pag-parser/src/utilities.rs
@@ -43,7 +43,9 @@ fn is_ascii_ident_head(x: &u8) -> bool {
 }
 
 fn is_ascii_ident(s: &str) -> bool {
-    let [x, xs@..] = s.as_bytes() else { return false };
+    let [x, xs @ ..] = s.as_bytes() else {
+        return false;
+    };
     is_ascii_ident_head(x) && xs.iter().all(is_ascii_ident_body)
 }
 

diff --git a/pag-parser2/Cargo.toml b/pag-parser2/Cargo.toml
@@ -23,5 +23,5 @@ authors.workspace = true
 readme.workspace = true
 
 [dependencies]
-syn = "2.0.27"
-quote = "1.0.9"
+syn = { version = "2.0.27", features = ["full"] }
+quote = "1.0.9"
diff --git a/pag-parser2/src/frontend/ast.rs b/pag-parser2/src/frontend/ast.rs
@@ -10,8 +10,8 @@ use std::collections::HashMap;
 
 pub struct Ast {
     pub entry: syn::Ident,
-    pub skip: Option<LexerTree>,
-    pub lexer_map: HashMap<syn::Ident, LexerTree>,
+    pub skip: Option<LexerExpr>,
+    pub lexer_map: HashMap<syn::Ident, LexerExpr>,
     pub parser_map: HashMap<syn::Ident, ParserDef>,
 }
 
@@ -21,18 +21,18 @@ pub struct ParserDef {
 }
 
 pub struct ParserRule {
-    pub bindings: Vec<ParserBinding>,
+    pub vars: Vec<VarBinding>,
     pub action: Option<syn::Block>,
 }
 
-pub struct ParserBinding {
+pub struct VarBinding {
     pub name: Option<syn::Ident>,
     pub ty: Option<syn::Type>,
-    pub tree: ParserTree,
+    pub expr: ParserExpr,
 }
 
-// TODO: how to express "bottom" & "empty"?
-pub enum LexerTree {
+// TODO: how to express "bottom" & "any"?
+pub enum LexerExpr {
     Alt(Vec<Self>),
     Seq(Vec<Self>),
     And(Vec<Self>),
@@ -46,7 +46,7 @@ pub enum LexerTree {
 }
 
 // TODO: how to express "select" & "ignore"?
-pub enum ParserTree {
+pub enum ParserExpr {
     Seq(Vec<Self>),
     Star(Box<Self>),
     Plus(Box<Self>),

diff --git a/pag-parser2/src/frontend/parse.rs b/pag-parser2/src/frontend/parse.rs
@@ -9,7 +9,6 @@
 use super::ast::*;
 
 use syn::parse::{Parse, ParseStream};
-use syn::punctuated::Punctuated;
 use syn::{parse_quote, Token};
 
 use std::collections::HashMap;
@@ -50,7 +49,7 @@ impl Parse for Ast {
                     }
                     "skip" => {
                         input.parse::<Token![=]>()?;
-                        skip = Some(input.parse::<LexerTree>()?);
+                        skip = Some(input.parse::<LexerExpr>()?);
                     }
                     _ => return Err(syn::Error::new(ident.span(), "invalid keyword")),
                 }
@@ -60,7 +59,7 @@ impl Parse for Ast {
                 match ident_kind(&ident) {
                     IdentKind::LexerName => {
                         input.parse::<Token![=]>()?;
-                        lexer_map.insert(ident, input.parse::<LexerTree>()?);
+                        lexer_map.insert(ident, input.parse::<LexerExpr>()?);
                     }
                     IdentKind::ParserName => {
                         parser_map.insert(ident, input.parse::<ParserDef>()?);
@@ -90,19 +89,14 @@ impl Parse for ParserDef {
 
         input.parse::<Token![=]>()?;
 
-        // let mut rules = Vec::new();
-        // loop {
-        //     rules.push(input.parse::<ParserRule>()?);
-        //     if !input.peek(Token![|]) {
-        //         break;
-        //     }
-        //     input.parse::<Token![|]>();
-        // }
-
-        // TODO: check whether this is in-place
-        let rules = Punctuated::<ParserRule, Token![|]>::parse_separated_nonempty(input)?
-            .into_iter()
-            .collect();
+        let mut rules = Vec::new();
+        loop {
+            rules.push(input.parse::<ParserRule>()?);
+            if !input.peek(Token![|]) {
+                break;
+            }
+            input.parse::<Token![|]>()?;
+        }
 
         Ok(Self { ty, rules })
     }
@@ -111,21 +105,21 @@ impl Parse for ParserDef {
 impl Parse for ParserRule {
     // (ParserBinding)+ syn::Block?
     fn parse(input: ParseStream) -> syn::Result<Self> {
-        let mut bindings = Vec::new();
+        let mut vars = Vec::new();
         while !input.peek(syn::token::Brace) && !input.peek(Token![|]) && !input.peek(Token![;]) {
-            bindings.push(input.parse::<ParserBinding>()?);
+            vars.push(input.parse::<VarBinding>()?);
         }
 
         let mut action = None;
         if input.peek(syn::token::Brace) {
             action = Some(input.parse::<syn::Block>()?);
         }
 
-        Ok(Self { bindings, action })
+        Ok(Self { vars, action })
     }
 }
 
-impl Parse for ParserBinding {
+impl Parse for VarBinding {
     // ("$" syn::Ident ("<" syn::Type ">")? ":")? ParserTree
     fn parse(input: ParseStream) -> syn::Result<Self> {
         let mut name = None;
@@ -144,20 +138,20 @@ impl Parse for ParserBinding {
             input.parse::<Token![:]>()?;
         }
 
-        let tree = input.parse::<ParserTree>()?;
+        let expr = input.parse::<ParserExpr>()?;
 
-        Ok(Self { name, ty, tree })
+        Ok(Self { name, ty, expr })
     }
 }
 
-impl Parse for LexerTree {
+impl Parse for LexerExpr {
     // pratt parsing
     fn parse(_input: ParseStream) -> syn::Result<Self> {
         todo!()
     }
 }
 
-impl Parse for ParserTree {
+impl Parse for ParserExpr {
     // pratt parsing
     fn parse(_input: ParseStream) -> syn::Result<Self> {
         todo!()

diff --git a/pag-parser2/src/nf/mod.rs b/pag-parser2/src/nf/mod.rs
@@ -1,3 +1,11 @@
+// Copyright (c) 2023 Paguroidea Developers
+//
+// Licensed under the Apache License, Version 2.0
+// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT
+// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. All files in the project carrying such notice may not be copied,
+// modified, or distributed except according to those terms.
+
 use quote::format_ident;
 use syn::Ident;
 mod semact;

diff --git a/pag-parser2/src/nf/semact.rs b/pag-parser2/src/nf/semact.rs
@@ -1,3 +1,11 @@
+// Copyright (c) 2023 Paguroidea Developers
+//
+// Licensed under the Apache License, Version 2.0
+// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT
+// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. All files in the project carrying such notice may not be copied,
+// modified, or distributed except according to those terms.
+
 use std::collections::HashMap;
 
 use quote::format_ident;