dasys
/
cst-to-llhd
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Update cst::AlwaysStatement

This commit is contained in:
Guojie Luo 2022-02-19 12:49:42 +08:00
parent dda95883e4
commit d3c4fbc626
10 changed files with 112 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
src/cst/always_statement.rs
View File

@ -1,15 +1,39 @@
use crate::cst::ModuleContext;
use crate::cst::{ModuleContext, ProceduralTimingControlStatement, Tag, Tools};
use json::JsonValue;
use llhd::ir::{Signature, Unit, UnitBuilder, UnitData, UnitKind, UnitName};
pub struct AlwaysStatement {}
impl AlwaysStatement {
pub fn codegen<'a>(_json: &JsonValue, context: &'a mut ModuleContext) -> Unit<'a> {
let mut proc_data =
UnitData::new(UnitKind::Process, UnitName::Anonymous(0), Signature::new());
pub fn codegen<'a>(json: &JsonValue, context: &'a mut ModuleContext) -> Unit<'a> {
let mut proc_data = UnitData::new(
UnitKind::Process,
UnitName::local(format!("{}.always.{}", context.name, context.process.len())),
Signature::new(),
);
let mut _proc_builder = UnitBuilder::new_anonymous(&mut proc_data);
let proc_id = context.module.add_unit(proc_data);
context.process.push(proc_id);
match json["children"][0]["tag"].as_str() {
Some(Tag::ALWAYS) => {
let json_statement = Tools::match_tags(
vec![json],
vec![
Tag::ALWAYS_STATEMENT,
Tag::PROCEDURAL_TIMING_CONTROL_STATEMENT,
],
);
assert_eq!(json_statement.len(), 1);
ProceduralTimingControlStatement::codegen(json_statement[0], context);
}
Some(Tag::ALWAYS_COMB) => {
// TODO
}
_ => {
panic!();
}
}
context.module.unit(proc_id)
}

0
src/cst/block_item_statement.rs Normal file
View File

0
src/cst/conditional_statement.rs Normal file
View File

6
src/cst/context.rs
View File

@ -1,9 +1,11 @@
use llhd::ir::{Arg, Module};
use llhd::ir::{Arg, Module, UnitId};
use std::collections::HashMap;
pub struct ModuleContext {
pub name: String,
pub module: Module,
pub arg_info: HashMap<Arg, ArgInfo>,
pub process: Vec<UnitId>,
}
pub struct ArgInfo {
@ -14,8 +16,10 @@ pub struct ArgInfo {
impl ModuleContext {
pub fn new() -> Self {
Self {
name: String::new(),
module: Module::new(),
arg_info: HashMap::new(),
process: Vec::new(),
}
}
}

22
src/cst/mod.rs
View File

@ -1,13 +1,15 @@
pub mod always_statement;
pub mod context;
pub mod description_list;
pub mod module_declaration;
pub mod tags;
pub mod tools;
mod always_statement;
mod context;
mod description_list;
mod module_declaration;
mod procedural_timing_control_statement;
mod tags;
mod tools;
pub use always_statement::AlwaysStatement;
pub use context::{ArgInfo, ModuleContext};
use always_statement::AlwaysStatement;
use context::{ArgInfo, ModuleContext};
pub use description_list::DescriptionList;
pub use module_declaration::ModuleDeclaration;
use module_declaration::ModuleDeclaration;
use procedural_timing_control_statement::ProceduralTimingControlStatement;
pub use tags::Tag;
pub use tools::Tools;
use tools::Tools;

91
src/cst/module_declaration.rs
View File

@ -4,7 +4,6 @@ use llhd::ir::{
ExtUnit, InstBuilder, Module, Signature, UnitBuilder, UnitData, UnitKind, UnitName,
};
use llhd::ty::{int_ty, signal_ty};
use std::collections::HashMap;
pub struct ModuleDeclaration {}
@ -12,51 +11,15 @@ impl ModuleDeclaration {
pub fn codegen(json: &JsonValue) -> Module {
let mut context = ModuleContext::new();
let entity_name = UnitName::global({
let json_symbol_identifier = Tools::match_tags(
vec![json],
vec![
Tag::MODULE_DECLARATION,
Tag::MODULE_HEADER,
Tag::SYMBOL_IDENTIFIER,
],
);
assert_eq!(json_symbol_identifier.len(), 1);
json_symbol_identifier[0]["text"].to_string()
});
let mut entity_signature = Signature::new();
let json_ports = &Tools::match_tags(
vec![json],
vec![
Tag::MODULE_DECLARATION,
Tag::MODULE_ITEM_LIST,
Tag::MODULE_PORT_DECLARATION,
],
);
let input_info = &Self::get_port_info(json_ports, Tag::INPUT);
let output_info = &Self::get_port_info(json_ports, Tag::OUTPUT);
let mut arg_table = HashMap::new();
for (name, width) in input_info {
let arg = entity_signature.add_input(signal_ty(int_ty(width.clone())));
arg_table.insert(arg, name.to_string());
context.arg_info.insert(arg, ArgInfo::new(name, width));
}
for (name, width) in output_info {
let arg = entity_signature.add_output(signal_ty(int_ty(width.clone())));
arg_table.insert(arg, name.to_string());
context.arg_info.insert(arg, ArgInfo::new(name, width));
}
let entity_name = Self::get_entity_name(json, &mut context);
let entity_signature = Self::get_entity_signature(json, &mut context);
let mut entity_data = UnitData::new(UnitKind::Entity, entity_name, entity_signature);
let mut entity_builder = UnitBuilder::new_anonymous(&mut entity_data);
for (arg, name) in arg_table.iter() {
for (arg, arg_info) in context.arg_info.iter() {
let value = entity_builder.arg_value(*arg);
entity_builder.set_name(value, name.to_string());
entity_builder.set_name(value, arg_info.name.to_string());
}
let process_list: Vec<ExtUnit> = Tools::match_tags(
@ -85,6 +48,50 @@ impl ModuleDeclaration {
context.module
}
fn get_entity_name(json: &JsonValue, context: &mut ModuleContext) -> UnitName {
context.name = {
let json_symbol_identifier = Tools::match_tags(
vec![json],
vec![
Tag::MODULE_DECLARATION,
Tag::MODULE_HEADER,
Tag::SYMBOL_IDENTIFIER,
],
);
assert_eq!(json_symbol_identifier.len(), 1);
json_symbol_identifier[0]["text"].to_string()
};
UnitName::global(context.name.to_string())
}
fn get_entity_signature(json: &JsonValue, context: &mut ModuleContext) -> Signature {
let mut signature = Signature::new();
let json_ports = &Tools::match_tags(
vec![json],
vec![
Tag::MODULE_DECLARATION,
Tag::MODULE_ITEM_LIST,
Tag::MODULE_PORT_DECLARATION,
],
);
let input_info = &Self::get_port_info(json_ports, Tag::INPUT);
let output_info = &Self::get_port_info(json_ports, Tag::OUTPUT);
for (name, width) in input_info {
let arg = signature.add_input(signal_ty(int_ty(width.clone())));
context.arg_info.insert(arg, ArgInfo::new(name, width));
}
for (name, width) in output_info {
let arg = signature.add_output(signal_ty(int_ty(width.clone())));
context.arg_info.insert(arg, ArgInfo::new(name, width));
}
signature
}
fn get_bit_names(json_io_ports: &Vec<&JsonValue>) -> Vec<String> {
// note: possible improvement by merging common path segments
let paths = vec![

0
src/cst/nonblocking_assignment_statement.rs Normal file
View File

8
src/cst/procedural_timing_control_statement.rs Normal file
View File

@ -0,0 +1,8 @@
use crate::cst::ModuleContext;
use json::JsonValue;
pub struct ProceduralTimingControlStatement {}
impl ProceduralTimingControlStatement {
pub fn codegen(_json: &JsonValue, _context: &ModuleContext) {}
}

0
src/cst/seq_block.rs Normal file
View File

14
src/cst/tags.rs
View File

@ -4,11 +4,8 @@ impl Tag {
pub const DESCRIPTION_LIST: &'static str = "kDescriptionList";
pub const MODULE_DECLARATION: &'static str = "kModuleDeclaration";
pub const MODULE_HEADER: &'static str = "kModuleHeader";
pub const SYMBOL_IDENTIFIER: &'static str = "SymbolIdentifier";
pub const MODULE_ITEM_LIST: &'static str = "kModuleItemList";
pub const MODULE_PORT_DECLARATION: &'static str = "kModulePortDeclaration";
pub const INPUT: &'static str = "input";
pub const OUTPUT: &'static str = "output";
pub const PORT_IDENTIFIER_LIST: &'static str = "kPortIdentifierList";
pub const PORT_IDENTIFIER: &'static str = "kPortIdentifier";
pub const IDENTIFIER_LIST: &'static str = "kIdentifierList";
@ -21,6 +18,15 @@ impl Tag {
pub const DIMENSION_RANGE: &'static str = "kDimensionRange";
pub const EXPRESSION: &'static str = "kExpression";
pub const NUMBER: &'static str = "kNumber";
pub const DEC_NUMBER: &'static str = "TK_DecNumber";
pub const ALWAYS_STATEMENT: &'static str = "kAlwaysStatement";
pub const PROCEDURAL_TIMING_CONTROL_STATEMENT: &'static str =
"kProceduralTimingControlStatement";
pub const SYMBOL_IDENTIFIER: &'static str = "SymbolIdentifier";
pub const DEC_NUMBER: &'static str = "TK_DecNumber";
pub const INPUT: &'static str = "input";
pub const OUTPUT: &'static str = "output";
pub const ALWAYS: &'static str = "always";
pub const ALWAYS_COMB: &'static str = "always_comb";
}