start implementing state adt
This commit is contained in:
parent
c1dc524cab
commit
faf92307e2
|
@ -1,6 +1,6 @@
|
|||
module identity (
|
||||
comb identity (
|
||||
a: Logic
|
||||
) -> Logic
|
||||
{
|
||||
assign x = a;
|
||||
a
|
||||
}
|
||||
|
|
|
@ -286,7 +286,7 @@ fn lower_assignment(
|
|||
|
||||
pub fn lower_module(pa_module: parser::Module) -> Result<String, CompileError> {
|
||||
let mut writer = rtlil::ILWriter::new();
|
||||
let mut ir_module = rtlil::Module::new(make_pubid(pa_module.name.fragment()));
|
||||
let mut ir_module = rtlil::Module::new(make_pubid("test"));
|
||||
let mut context = Context {
|
||||
callables: get_builtins()
|
||||
.into_iter()
|
||||
|
@ -297,6 +297,7 @@ pub fn lower_module(pa_module: parser::Module) -> Result<String, CompileError> {
|
|||
};
|
||||
|
||||
writer.write_line("autoidx 1");
|
||||
/*
|
||||
for (idx, port) in pa_module.ports.iter().enumerate() {
|
||||
// FIXME: Actually resolve types
|
||||
let sigtype = TypeStruct::logic_width(TODO_WIDTH);
|
||||
|
@ -328,5 +329,6 @@ pub fn lower_module(pa_module: parser::Module) -> Result<String, CompileError> {
|
|||
}
|
||||
}
|
||||
ir_module.write_rtlil(&mut writer);
|
||||
*/
|
||||
Ok(writer.finish())
|
||||
}
|
||||
|
|
|
@ -1,16 +1,40 @@
|
|||
use super::declaration::{declaration, NetDecl};
|
||||
use super::tokens::{token, Token, TokenKind as tk, TokenSpan};
|
||||
use super::IResult;
|
||||
use nom::multi::many0;
|
||||
use nom::multi::separated_list0;
|
||||
use nom::sequence::tuple;
|
||||
use nom::{
|
||||
combinator::{cut, map},
|
||||
combinator::{cut, map, opt},
|
||||
sequence::{delimited, preceded},
|
||||
};
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct StateBlock<'a> {
|
||||
name: Token<'a>,
|
||||
items: Vec<NetDecl<'a>>,
|
||||
pub name: Token<'a>,
|
||||
pub variants: Vec<StateVariant<'a>>,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct StateVariant<'a> {
|
||||
pub name: Token<'a>,
|
||||
pub params: Option<Vec<Token<'a>>>,
|
||||
}
|
||||
|
||||
fn state_variant(input: TokenSpan) -> IResult<TokenSpan, StateVariant> {
|
||||
map(
|
||||
tuple((
|
||||
token(tk::Ident),
|
||||
opt(delimited(
|
||||
token(tk::LParen),
|
||||
separated_list0(token(tk::Comma), token(tk::Ident)),
|
||||
token(tk::RParen),
|
||||
)),
|
||||
)),
|
||||
|(name, param)| StateVariant {
|
||||
name: name.clone(),
|
||||
params: param,
|
||||
},
|
||||
)(input)
|
||||
}
|
||||
|
||||
pub fn state(input: TokenSpan) -> IResult<TokenSpan, StateBlock> {
|
||||
|
@ -19,12 +43,13 @@ pub fn state(input: TokenSpan) -> IResult<TokenSpan, StateBlock> {
|
|||
token(tk::State),
|
||||
cut(tuple((
|
||||
token(tk::Ident),
|
||||
delimited(token(tk::LBrace), many0(declaration), token(tk::RBrace)),
|
||||
delimited(
|
||||
token(tk::LBrace),
|
||||
separated_list0(token(tk::Comma), state_variant),
|
||||
token(tk::RBrace),
|
||||
),
|
||||
))),
|
||||
),
|
||||
|(name, items)| StateBlock {
|
||||
name: name.clone(),
|
||||
items,
|
||||
},
|
||||
|(name, variants)| StateBlock { name, variants },
|
||||
)(input)
|
||||
}
|
||||
|
|
|
@ -1,18 +1,24 @@
|
|||
use super::module::inputs_list;
|
||||
use super::tokens::TokenKind as tk;
|
||||
use crate::parser::tokens::token;
|
||||
use crate::parser::typename;
|
||||
use crate::parser::IResult;
|
||||
use crate::parser::Module;
|
||||
use crate::parser::TokenSpan;
|
||||
use nom::combinator::cut;
|
||||
use nom::combinator::map;
|
||||
use nom::multi::many0;
|
||||
use super::{
|
||||
module::inputs_list,
|
||||
module::PortDecl,
|
||||
tokens::{token, TokenKind as tk, TokenSpan},
|
||||
typename, IResult, Span,
|
||||
};
|
||||
use nom::sequence::delimited;
|
||||
use nom::sequence::preceded;
|
||||
use nom::sequence::tuple;
|
||||
use nom::{
|
||||
combinator::{cut, map},
|
||||
multi::many0,
|
||||
};
|
||||
|
||||
pub fn comb_block(input: TokenSpan) -> IResult<TokenSpan, Module> {
|
||||
#[derive(Debug)]
|
||||
pub struct CombBlock<'a> {
|
||||
pub name: Span<'a>,
|
||||
pub ports: Vec<PortDecl<'a>>,
|
||||
}
|
||||
|
||||
pub fn comb_block(input: TokenSpan) -> IResult<TokenSpan, CombBlock> {
|
||||
map(
|
||||
preceded(
|
||||
token(tk::Comb),
|
||||
|
@ -27,11 +33,10 @@ pub fn comb_block(input: TokenSpan) -> IResult<TokenSpan, Module> {
|
|||
),
|
||||
))),
|
||||
),
|
||||
|(name, inputs, _ret, _items)| Module {
|
||||
|(name, inputs, _ret, _items)| CombBlock {
|
||||
// TODO: bring back returns
|
||||
name: name.span(),
|
||||
ports: inputs,
|
||||
items: todo!(),
|
||||
},
|
||||
)(input)
|
||||
}
|
||||
|
|
|
@ -23,9 +23,10 @@ pub use crate::parser::declaration::{
|
|||
pub use crate::parser::expression::{expression, Call, Expression, Operation};
|
||||
pub use crate::parser::module::{module, Module, ModuleItem, PortDirection};
|
||||
use crate::parser::tokens::TokenSpan;
|
||||
use nom::combinator::all_consuming;
|
||||
|
||||
pub fn parse(input: TokenSpan) -> IResult<TokenSpan, Module> {
|
||||
module(input)
|
||||
all_consuming(module)(input)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
|
|
@ -1,10 +1,16 @@
|
|||
use nom::{combinator::map, multi::separated_list0};
|
||||
use nom::{
|
||||
branch::alt,
|
||||
combinator::map,
|
||||
multi::{many1, separated_list0},
|
||||
};
|
||||
|
||||
use crate::parser::{
|
||||
adt::{state, StateBlock},
|
||||
comb::{comb_block, CombBlock},
|
||||
declaration,
|
||||
proc::ProcBlock,
|
||||
tokens::{token, TokenKind as tk, TokenSpan},
|
||||
Assign, IResult, NetDecl, Span,
|
||||
IResult, NetDecl, Span,
|
||||
};
|
||||
|
||||
#[derive(Debug)]
|
||||
|
@ -21,15 +27,14 @@ pub struct PortDecl<'a> {
|
|||
|
||||
#[derive(Debug)]
|
||||
pub struct Module<'a> {
|
||||
pub name: Span<'a>,
|
||||
pub ports: Vec<PortDecl<'a>>,
|
||||
pub items: Vec<ModuleItem<'a>>,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum ModuleItem<'a> {
|
||||
Assign(Assign<'a>),
|
||||
Comb(CombBlock<'a>),
|
||||
Proc(ProcBlock<'a>),
|
||||
State(StateBlock<'a>),
|
||||
}
|
||||
|
||||
fn port_decl(i: TokenSpan) -> IResult<TokenSpan, PortDecl> {
|
||||
|
@ -43,8 +48,14 @@ pub fn inputs_list(input: TokenSpan) -> IResult<TokenSpan, Vec<PortDecl>> {
|
|||
separated_list0(token(tk::Comma), port_decl)(input)
|
||||
}
|
||||
|
||||
pub fn module(_input: TokenSpan) -> IResult<TokenSpan, Module> {
|
||||
todo!();
|
||||
pub fn module(input: TokenSpan) -> IResult<TokenSpan, Module> {
|
||||
map(
|
||||
many1(alt((
|
||||
map(state, ModuleItem::State),
|
||||
map(comb_block, ModuleItem::Comb),
|
||||
))),
|
||||
|items| Module { items },
|
||||
)(input)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
|
|
@ -3,18 +3,20 @@
|
|||
use super::{
|
||||
error::{Error, InputPos},
|
||||
literals::{identifier, ws0},
|
||||
IResult, Span,
|
||||
IErr, IResult, Span,
|
||||
};
|
||||
use nom::{
|
||||
branch::alt,
|
||||
bytes::complete::tag,
|
||||
character::complete::{anychar, digit1},
|
||||
combinator::{consumed, map, recognize},
|
||||
error::ParseError,
|
||||
multi::many0,
|
||||
InputTake,
|
||||
};
|
||||
use std::fmt;
|
||||
|
||||
#[derive(Clone)]
|
||||
#[derive(Clone, Copy)]
|
||||
pub struct Token<'a> {
|
||||
span: Span<'a>,
|
||||
kind: TokenKind,
|
||||
|
@ -38,7 +40,7 @@ impl<'a> Token<'a> {
|
|||
Self { span, kind }
|
||||
}
|
||||
|
||||
pub fn span(&self) -> Span {
|
||||
pub fn span(self) -> Span<'a> {
|
||||
self.span
|
||||
}
|
||||
pub fn kind(&self) -> TokenKind {
|
||||
|
@ -85,7 +87,7 @@ pub enum TokenKind {
|
|||
Error,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
#[derive(Debug, Copy, Clone)]
|
||||
pub struct TokenSpan<'a> {
|
||||
rest: &'a [Token<'a>],
|
||||
pos: usize,
|
||||
|
@ -106,7 +108,7 @@ impl<'a> TokenSpan<'a> {
|
|||
}
|
||||
}
|
||||
|
||||
impl nom::InputTake for TokenSpan<'_> {
|
||||
impl InputTake for TokenSpan<'_> {
|
||||
fn take(&self, count: usize) -> Self {
|
||||
TokenSpan::with_pos(&self.rest[..count], self.pos + count)
|
||||
}
|
||||
|
@ -133,10 +135,16 @@ impl InputPos for TokenSpan<'_> {
|
|||
}
|
||||
|
||||
/// combinator that matches a token kind
|
||||
pub fn token<'a>(kind: TokenKind) -> impl FnMut(TokenSpan<'a>) -> IResult<TokenSpan, &Token> {
|
||||
pub fn token<'a>(kind: TokenKind) -> impl FnMut(TokenSpan<'a>) -> IResult<TokenSpan, Token> {
|
||||
move |input: TokenSpan| {
|
||||
let next = &input.rest[0];
|
||||
let kind = kind;
|
||||
let next = if let Some(i) = input.rest.first() {
|
||||
*i
|
||||
} else {
|
||||
return Err(nom::Err::Error(Error::from_error_kind(
|
||||
input,
|
||||
nom::error::ErrorKind::Eof,
|
||||
)));
|
||||
};
|
||||
if next.kind == kind {
|
||||
let rest = TokenSpan::with_pos(&input.rest[1..], input.pos + 1);
|
||||
Ok((rest, next))
|
||||
|
@ -210,7 +218,7 @@ fn lex_keywords(input: Span) -> IResult<Span, Token> {
|
|||
map(tag("match"), |_| TokenKind::Match),
|
||||
map(tag("proc"), |_| TokenKind::Proc),
|
||||
map(tag("comb"), |_| TokenKind::Comb),
|
||||
map(tag("state"), |_| TokenKind::Proc),
|
||||
map(tag("state"), |_| TokenKind::State),
|
||||
))),
|
||||
|(span, kind)| Token::new(span, kind),
|
||||
)(input)
|
||||
|
|
Loading…
Reference in New Issue