Initial commit

src/boolean_algebra/boolean_algebra.pest

@@ -0,0 +1,12 @@
+boolean_algebra = { SOI ~ expression ~ EOI }
+expression = { negatable_term ~ (binop ~ negatable_term)* }
+negatable_term = _{ negated | term }
+negated = ${ negation ~ term }
+term = _{ label | "(" ~ expression ~ ")" }
+
+negation = _{ "!" | "~" }
+binop = @{ or_op | and_op }
+  and_op = _{ "" }
+  or_op =  _{ "+" }
+
+label = @{ ASCII_ALPHA }

src/boolean_algebra/mod.rs

@@ -0,0 +1,2 @@
+pub mod parser;
+pub mod logic;

src/boolean_algebra/parser.rs

@@ -0,0 +1,84 @@
+use crate::traits::{parser::Pair, self};
+
+use super::super::traits::graphvizable::Graphvizable;
+
+pub use pest::iterators::Pair as BAPair;
+use pest::Parser;
+use pest_derive::Parser;
+
+#[derive(Parser)]
+#[grammar = "boolean_algebra/boolean_algebra.pest"]
+pub struct BAParser;
+pub type BARule = Rule;
+
+impl Graphvizable for BAPair<'_, BARule> {
+    fn print_graphviz_diagram(&self) {
+        let mut i: u64 = 0;
+        println!("digraph parse_tree {{");
+        println!("ratio = fill;");
+        println!("node [style=filled];");
+        _print_graphviz_syntax_tree(self, &mut i);
+        println!("}}");
+    }
+
+    fn graphviz_diagram(&self) -> String {
+        todo!()
+    }
+}
+
+impl traits::parser:: Parser for BAParser {
+    fn parse(input: &mut String) -> Pair {
+        input.retain(|c| !c.is_whitespace());
+        let result = <BAParser as Parser<BARule>>::parse(BARule::boolean_algebra, input.as_str())
+            .expect("UNSUCCESSFUL PARSE")
+            .next()
+            .unwrap();
+        Pair::BAPair(result)
+    }
+}
+
+// pub fn format_graphviz_syntax_tree(root: Pair<BARule>, output: &mut str) {
+//   let mut i: u64 = 0;
+//   str += ("digraph parse_tree {{");
+//   str += ("ratio = fill;");
+//   str += ("node [style=filled];");
+//   _print_graphviz_syntax_tree(root, &mut i);
+//   str += ("}}");
+// }
+
+fn _print_g_node(pair: &BAPair<BARule>, node_name: &str) {
+    if pair.as_rule() == BARule::binop {
+        println!(
+            "  {} [label=\"{}\", color=\"brown1\"];",
+            node_name,
+            pair.as_str()
+        );
+    } else if pair.as_rule() == BARule::label {
+        println!(
+            "  {} [label=\"{}\", color=\"lightgoldenrod1\"];",
+            node_name,
+            pair.as_str()
+        );
+    } else if pair.as_rule() == BARule::negated {
+        println!("  {} [label=\"~\", color=\"orange\"];", node_name);
+    } else if pair.as_rule() == BARule::expression {
+        println!(
+            "  {} [label=\"{}\", color=\"chartreuse2\"];",
+            node_name,
+            pair.as_str()
+        );
+    } else {
+        println!("  {} [label=\"{:?}\"];", node_name, pair.as_rule());
+    }
+}
+
+fn _print_graphviz_syntax_tree(pair: &BAPair<BARule>, i: &mut u64) {
+    let node_name = format!("n{}", *i);
+    _print_g_node(&pair, &node_name);
+
+    for inner_pair in pair.clone().into_inner() {
+        *i += 1;
+        println!("  {} -> n{};", node_name, *i);
+        _print_graphviz_syntax_tree(&inner_pair, i);
+    }
+}