futilehdl/src/parser/proc.rs

use nom::{
    branch::alt,
    combinator::map,
    error::context,
    multi::{many1, separated_list1},
    sequence::{delimited, tuple},
};

use crate::parser::{
    assign_statement,
    tokens::{token, TokenKind as tk, TokenSpan},
    Assign, IResult, Span,
};

#[derive(Debug)]
pub struct ProcBlock<'a> {
    pub net: Span<'a>,
    pub items: Vec<ProcStatement<'a>>,
}

#[derive(Debug)]
pub enum ProcStatement<'a> {
    Assign(Assign<'a>),
}

fn statement_block(input: TokenSpan) -> IResult<TokenSpan, Vec<ProcStatement>> {
    delimited(
        token(tk::LBrace),
        separated_list1(token(tk::Semicolon), proc_statement),
        token(tk::RBrace),
    )(input)
}

/// parse a statement that is valid inside a proc block
fn proc_statement(input: TokenSpan) -> IResult<TokenSpan, ProcStatement> {
    alt((map(assign_statement, ProcStatement::Assign),))(input)
}

pub fn proc_block(input: TokenSpan) -> IResult<TokenSpan, ProcBlock> {
    context(
        "proc block",
        map(
            tuple((
                token(tk::Proc),
                delimited(token(tk::LParen), token(tk::Ident), token(tk::RParen)),
                delimited(token(tk::LBrace), many1(proc_statement), token(tk::RBrace)),
            )),
            |(_, net, items)| ProcBlock {
                net: net.span(),
                items,
            },
        ),
    )(input)
}