move expressions to file

src/parser.rs

@@ -1,4 +1,5 @@
 pub mod error;
+pub mod expression;
 mod literals;
 pub mod module;
 pub mod proc;
@@ -23,6 +24,7 @@ pub type IErr<I> = GreedyError<I, ErrorKind>;
 // custom IResult type for VerboseError
 pub type IResult<I, O, E = IErr<I>> = nom::IResult<I, O, E>;
 
+pub use crate::parser::expression::{expression, Call, Expression, Operation};
 pub use crate::parser::module::{module, Module, ModuleItem, PortDirection};
 use crate::parser::tokens::{token, TokenKind as tk, TokenSpan};
 
@@ -76,35 +78,14 @@ pub struct Assign<'a> {
     pub expr: Expression<'a>,
 }
 
-#[derive(Debug, Clone)]
-pub enum Operation<'a> {
-    And {
-        a: Expression<'a>,
-        b: Expression<'a>,
-    },
-    Or {
-        a: Expression<'a>,
-        b: Expression<'a>,
-    },
-    Xor {
-        a: Expression<'a>,
-        b: Expression<'a>,
-    },
-    Not(Expression<'a>),
-}
-
-#[derive(Debug, Clone)]
-pub struct Call<'a> {
-    pub name: Span<'a>,
-    pub args: Vec<Expression<'a>>,
-}
-
-#[derive(Debug, Clone)]
-pub enum Expression<'a> {
-    Ident(&'a str),
-    Literal(u64),
-    Call(Box<Call<'a>>),
-    Operation(Box<Operation<'a>>),
+fn assign_statement(input: TokenSpan) -> IResult<TokenSpan, Assign> {
+    map(
+        separated_pair(token(tk::Ident), token(tk::EqAssign), expression),
+        |(lhs, expr)| Assign {
+            lhs: (*lhs.span().fragment()),
+            expr,
+        },
+    )(input)
 }
 
 // TODO: reallow assignments
@@ -122,74 +103,6 @@ fn declaration(i: TokenSpan) -> IResult<TokenSpan, NetDecl> {
     )(i)
 }
 
-fn operation(input: TokenSpan) -> IResult<TokenSpan, Operation> {
-    // temporarily given up on before I learn the shunting yard algorithm
-    alt((
-        map(
-            separated_pair(expression_nonrecurse, token(tk::BitAnd), expression),
-            |(a, b)| Operation::And { a, b },
-        ),
-        map(
-            separated_pair(expression_nonrecurse, token(tk::BitOr), expression),
-            |(a, b)| Operation::Or { a, b },
-        ),
-        map(
-            separated_pair(expression_nonrecurse, token(tk::BitXor), expression),
-            |(a, b)| Operation::Xor { a, b },
-        ),
-        map(preceded(token(tk::BitNot), expression), Operation::Not),
-    ))(input)
-}
-
-fn call_item(input: TokenSpan) -> IResult<TokenSpan, Call> {
-    map(
-        tuple((
-            token(tk::Ident),
-            delimited(
-                token(tk::LParen),
-                separated_list0(token(tk::Comma), expression),
-                token(tk::RParen),
-            ),
-        )),
-        |(name, args)| Call {
-            name: name.span(),
-            args,
-        },
-    )(input)
-}
-
-/// parser combinators can not parse left-recursive grammars. To work around this, we split
-/// expressions into a recursive and non-recursive portion.
-/// Parsers reachable from this point must call expression_nonrecurse instead
-fn expression(input: TokenSpan) -> IResult<TokenSpan, Expression> {
-    alt((
-        map(operation, |op| Expression::Operation(Box::new(op))),
-        expression_nonrecurse,
-    ))(input)
-}
-
-/// the portion of the expression grammar that can be parsed without left recursion
-fn expression_nonrecurse(input: TokenSpan) -> IResult<TokenSpan, Expression> {
-    alt((
-        map(token(tk::Number), |_| Expression::Literal(42)),
-        map(call_item, |call| Expression::Call(Box::new(call))),
-        map(token(tk::Ident), |ident| {
-            Expression::Ident(*ident.span().fragment())
-        }),
-        delimited(token(tk::LParen), expression, token(tk::RParen)),
-    ))(input)
-}
-
-fn assign_statement(input: TokenSpan) -> IResult<TokenSpan, Assign> {
-    map(
-        separated_pair(token(tk::Ident), token(tk::EqAssign), expression),
-        |(lhs, expr)| Assign {
-            lhs: (*lhs.span().fragment()),
-            expr,
-        },
-    )(input)
-}
-
 pub fn parse(input: TokenSpan) -> IResult<TokenSpan, Module> {
     module(input)
 }

src/parser/expression.rs

@@ -0,0 +1,97 @@
+use super::tokens::{token, TokenKind as tk, TokenSpan};
+use super::{IResult, Span};
+use nom::{
+    branch::alt,
+    combinator::map,
+    multi::separated_list0,
+    sequence::{delimited, preceded, separated_pair, tuple},
+};
+
+#[derive(Debug, Clone)]
+pub enum Operation<'a> {
+    And {
+        a: Expression<'a>,
+        b: Expression<'a>,
+    },
+    Or {
+        a: Expression<'a>,
+        b: Expression<'a>,
+    },
+    Xor {
+        a: Expression<'a>,
+        b: Expression<'a>,
+    },
+    Not(Expression<'a>),
+}
+
+pub fn operation(input: TokenSpan) -> IResult<TokenSpan, Operation> {
+    // temporarily given up on before I learn the shunting yard algorithm
+    alt((
+        map(
+            separated_pair(expression_nonrecurse, token(tk::BitAnd), expression),
+            |(a, b)| Operation::And { a, b },
+        ),
+        map(
+            separated_pair(expression_nonrecurse, token(tk::BitOr), expression),
+            |(a, b)| Operation::Or { a, b },
+        ),
+        map(
+            separated_pair(expression_nonrecurse, token(tk::BitXor), expression),
+            |(a, b)| Operation::Xor { a, b },
+        ),
+        map(preceded(token(tk::BitNot), expression), Operation::Not),
+    ))(input)
+}
+
+#[derive(Debug, Clone)]
+pub struct Call<'a> {
+    pub name: Span<'a>,
+    pub args: Vec<Expression<'a>>,
+}
+
+pub fn call_item(input: TokenSpan) -> IResult<TokenSpan, Call> {
+    map(
+        tuple((
+            token(tk::Ident),
+            delimited(
+                token(tk::LParen),
+                separated_list0(token(tk::Comma), expression),
+                token(tk::RParen),
+            ),
+        )),
+        |(name, args)| Call {
+            name: name.span(),
+            args,
+        },
+    )(input)
+}
+
+#[derive(Debug, Clone)]
+pub enum Expression<'a> {
+    Ident(&'a str),
+    Literal(u64),
+    Call(Box<Call<'a>>),
+    Operation(Box<Operation<'a>>),
+}
+
+/// parser combinators can not parse left-recursive grammars. To work around this, we split
+/// expressions into a recursive and non-recursive portion.
+/// Parsers reachable from this point must call expression_nonrecurse instead
+pub fn expression(input: TokenSpan) -> IResult<TokenSpan, Expression> {
+    alt((
+        map(operation, |op| Expression::Operation(Box::new(op))),
+        expression_nonrecurse,
+    ))(input)
+}
+
+/// the portion of the expression grammar that can be parsed without left recursion
+fn expression_nonrecurse(input: TokenSpan) -> IResult<TokenSpan, Expression> {
+    alt((
+        map(token(tk::Number), |_| Expression::Literal(42)),
+        map(call_item, |call| Expression::Call(Box::new(call))),
+        map(token(tk::Ident), |ident| {
+            Expression::Ident(*ident.span().fragment())
+        }),
+        delimited(token(tk::LParen), expression, token(tk::RParen)),
+    ))(input)
+}