diff --git a/crates/analyzer/src/analyzer_error.rs b/crates/analyzer/src/analyzer_error.rs index 5be3e398..3780debf 100644 --- a/crates/analyzer/src/analyzer_error.rs +++ b/crates/analyzer/src/analyzer_error.rs @@ -166,6 +166,21 @@ pub enum AnalyzerError { error_location: SourceSpan, }, + #[diagnostic( + severity(Warning), + code(invalid_select), + help(""), + url("https://doc.veryl-lang.org/book/07_appendix/02_semantic_error.html#invalid_select") + )] + #[error("invalid select caused by {kind}")] + InvalidSelect { + kind: String, + #[source_code] + input: NamedSource, + #[label("Error location")] + error_location: SourceSpan, + }, + #[diagnostic( severity(Warning), code(invalid_identifier), @@ -503,6 +518,22 @@ pub enum AnalyzerError { other_location: SourceSpan, }, + #[diagnostic( + severity(Warning), + code(mismatch_assignment), + help(""), + url("https://doc.veryl-lang.org/book/07_appendix/02_semantic_error.html#mismatch_assignment") + )] + #[error("\"{src}\" can't be assigned to \"{dst}\"")] + MismatchAssignment { + src: String, + dst: String, + #[source_code] + input: NamedSource, + #[label("Error location")] + error_location: SourceSpan, + }, + #[diagnostic( severity(Error), code(missing_if_reset), @@ -1412,6 +1443,15 @@ impl AnalyzerError { } } + pub fn mismatch_assignment(src: &str, dst: &str, source: &str, token: &TokenRange) -> Self { + AnalyzerError::MismatchAssignment { + src: src.to_string(), + dst: dst.to_string(), + input: AnalyzerError::named_source(source, token), + error_location: token.into(), + } + } + pub fn missing_clock_signal(source: &str, token: &TokenRange) -> Self { AnalyzerError::MissingClockSignal { input: AnalyzerError::named_source(source, token), @@ -1772,6 +1812,11 @@ impl AnalyzerError { input: AnalyzerError::named_source(source, &token.into()), error_location: token.into(), }, + EvaluatedError::InvalidSelect { kind, range } => AnalyzerError::InvalidSelect { + kind: kind.to_string(), + input: AnalyzerError::named_source(source, range), + error_location: range.into(), + }, } } } diff --git a/crates/analyzer/src/evaluator.rs b/crates/analyzer/src/evaluator.rs index b33f28cf..7ab7b0e4 100644 --- a/crates/analyzer/src/evaluator.rs +++ b/crates/analyzer/src/evaluator.rs @@ -1,7 +1,7 @@ use crate::symbol::{SymbolId, Type, TypeKind}; use crate::symbol_table::{self, ResolveError, ResolveResult}; use veryl_parser::veryl_grammar_trait::*; -use veryl_parser::veryl_token::Token; +use veryl_parser::veryl_token::{Token, TokenRange}; #[derive(Clone, Debug)] pub struct Evaluated { @@ -83,6 +83,7 @@ pub struct EvaluatedTypeUserDefined { pub enum EvaluatedError { InvalidFactor { kind: String, token: Token }, CallNonFunction { kind: String, token: Token }, + InvalidSelect { kind: String, range: TokenRange }, } fn reduction isize>( @@ -121,6 +122,17 @@ impl Evaluated { matches!(self.r#type, EvaluatedType::Reset(_)) } + pub fn is_4state(&self) -> bool { + matches!( + self.r#type, + EvaluatedType::Clock(_) | EvaluatedType::Reset(_) | EvaluatedType::Logic(_) + ) + } + + pub fn is_2state(&self) -> bool { + matches!(self.r#type, EvaluatedType::Bit(_)) + } + pub fn get_value(&self) -> Option { if let EvaluatedValue::Fixed(x) = self.value { Some(x) @@ -129,25 +141,25 @@ impl Evaluated { } } - pub fn get_width(&self) -> Vec { + pub fn get_width(&self) -> Option> { match &self.r#type { - EvaluatedType::Clock(x) => x.width.clone(), - EvaluatedType::Reset(x) => x.width.clone(), - EvaluatedType::Bit(x) => x.width.clone(), - EvaluatedType::Logic(x) => x.width.clone(), - EvaluatedType::UserDefined(x) => x.width.clone(), - EvaluatedType::Unknown => Vec::new(), + EvaluatedType::Clock(x) => Some(x.width.clone()), + EvaluatedType::Reset(x) => Some(x.width.clone()), + EvaluatedType::Bit(x) => Some(x.width.clone()), + EvaluatedType::Logic(x) => Some(x.width.clone()), + EvaluatedType::UserDefined(x) => Some(x.width.clone()), + EvaluatedType::Unknown => None, } } - pub fn get_array(&self) -> Vec { + pub fn get_array(&self) -> Option> { match &self.r#type { - EvaluatedType::Clock(x) => x.array.clone(), - EvaluatedType::Reset(x) => x.array.clone(), - EvaluatedType::Bit(x) => x.array.clone(), - EvaluatedType::Logic(x) => x.array.clone(), - EvaluatedType::UserDefined(x) => x.array.clone(), - EvaluatedType::Unknown => Vec::new(), + EvaluatedType::Clock(x) => Some(x.array.clone()), + EvaluatedType::Reset(x) => Some(x.array.clone()), + EvaluatedType::Bit(x) => Some(x.array.clone()), + EvaluatedType::Logic(x) => Some(x.array.clone()), + EvaluatedType::UserDefined(x) => Some(x.array.clone()), + EvaluatedType::Unknown => None, } } @@ -258,14 +270,14 @@ impl Evaluated { }); } - pub fn create_variable(signed: bool, width: Vec, array: Vec) -> Evaluated { + pub fn create_undefine_fixed(signed: bool, width: Vec, array: Vec) -> Evaluated { let mut ret = Self::create_unknown(); - ret.set_variable(signed, width, array); + ret.set_undefine_fixed(signed, width, array); ret } - pub fn set_variable(&mut self, signed: bool, width: Vec, array: Vec) { - self.value = EvaluatedValue::Unknown; + pub fn set_undefine_fixed(&mut self, signed: bool, width: Vec, array: Vec) { + self.value = EvaluatedValue::UnknownStatic; self.r#type = EvaluatedType::Logic(EvaluatedTypeLogic { signed, width, @@ -273,6 +285,40 @@ impl Evaluated { }); } + pub fn create_variable( + signed: bool, + is_4state: bool, + width: Vec, + array: Vec, + ) -> Evaluated { + let mut ret = Self::create_unknown(); + ret.set_variable(signed, is_4state, width, array); + ret + } + + pub fn set_variable( + &mut self, + signed: bool, + is_4state: bool, + width: Vec, + array: Vec, + ) { + self.value = EvaluatedValue::Unknown; + if is_4state { + self.r#type = EvaluatedType::Logic(EvaluatedTypeLogic { + signed, + width, + array, + }); + } else { + self.r#type = EvaluatedType::Bit(EvaluatedTypeBit { + signed, + width, + array, + }); + } + } + pub fn create_clock( kind: EvaluatedTypeClockKind, width: Vec, @@ -313,22 +359,70 @@ impl Evaluated { self.r#type = EvaluatedType::Reset(EvaluatedTypeReset { kind, width, array }); } - pub fn select(mut self, mut beg: Evaluated, mut end: Evaluated) -> Evaluated { + pub fn select( + mut self, + mut beg: Evaluated, + mut end: Evaluated, + single: bool, + range: TokenRange, + ) -> Evaluated { let value = self.get_value(); let width = self.get_width(); let array = self.get_array(); - if let (Some(beg), Some(end)) = (beg.get_value(), end.get_value()) { - if let Some(x) = array.first() { - if *x == 1 { - // select width + if let (Some(width), Some(array)) = (width, array) { + if let Some(select_array) = array.first() { + // select array + + let mut rest: Vec<_> = array[1..].to_vec(); + if let (Some(beg), Some(end)) = (beg.get_value(), end.get_value()) { + if beg > end { + self.errors.push(EvaluatedError::InvalidSelect { + kind: "wrong index order".to_string(), + range, + }); + self.set_unknown(); + } else if end >= *select_array as isize { + self.errors.push(EvaluatedError::InvalidSelect { + kind: "out of range".to_string(), + range, + }); + self.set_unknown(); + } else { + if single { + self.set_array(rest); + } else { + let mut new_array = vec![(end - beg + 1) as usize]; + new_array.append(&mut rest); + self.set_array(new_array); + } + self.set_unknown(); + } + } else if single { + self.set_array(rest); + self.set_unknown(); + } + } else { + // select width - let select_width = width.first().unwrap_or(&0); - let mut rest = width[1..].to_vec(); + let select_width = width.first().unwrap_or(&0); + let mut rest = if width.is_empty() { + vec![] + } else { + width[1..].to_vec() + }; + + if let (Some(beg), Some(end)) = (beg.get_value(), end.get_value()) { if end > beg { - // TODO index error + self.errors.push(EvaluatedError::InvalidSelect { + kind: "wrong index order".to_string(), + range, + }); self.set_unknown(); } else if beg >= *select_width as isize { - // TODO out of range error + self.errors.push(EvaluatedError::InvalidSelect { + kind: "out of range".to_string(), + range, + }); self.set_unknown(); } else { let part_size: usize = if rest.is_empty() { @@ -360,23 +454,10 @@ impl Evaluated { self.set_width(new_width); } - } else { - // select array - - let select_array = array.first().unwrap_or(&0); - let _rest: Vec<_> = array[1..].iter().collect(); - if beg > end { - // TODO index error - self.set_unknown(); - } else if end >= *select_array as isize { - // TODO out of range error - self.set_unknown(); - } else { - self.set_unknown(); - } + } else if single { + let new_width = if rest.is_empty() { vec![1] } else { rest }; + self.set_width(new_width); } - } else { - self.set_unknown(); } } else { self.set_unknown(); @@ -399,6 +480,8 @@ impl Evaluated { ) -> Evaluated { // TODO array error + let is_4state = left.is_4state() | right.is_4state(); + let mut ret = match ( left.get_value(), right.get_value(), @@ -409,14 +492,14 @@ impl Evaluated { let value = calc_value(value0, value1); let width = calc_width(width0, width1, context_width); if let Some(value) = value { - Evaluated::create_fixed(value, false, vec![width], vec![1]) + Evaluated::create_fixed(value, false, vec![width], vec![]) } else { - Evaluated::create_variable(false, vec![width], vec![1]) + Evaluated::create_variable(false, is_4state, vec![width], vec![]) } } (_, _, Some(width0), Some(width1)) => { let width = calc_width(width0, width1, context_width); - Evaluated::create_variable(false, vec![width], vec![1]) + Evaluated::create_variable(false, is_4state, vec![width], vec![]) } _ => Evaluated::create_unknown(), }; @@ -433,19 +516,21 @@ impl Evaluated { ) -> Evaluated { // TODO array error + let is_4state = left.is_4state(); + let mut ret = match (left.get_value(), left.get_total_width()) { (Some(value0), Some(width0)) => { let value = calc_value(value0); let width = calc_width(width0); if let Some(value) = value { - Evaluated::create_fixed(value, false, vec![width], vec![1]) + Evaluated::create_fixed(value, false, vec![width], vec![]) } else { - Evaluated::create_variable(false, vec![width], vec![1]) + Evaluated::create_variable(false, is_4state, vec![width], vec![]) } } (_, Some(width0)) => { let width = calc_width(width0); - Evaluated::create_variable(false, vec![width], vec![1]) + Evaluated::create_variable(false, is_4state, vec![width], vec![]) } _ => Evaluated::create_unknown(), }; @@ -738,6 +823,33 @@ impl Evaluator { Default::default() } + pub fn evaluate_select(&mut self, value: &Select) -> (Evaluated, Evaluated, bool) { + let beg = self.expression(value.expression.as_ref()); + if let Some(x) = &value.select_opt { + let end = self.expression(x.expression.as_ref()); + match x.select_operator.as_ref() { + SelectOperator::Colon(_) => (beg, end, false), + SelectOperator::PlusColon(_) => { + let one = Evaluated::create_fixed(1, false, vec![32], vec![]); + let calc = beg.clone().add(end, None).sub(one, None); + (calc, beg, false) + } + SelectOperator::MinusColon(_) => { + let one = Evaluated::create_fixed(1, false, vec![32], vec![]); + let calc = beg.clone().sub(end, None).add(one, None); + (beg, calc, false) + } + SelectOperator::Step(_) => ( + beg.clone().mul(end.clone(), None).add(end.clone(), None), + beg.mul(end, None), + false, + ), + } + } else { + (beg.clone(), beg, true) + } + } + fn binary_operator(&mut self, operator: &str, left: Evaluated, right: Evaluated) -> Evaluated { match operator { "**" => left.pow(right, self.context_width.first()), @@ -841,7 +953,7 @@ impl Evaluator { pub fn type_array(&mut self, x: Type) -> Option> { if x.array.is_empty() { - Some(vec![1]) + Some(vec![]) } else { let mut ret = Vec::new(); for x in &x.array { @@ -883,22 +995,24 @@ impl Evaluator { }; let width = str::parse::(width); let value = isize::from_str_radix(value, radix); - if let (Ok(width), Ok(value)) = (width, value) { - Evaluated::create_fixed(value, signed, vec![width], vec![1]) - } else { - Evaluated::create_unknown_static() + match (width, value) { + (Ok(width), Ok(value)) => { + Evaluated::create_fixed(value, signed, vec![width], vec![]) + } + (Ok(width), _) => Evaluated::create_undefine_fixed(signed, vec![width], vec![]), + _ => Evaluated::create_unknown_static(), } } else { - Evaluated::create_unknown_static() + unreachable!() } } fn base_less(&mut self, arg: &BaseLess) -> Evaluated { let text = arg.base_less_token.to_string().replace('_', ""); if let Ok(value) = str::parse::(&text) { - Evaluated::create_fixed(value, false, vec![32], vec![1]) + Evaluated::create_fixed(value, false, vec![32], vec![]) } else { - Evaluated::create_unknown() + Evaluated::create_unknown_static() } } @@ -924,11 +1038,12 @@ impl Evaluator { 0 } }; + + let width = *self.context_width.last().unwrap_or(&0); if unknown { - Evaluated::create_unknown() + Evaluated::create_undefine_fixed(false, vec![width], vec![]) } else { - let width = *self.context_width.last().unwrap_or(&0); - Evaluated::create_fixed(value, false, vec![width], vec![1]) + Evaluated::create_fixed(value, false, vec![width], vec![]) } } @@ -1074,42 +1189,42 @@ impl Evaluator { CastingType::Clock(_) => Some(Evaluated::create_clock( EvaluatedTypeClockKind::Implicit, vec![1], - vec![1], + vec![], )), CastingType::ClockPosedge(_) => Some(Evaluated::create_clock( EvaluatedTypeClockKind::Posedge, vec![1], - vec![1], + vec![], )), CastingType::ClockNegedge(_) => Some(Evaluated::create_clock( EvaluatedTypeClockKind::Negedge, vec![1], - vec![1], + vec![], )), CastingType::Reset(_) => Some(Evaluated::create_reset( EvaluatedTypeResetKind::Implicit, vec![1], - vec![1], + vec![], )), CastingType::ResetAsyncHigh(_) => Some(Evaluated::create_reset( EvaluatedTypeResetKind::AsyncHigh, vec![1], - vec![1], + vec![], )), CastingType::ResetAsyncLow(_) => Some(Evaluated::create_reset( EvaluatedTypeResetKind::AsyncLow, vec![1], - vec![1], + vec![], )), CastingType::ResetSyncHigh(_) => Some(Evaluated::create_reset( EvaluatedTypeResetKind::SyncHigh, vec![1], - vec![1], + vec![], )), CastingType::ResetSyncLow(_) => Some(Evaluated::create_reset( EvaluatedTypeResetKind::SyncLow, vec![1], - vec![1], + vec![], )), _ => None, }; @@ -1162,35 +1277,16 @@ impl Evaluator { } fn expression_identifier(&mut self, arg: &ExpressionIdentifier) -> Evaluated { - // TODO array / bit select + let range: TokenRange = arg.into(); let symbol = symbol_table::resolve(arg); - let last_select: Vec<_> = if arg.expression_identifier_list0.is_empty() { - arg.expression_identifier_list - .iter() - .map(|x| x.select.clone()) - .collect() - } else { - arg.expression_identifier_list0 - .last() - .unwrap() - .expression_identifier_list0_list - .iter() - .map(|x| x.select.clone()) - .collect() - }; + let last_select: Vec<_> = arg.last_select(); let mut ret = self.identifier_helper(symbol); for s in &last_select { - let beg = self.expression(s.expression.as_ref()); - let end = if let Some(x) = &s.select_opt { - self.expression(x.expression.as_ref()) - } else { - beg.clone() - }; - - ret = ret.select(beg, end); + let (beg, end, single) = self.evaluate_select(s); + ret = ret.select(beg, end, single, range); } ret @@ -1265,7 +1361,7 @@ impl Evaluator { let arg = self.expression(&arg.expression); if let EvaluatedValue::Fixed(x) = arg.value { let ret = isize::BITS - x.leading_zeros(); - Evaluated::create_fixed(ret as isize, false, vec![32], vec![1]) + Evaluated::create_fixed(ret as isize, false, vec![32], vec![]) } else { Evaluated::create_unknown() } @@ -1287,7 +1383,7 @@ impl Evaluator { (Some(value0), Some(value1), Some(width0), Some(width1)) => { let width = width0 + width1; let value = (value0 << width1) | value1; - Evaluated::create_fixed(value, false, vec![width], vec![1]) + Evaluated::create_fixed(value, false, vec![width], vec![]) } _ => { if x.is_known_static() && y.is_known_static() { @@ -1308,7 +1404,7 @@ impl Evaluator { if let Some(cio) = &arg.concatenation_item_opt { let c = self.expression(cio.expression.as_ref()); if let EvaluatedValue::Fixed(c) = c.value { - let mut tmp = Evaluated::create_fixed(0, false, vec![0], vec![1]); + let mut tmp = Evaluated::create_fixed(0, false, vec![0], vec![]); for _ in 0..c { tmp = self.do_concatenation(tmp, e.clone()); } @@ -1331,7 +1427,7 @@ impl Evaluator { for cll in arg.concatenation_list_list.iter() { eval_vec.push(self.concatenation_list_list(cll)); } - let default_value = Evaluated::create_fixed(0, false, vec![0], vec![1]); + let default_value = Evaluated::create_fixed(0, false, vec![0], vec![]); eval_vec.iter().fold(default_value, |acc, x| { self.do_concatenation(acc, x.clone()) }) @@ -1351,10 +1447,15 @@ impl Evaluator { fn array_literal_item_group(&mut self, arg: &ArrayLiteralItemGroup) -> Evaluated { match arg { ArrayLiteralItemGroup::ExpressionArrayLiteralItemOpt(x) => { - let exp_eval = self.expression(x.expression.as_ref()); + let mut exp_eval = self.expression(x.expression.as_ref()); if let Some(alio) = &x.array_literal_item_opt { let repeat_exp = self.expression(alio.expression.as_ref()); - self.do_concatenation(exp_eval, repeat_exp) + if let Some(value) = repeat_exp.get_value() { + exp_eval.set_array(vec![value as usize]); + exp_eval + } else { + Evaluated::create_unknown() + } } else { exp_eval } @@ -1375,8 +1476,9 @@ impl Evaluator { fn array_literal_list(&mut self, arg: &ArrayLiteralList) -> Evaluated { // Currently only checking for `Defaul Colon Expression` syntax - let e = self.array_literal_item(arg.array_literal_item.as_ref()); + let mut e = self.array_literal_item(arg.array_literal_item.as_ref()); if arg.array_literal_list_list.is_empty() { + e.set_array(vec![1]); e } else if e.is_known_static() { let is_known_static: bool = arg diff --git a/crates/analyzer/src/handlers/check_expression.rs b/crates/analyzer/src/handlers/check_expression.rs index 52176c03..9277f87b 100644 --- a/crates/analyzer/src/handlers/check_expression.rs +++ b/crates/analyzer/src/handlers/check_expression.rs @@ -1,7 +1,9 @@ use crate::analyzer_error::AnalyzerError; -use crate::evaluator::{EvaluatedError, Evaluator}; -use crate::symbol::{Direction, GenericBoundKind, SymbolId, SymbolKind}; +use crate::evaluator::{Evaluated, EvaluatedError, EvaluatedType, Evaluator}; +use crate::symbol::{Direction, GenericBoundKind, Symbol, SymbolId, SymbolKind}; use crate::symbol_table; +use std::collections::HashSet; +use veryl_parser::resource_table::TokenId; use veryl_parser::veryl_grammar_trait::*; use veryl_parser::veryl_token::TokenRange; use veryl_parser::veryl_walker::{Handler, HandlerPoint}; @@ -16,6 +18,9 @@ pub struct CheckExpression<'a> { in_inst_declaration: bool, port_direction: Option, in_input_port_default_value: bool, + disable: bool, + disable_block_beg: HashSet, + disable_block_end: HashSet, } impl<'a> CheckExpression<'a> { @@ -32,6 +37,49 @@ impl<'a> CheckExpression<'a> { .push(AnalyzerError::evaluated_error(self.text, e)); } } + + fn check_assignment( + &mut self, + src: &Evaluated, + dst: &Symbol, + dst_last_select: &[Select], + token: &TokenRange, + ) { + if let Some(dst_type) = dst.kind.get_type() { + if src.r#type != EvaluatedType::Unknown { + // check array dimension + let src_array_dim = src.get_array().unwrap().len(); + let mut dst_array_dim = dst_type.array.len(); + + for s in dst_last_select { + let (_, _, single) = self.evaluator.evaluate_select(s); + if single { + dst_array_dim = dst_array_dim.saturating_sub(1); + } + } + + if src_array_dim != dst_array_dim { + self.errors.push(AnalyzerError::mismatch_assignment( + &format!("{}-D array", src_array_dim), + &format!("{}-D array", dst_array_dim), + self.text, + token, + )); + } + + if dst_type.kind.is_2state() && src.is_4state() { + self.errors.push(AnalyzerError::mismatch_assignment( + "4-state value", + "2-state variable", + self.text, + token, + )); + } + + // TODO type checks + } + } + } } impl Handler for CheckExpression<'_> { @@ -61,31 +109,53 @@ fn is_defined_in_package(full_path: &[SymbolId]) -> bool { } impl VerylGrammarTrait for CheckExpression<'_> { + fn l_brace(&mut self, arg: &LBrace) -> Result<(), ParolError> { + if let HandlerPoint::Before = self.point { + if self.disable_block_beg.remove(&arg.l_brace_token.token.id) { + self.disable = true; + } + } + + Ok(()) + } + + fn r_brace(&mut self, arg: &RBrace) -> Result<(), ParolError> { + if let HandlerPoint::Before = self.point { + if self.disable_block_end.remove(&arg.r_brace_token.token.id) { + self.disable = false; + } + } + + Ok(()) + } + fn identifier_factor(&mut self, arg: &IdentifierFactor) -> Result<(), ParolError> { if let HandlerPoint::Before = self.point { - let expid = arg.expression_identifier.as_ref(); - if let Ok(rr) = symbol_table::resolve(expid) { - // Only generic const or globally visible identifier can be used as port default value - if self.in_input_port_default_value { - let port_default_available = match &rr.found.kind { - SymbolKind::SystemFunction => true, - SymbolKind::GenericParameter(x) => { - matches!(x.bound, GenericBoundKind::Const) + if !self.disable { + let expid = arg.expression_identifier.as_ref(); + if let Ok(rr) = symbol_table::resolve(expid) { + // Only generic const or globally visible identifier can be used as port default value + if self.in_input_port_default_value { + let port_default_available = match &rr.found.kind { + SymbolKind::SystemFunction => true, + SymbolKind::GenericParameter(x) => { + matches!(x.bound, GenericBoundKind::Const) + } + _ => is_defined_in_package(&rr.full_path), + }; + + if !port_default_available { + let identifier = rr.found.token.to_string(); + let token: TokenRange = arg.expression_identifier.as_ref().into(); + let kind_name = rr.found.kind.to_kind_name(); + + self.errors.push(AnalyzerError::invalid_factor( + &identifier, + &kind_name, + self.text, + &token, + )); } - _ => is_defined_in_package(&rr.full_path), - }; - - if !port_default_available { - let identifier = rr.found.token.to_string(); - let token: TokenRange = arg.expression_identifier.as_ref().into(); - let kind_name = rr.found.kind.to_kind_name(); - - self.errors.push(AnalyzerError::invalid_factor( - &identifier, - &kind_name, - self.text, - &token, - )); } } } @@ -94,124 +164,163 @@ impl VerylGrammarTrait for CheckExpression<'_> { } fn let_statement(&mut self, arg: &LetStatement) -> Result<(), ParolError> { - let exp = self.evaluator.expression(&arg.expression); - self.evaluated_error(&exp.errors); + if let HandlerPoint::Before = self.point { + if !self.disable { + let exp = self.evaluator.expression(&arg.expression); + self.evaluated_error(&exp.errors); - // TODO type check + if let Ok(dst) = symbol_table::resolve(arg.identifier.as_ref()) { + self.check_assignment(&exp, &dst.found, &[], &arg.into()); + } + } + } Ok(()) } fn identifier_statement(&mut self, arg: &IdentifierStatement) -> Result<(), ParolError> { - match arg.identifier_statement_group.as_ref() { - IdentifierStatementGroup::FunctionCall(_) => { - // TODO function check - } - IdentifierStatementGroup::Assignment(x) => { - let exp = self.evaluator.expression(&x.assignment.expression); - self.evaluated_error(&exp.errors); + if let HandlerPoint::Before = self.point { + if !self.disable { + match arg.identifier_statement_group.as_ref() { + IdentifierStatementGroup::FunctionCall(_) => { + // TODO function check + } + IdentifierStatementGroup::Assignment(x) => { + let exp = self.evaluator.expression(&x.assignment.expression); + self.evaluated_error(&exp.errors); - // TODO type check + if let Ok(dst) = symbol_table::resolve(arg.expression_identifier.as_ref()) { + let dst_last_select = arg.expression_identifier.last_select(); + self.check_assignment(&exp, &dst.found, &dst_last_select, &arg.into()); + } + } + } } } + Ok(()) } fn if_statement(&mut self, arg: &IfStatement) -> Result<(), ParolError> { - let exp = self.evaluator.expression(&arg.expression); - self.evaluated_error(&exp.errors); + if let HandlerPoint::Before = self.point { + if !self.disable { + let exp = self.evaluator.expression(&arg.expression); + self.evaluated_error(&exp.errors); - // TODO type check + // TODO type check - for x in &arg.if_statement_list { - let exp = self.evaluator.expression(&x.expression); - self.evaluated_error(&exp.errors); + for x in &arg.if_statement_list { + let exp = self.evaluator.expression(&x.expression); + self.evaluated_error(&exp.errors); - // TODO type check + // TODO type check + } + } } Ok(()) } fn if_reset_statement(&mut self, arg: &IfResetStatement) -> Result<(), ParolError> { - for x in &arg.if_reset_statement_list { - let exp = self.evaluator.expression(&x.expression); - self.evaluated_error(&exp.errors); + if let HandlerPoint::Before = self.point { + if !self.disable { + for x in &arg.if_reset_statement_list { + let exp = self.evaluator.expression(&x.expression); + self.evaluated_error(&exp.errors); - // TODO type check + // TODO type check + } + } } Ok(()) } fn return_statement(&mut self, arg: &ReturnStatement) -> Result<(), ParolError> { - let exp = self.evaluator.expression(&arg.expression); - self.evaluated_error(&exp.errors); + if let HandlerPoint::Before = self.point { + if !self.disable { + let exp = self.evaluator.expression(&arg.expression); + self.evaluated_error(&exp.errors); - // TODO type check + // TODO type check + } + } Ok(()) } fn for_statement(&mut self, arg: &ForStatement) -> Result<(), ParolError> { - let exp = self.evaluator.expression(&arg.range.expression); - self.evaluated_error(&exp.errors); + if let HandlerPoint::Before = self.point { + if !self.disable { + let exp = self.evaluator.expression(&arg.range.expression); + self.evaluated_error(&exp.errors); - // TODO type check + // TODO type check - if let Some(x) = &arg.range.range_opt { - let exp = self.evaluator.expression(&x.expression); - self.evaluated_error(&exp.errors); + if let Some(x) = &arg.range.range_opt { + let exp = self.evaluator.expression(&x.expression); + self.evaluated_error(&exp.errors); - // TODO type check - } + // TODO type check + } - if let Some(x) = &arg.for_statement_opt { - let exp = self.evaluator.expression(&x.expression); - self.evaluated_error(&exp.errors); + if let Some(x) = &arg.for_statement_opt { + let exp = self.evaluator.expression(&x.expression); + self.evaluated_error(&exp.errors); - // TODO type check + // TODO type check + } + } } Ok(()) } fn case_statement(&mut self, arg: &CaseStatement) -> Result<(), ParolError> { - let exp = self.evaluator.expression(&arg.expression); - self.evaluated_error(&exp.errors); + if let HandlerPoint::Before = self.point { + if !self.disable { + let exp = self.evaluator.expression(&arg.expression); + self.evaluated_error(&exp.errors); + } + } Ok(()) } fn case_condition(&mut self, arg: &CaseCondition) -> Result<(), ParolError> { - let range_items: Vec = arg.into(); + if let HandlerPoint::Before = self.point { + if !self.disable { + let range_items: Vec = arg.into(); - for x in range_items { - let exp = self.evaluator.expression(&x.range.expression); - self.evaluated_error(&exp.errors); + for x in range_items { + let exp = self.evaluator.expression(&x.range.expression); + self.evaluated_error(&exp.errors); - // TODO type check + // TODO type check - if !exp.is_known_static() { - self.errors - .push(AnalyzerError::invalid_case_condition_non_elaborative( - self.text, - &x.range.expression.as_ref().into(), - )); - } + if !exp.is_known_static() { + self.errors + .push(AnalyzerError::invalid_case_condition_non_elaborative( + self.text, + &x.range.expression.as_ref().into(), + )); + } - if let Some(x) = &x.range.range_opt { - let exp = self.evaluator.expression(&x.expression); - self.evaluated_error(&exp.errors); + if let Some(x) = &x.range.range_opt { + let exp = self.evaluator.expression(&x.expression); + self.evaluated_error(&exp.errors); - // TODO type check + // TODO type check - if !exp.is_known_static() { - self.errors - .push(AnalyzerError::invalid_case_condition_non_elaborative( - self.text, - &x.expression.as_ref().into(), - )); + if !exp.is_known_static() { + self.errors.push( + AnalyzerError::invalid_case_condition_non_elaborative( + self.text, + &x.expression.as_ref().into(), + ), + ); + } + } } } } @@ -220,52 +329,80 @@ impl VerylGrammarTrait for CheckExpression<'_> { } fn switch_condition(&mut self, arg: &SwitchCondition) -> Result<(), ParolError> { - let expressions: Vec = arg.into(); + if let HandlerPoint::Before = self.point { + if !self.disable { + let expressions: Vec = arg.into(); - for x in expressions { - let exp = self.evaluator.expression(&x); - self.evaluated_error(&exp.errors); + for x in expressions { + let exp = self.evaluator.expression(&x); + self.evaluated_error(&exp.errors); - // TODO type check + // TODO type check + } + } } Ok(()) } fn let_declaration(&mut self, arg: &LetDeclaration) -> Result<(), ParolError> { - let exp = self.evaluator.expression(&arg.expression); - self.evaluated_error(&exp.errors); + if let HandlerPoint::Before = self.point { + if !self.disable { + let exp = self.evaluator.expression(&arg.expression); + self.evaluated_error(&exp.errors); - // TODO type check + if let Ok(dst) = symbol_table::resolve(arg.identifier.as_ref()) { + self.check_assignment(&exp, &dst.found, &[], &arg.into()); + } + } + } Ok(()) } fn const_declaration(&mut self, arg: &ConstDeclaration) -> Result<(), ParolError> { - let exp = self.evaluator.expression(&arg.expression); - self.evaluated_error(&exp.errors); + if let HandlerPoint::Before = self.point { + if !self.disable { + let exp = self.evaluator.expression(&arg.expression); + self.evaluated_error(&exp.errors); - // TODO type check + if let Ok(dst) = symbol_table::resolve(arg.identifier.as_ref()) { + self.check_assignment(&exp, &dst.found, &[], &arg.into()); + } + } + } Ok(()) } fn assign_declaration(&mut self, arg: &AssignDeclaration) -> Result<(), ParolError> { - let exp = self.evaluator.expression(&arg.expression); - self.evaluated_error(&exp.errors); + if let HandlerPoint::Before = self.point { + if !self.disable { + let exp = self.evaluator.expression(&arg.expression); + self.evaluated_error(&exp.errors); - // TODO type check + if let Ok(dst) = symbol_table::resolve(arg.hierarchical_identifier.as_ref()) { + let dst_last_select = arg.hierarchical_identifier.last_select(); + self.check_assignment(&exp, &dst.found, &dst_last_select, &arg.into()); + } + } + } Ok(()) } fn enum_item(&mut self, arg: &EnumItem) -> Result<(), ParolError> { - if let Some(x) = &arg.enum_item_opt { - let exp = self.evaluator.expression(&x.expression); - self.evaluated_error(&exp.errors); + if let HandlerPoint::Before = self.point { + if !self.disable { + if let Some(x) = &arg.enum_item_opt { + let exp = self.evaluator.expression(&x.expression); + self.evaluated_error(&exp.errors); - // TODO type check + // TODO type check + } + } } + Ok(()) } @@ -282,10 +419,14 @@ impl VerylGrammarTrait for CheckExpression<'_> { } fn with_parameter_item(&mut self, arg: &WithParameterItem) -> Result<(), ParolError> { - let exp = self.evaluator.expression(&arg.expression); - self.evaluated_error(&exp.errors); + if let HandlerPoint::Before = self.point { + if !self.disable { + let exp = self.evaluator.expression(&arg.expression); + self.evaluated_error(&exp.errors); - // TODO type check + // TODO type check + } + } Ok(()) } @@ -295,11 +436,13 @@ impl VerylGrammarTrait for CheckExpression<'_> { HandlerPoint::Before => { self.port_direction = Some(arg.direction.as_ref().into()); - if let Some(x) = &arg.port_type_concrete_opt0 { - let exp = self.evaluator.expression(&x.port_default_value.expression); - self.evaluated_error(&exp.errors); + if !self.disable { + if let Some(x) = &arg.port_type_concrete_opt0 { + let exp = self.evaluator.expression(&x.port_default_value.expression); + self.evaluated_error(&exp.errors); - // TODO type check + // TODO type check + } } } HandlerPoint::After => self.port_direction = None, @@ -319,39 +462,79 @@ impl VerylGrammarTrait for CheckExpression<'_> { } fn generate_if_declaration(&mut self, arg: &GenerateIfDeclaration) -> Result<(), ParolError> { - let exp = self.evaluator.expression(&arg.expression); - self.evaluated_error(&exp.errors); + if let HandlerPoint::Before = self.point { + if !self.disable { + let exp = self.evaluator.expression(&arg.expression); + self.evaluated_error(&exp.errors); + + let mut already_enabled = false; + if let Some(value) = exp.get_value() { + if value == 0 { + let beg = arg.generate_named_block.l_brace.as_ref().into(); + let end = arg.generate_named_block.r_brace.as_ref().into(); + self.disable_block_beg.insert(beg); + self.disable_block_end.insert(end); + } else { + already_enabled = true; + } + } + + // TODO type check + + for x in &arg.generate_if_declaration_list { + let exp = self.evaluator.expression(&x.expression); + self.evaluated_error(&exp.errors); - // TODO type check + if let Some(value) = exp.get_value() { + if value == 0 || already_enabled { + let beg = x.generate_optional_named_block.l_brace.as_ref().into(); + let end = x.generate_optional_named_block.r_brace.as_ref().into(); + self.disable_block_beg.insert(beg); + self.disable_block_end.insert(end); + } else { + already_enabled = true; + } + } - for x in &arg.generate_if_declaration_list { - let exp = self.evaluator.expression(&x.expression); - self.evaluated_error(&exp.errors); + // TODO type check + } - // TODO type check + if let Some(x) = &arg.generate_if_declaration_opt { + if already_enabled { + let beg = x.generate_optional_named_block.l_brace.as_ref().into(); + let end = x.generate_optional_named_block.r_brace.as_ref().into(); + self.disable_block_beg.insert(beg); + self.disable_block_end.insert(end); + } + } + } } Ok(()) } fn generate_for_declaration(&mut self, arg: &GenerateForDeclaration) -> Result<(), ParolError> { - let exp = self.evaluator.expression(&arg.range.expression); - self.evaluated_error(&exp.errors); + if let HandlerPoint::Before = self.point { + if !self.disable { + let exp = self.evaluator.expression(&arg.range.expression); + self.evaluated_error(&exp.errors); - // TODO type check + // TODO type check - if let Some(x) = &arg.range.range_opt { - let exp = self.evaluator.expression(&x.expression); - self.evaluated_error(&exp.errors); + if let Some(x) = &arg.range.range_opt { + let exp = self.evaluator.expression(&x.expression); + self.evaluated_error(&exp.errors); - // TODO type check - } + // TODO type check + } - if let Some(x) = &arg.generate_for_declaration_opt { - let exp = self.evaluator.expression(&x.expression); - self.evaluated_error(&exp.errors); + if let Some(x) = &arg.generate_for_declaration_opt { + let exp = self.evaluator.expression(&x.expression); + self.evaluated_error(&exp.errors); - // TODO type check + // TODO type check + } + } } Ok(()) diff --git a/crates/analyzer/src/symbol.rs b/crates/analyzer/src/symbol.rs index a2f0ec0a..a8afd9b2 100644 --- a/crates/analyzer/src/symbol.rs +++ b/crates/analyzer/src/symbol.rs @@ -121,7 +121,7 @@ impl Symbol { SymbolKind::Variable(x) => { let mut evaluator = Evaluator::new(); let width = evaluator.type_width(x.r#type.clone()); - let array = evaluator.type_width(x.r#type.clone()); + let array = evaluator.type_array(x.r#type.clone()); if let (Some(width), Some(array)) = (width, array) { if x.r#type.kind.is_clock() { @@ -146,7 +146,8 @@ impl Symbol { Evaluated::create_unknown_static() } else { let signed = x.r#type.modifier.contains(&TypeModifier::Signed); - Evaluated::create_variable(signed, width, array) + let is_4state = x.r#type.kind.is_4state(); + Evaluated::create_variable(signed, is_4state, width, array) } } else { Evaluated::create_unknown() @@ -156,7 +157,7 @@ impl Symbol { if let Some(x) = &x.r#type { let mut evaluator = Evaluator::new(); let width = evaluator.type_width(x.clone()); - let array = evaluator.type_width(x.clone()); + let array = evaluator.type_array(x.clone()); if let (Some(width), Some(array)) = (width, array) { if x.kind.is_clock() { @@ -179,7 +180,8 @@ impl Symbol { Evaluated::create_reset(kind, width, array) } else { let signed = x.modifier.contains(&TypeModifier::Signed); - Evaluated::create_variable(signed, width, array) + let is_4state = x.kind.is_4state(); + Evaluated::create_variable(signed, is_4state, width, array) } } else { Evaluated::create_unknown() @@ -724,6 +726,23 @@ impl TypeKind { | TypeKind::ResetSyncLow ) } + + pub fn is_2state(&self) -> bool { + matches!( + self, + TypeKind::Bit + | TypeKind::U32 + | TypeKind::U64 + | TypeKind::I32 + | TypeKind::I64 + | TypeKind::F32 + | TypeKind::F64 + ) + } + + pub fn is_4state(&self) -> bool { + self.is_clock() | self.is_reset() | (*self == TypeKind::Logic) + } } #[derive(Debug, Clone, PartialEq, Eq)] diff --git a/crates/analyzer/src/tests.rs b/crates/analyzer/src/tests.rs index bbc8e89d..9cc14916 100644 --- a/crates/analyzer/src/tests.rs +++ b/crates/analyzer/src/tests.rs @@ -1310,6 +1310,46 @@ fn mismatch_type() { assert!(errors.is_empty()); } +#[test] +fn mismatch_assignment() { + let code = r#" + module ModuleA { + let _a: logic[2] = 1; + } + "#; + + let errors = analyze(code); + assert!(matches!( + errors[0], + AnalyzerError::MismatchAssignment { .. } + )); + + let code = r#" + module ModuleA { + var _a: logic[2]; + assign _a = 1; + } + "#; + + let errors = analyze(code); + assert!(matches!( + errors[0], + AnalyzerError::MismatchAssignment { .. } + )); + + let code = r#" + module ModuleA { + let _a: u32 = 'x; + } + "#; + + let errors = analyze(code); + assert!(matches!( + errors[0], + AnalyzerError::MismatchAssignment { .. } + )); +} + #[test] fn missing_if_reset() { let code = r#" @@ -2982,6 +3022,49 @@ fn invalid_test() { assert!(matches!(errors[0], AnalyzerError::InvalidTest { .. })); } +#[test] +fn invalid_select() { + let code = r#" + module ModuleA { + let _a: logic<2> = 1; + let _b: logic<2> = _a[2]; + } + "#; + + let errors = analyze(code); + assert!(matches!(errors[0], AnalyzerError::InvalidSelect { .. })); + + let code = r#" + module ModuleA { + let _a: logic[2] = '{1, 1}; + let _b: logic<2> = _a[2]; + } + "#; + + let errors = analyze(code); + assert!(matches!(errors[0], AnalyzerError::InvalidSelect { .. })); + + let code = r#" + module ModuleA { + let _a: logic<2> = 1; + let _b: logic<2> = _a[0:1]; + } + "#; + + let errors = analyze(code); + assert!(matches!(errors[0], AnalyzerError::InvalidSelect { .. })); + + let code = r#" + module ModuleA { + let _a: logic[2] = '{1, 1}; + let _b: logic[2] = _a[1:0]; + } + "#; + + let errors = analyze(code); + assert!(matches!(errors[0], AnalyzerError::InvalidSelect { .. })); +} + #[test] fn clock_domain() { let code = r#" @@ -3397,3 +3480,23 @@ fn evaluator() { assert_eq!((j.get_value(), j.get_total_width()), (Some(4), Some(32))); assert_eq!((k.get_value(), k.get_total_width()), (Some(3), Some(2))); } + +#[test] +fn skip_disabled_generate_block() { + let code = r#" + module ModuleA { + const X: u32 = 1; + + if X == 1 :label { + let _a: u32 = 1; + } else { + // This statement contains MismatchAssignment + // But it should be ignored because this block is disabled + let _a: u32 = 'x; + } + } + "#; + + let errors = analyze(code); + assert!(errors.is_empty()); +} diff --git a/crates/parser/src/veryl_grammar_trait.rs b/crates/parser/src/veryl_grammar_trait.rs index 71a75c3d..5e0262cd 100644 --- a/crates/parser/src/veryl_grammar_trait.rs +++ b/crates/parser/src/veryl_grammar_trait.rs @@ -1,4 +1,5 @@ pub use crate::generated::veryl_grammar_trait::*; +use crate::resource_table::TokenId; use crate::veryl_token::is_anonymous_token; use paste::paste; use std::fmt; @@ -262,3 +263,53 @@ impl fmt::Display for Direction { token.fmt(f) } } + +impl From<&LBrace> for TokenId { + fn from(value: &LBrace) -> Self { + value.l_brace_token.token.id + } +} + +impl From<&RBrace> for TokenId { + fn from(value: &RBrace) -> Self { + value.r_brace_token.token.id + } +} + +impl ExpressionIdentifier { + pub fn last_select(&self) -> Vec { + if self.hierarchical_identifier_list0.is_empty() { + self.hierarchical_identifier_list + .iter() + .map(|x| x.select.as_ref().clone()) + .collect() + } else { + self.hierarchical_identifier_list0 + .last() + .unwrap() + .hierarchical_identifier_list0_list + .iter() + .map(|x| x.select.as_ref().clone()) + .collect() + } + } +} diff --git a/crates/parser/src/veryl_token.rs b/crates/parser/src/veryl_token.rs index 194b5f06..97ad8732 100644 --- a/crates/parser/src/veryl_token.rs +++ b/crates/parser/src/veryl_token.rs @@ -398,6 +398,30 @@ impl_token_range!( r_brace_token ); impl_token_range!(TypeExpression, r#type, type_token, r_paren, r_paren_token); +impl_token_range!(LetStatement, r#let, let_token, semicolon, semicolon_token); +impl_token_range!(LetDeclaration, r#let, let_token, semicolon, semicolon_token); +impl_token_range!( + ConstDeclaration, + r#const, + const_token, + semicolon, + semicolon_token +); +impl_token_range!( + AssignDeclaration, + assign, + assign_token, + semicolon, + semicolon_token +); + +impl From<&IdentifierStatement> for TokenRange { + fn from(value: &IdentifierStatement) -> Self { + let beg: TokenRange = value.expression_identifier.as_ref().into(); + let end = value.semicolon.semicolon_token.token; + TokenRange { beg: beg.beg, end } + } +} impl From<&FactorGroup> for TokenRange { fn from(value: &FactorGroup) -> Self { diff --git a/testcases/map/testcases/sv/01_number.sv.map b/testcases/map/testcases/sv/01_number.sv.map index 18aed132..c91d41e1 100644 --- a/testcases/map/testcases/sv/01_number.sv.map +++ b/testcases/map/testcases/sv/01_number.sv.map @@ -1 +1 @@ -{"version":3,"file":"01_number.sv.map","sources":["../../../veryl/01_number.veryl"],"names":["","module","Module01",";","localparam","int unsigned","a","=","0123456789","aa","01234_56789","b","32'b01xzXZ","bb","32'b01_xz_XZ","bbb","32'sb01_xz_XZ","c","32'o01234567xzXZ","cc","32'o01234_567xzXZ","ccc","32'so01234_567xzXZ","d","32'd0123456789","dd","32'd01234_56789","ddd","32'sd01234_56789","e","128'h0123456789abcdefxzABCDEFXZ","ee","128'h01234_5678_9abc_defxz_ABCD_EFXZ","eee","128'sh01234_5678_9abc_defxz_ABCD_EFXZ","f","'0","ff","'1","fff","'x","ffff","'X","fffff","'z","ffffff","'Z","g","0123456789.0123456789","gg","0123456789.0123456789e+0123456789","ggg","0123456789.0123456789e-0123456789","gggg","0123456789.0123456789E+0123456789","ggggg","0123456789.0123456789E-0123456789","endmodule"],"mappings":"AAAAA,AAAAC,sBAAOC,QAASC;;IAEZC,WAAUC,aAAJC,GAAQC,EAAEC,UAAUL;IAC1BC,WAAUC,aAAJI,GAAQF,EAAEG,WAAWP;;;IAG3BC,WAAWC,aAALM,IAASJ,EAAEK,UAAUT;IAC3BC,WAAWC,aAALQ,IAASN,EAAEO,YAAYX;IAC7BC,WAAWC,aAALU,IAASR,EAAES,aAAab;;;IAG9BC,WAAWC,aAALY,IAASV,EAAEW,gBAAgBf;IACjCC,WAAWC,aAALc,IAASZ,EAAEa,iBAAiBjB;IAClCC,WAAWC,aAALgB,IAASd,EAAEe,kBAAkBnB;;;IAGnCC,WAAWC,aAALkB,IAAShB,EAAEiB,cAAcrB;IAC/BC,WAAWC,aAALoB,IAASlB,EAAEmB,eAAevB;IAChCC,WAAWC,aAALsB,IAASpB,EAAEqB,gBAAgBzB;;;IAGjCC,WAAWC,aAALwB,IAAStB,EAAEuB,+BAA+B3B;IAChDC,WAAWC,aAAL0B,IAASxB,EAAEyB,oCAAoC7B;IACrDC,WAAWC,aAAL4B,IAAS1B,EAAE2B,qCAAqC/B;;;IAGtDC,WAAcC,aAAR8B,OAAY5B,EAAE6B,EAAEjC;IACtBC,WAAcC,aAARgC,OAAY9B,EAAE+B,EAAEnC;IACtBC,WAAcC,aAARkC,OAAYhC,EAAEiC,EAAErC;IACtBC,WAAcC,aAARoC,OAAYlC,EAAEmC,EAAEvC;IACtBC,WAAcC,aAARsC,OAAYpC,EAAEqC,EAAEzC;IACtBC,WAAcC,aAARwC,OAAYtC,EAAEuC,EAAE3C;;;IAGtBC,WAAaC,aAAP0C,MAAWxC,EAAEyC,qBAAqB7C;IACxCC,WAAaC,aAAP4C,MAAW1C,EAAE2C,iCAAiC/C;IACpDC,WAAaC,aAAP8C,MAAW5C,EAAE6C,iCAAiCjD;IACpDC,WAAaC,aAAPgD,MAAW9C,EAAE+C,iCAAiCnD;IACpDC,WAAaC,aAAPkD,MAAWhD,EAAEiD,iCAAiCrD;AACxDsD"} \ No newline at end of file +{"version":3,"file":"01_number.sv.map","sources":["../../../veryl/01_number.veryl"],"names":["","module","Module01",";","localparam","int unsigned","a","=","0123456789","aa","01234_56789","logic","[","32","]","b","32'b01xzXZ","bb","32'b01_xz_XZ","bbb","32'sb01_xz_XZ","c","32'o01234567xzXZ","cc","32'o01234_567xzXZ","ccc","32'so01234_567xzXZ","d","32'd0123456789","dd","32'd01234_56789","ddd","32'sd01234_56789","128","e","128'h0123456789abcdefxzABCDEFXZ","ee","128'h01234_5678_9abc_defxz_ABCD_EFXZ","eee","128'sh01234_5678_9abc_defxz_ABCD_EFXZ","f","'0","ff","'1","fff","'x","ffff","'X","fffff","'z","ffffff","'Z","g","0123456789.0123456789","gg","0123456789.0123456789e+0123456789","ggg","0123456789.0123456789e-0123456789","gggg","0123456789.0123456789E+0123456789","ggggg","0123456789.0123456789E-0123456789","endmodule"],"mappings":"AAAAA,AAAAC,sBAAOC,QAASC;;IAEZC,WAAUC,aAAJC,GAAQC,EAAEC,UAAUL;IAC1BC,WAAUC,aAAJI,GAAQF,EAAEG,WAAWP;;;IAG3BC,WAAWO,MAAKC,CAACC,MAAEC,EAAbC,IAAeR,EAAES,UAAUb;IACjCC,WAAWO,MAAKC,CAACC,MAAEC,EAAbG,IAAeV,EAAEW,YAAYf;IACnCC,WAAWO,MAAKC,CAACC,MAAEC,EAAbK,IAAeZ,EAAEa,aAAajB;;;IAGpCC,WAAWO,MAAKC,CAACC,MAAEC,EAAbO,IAAed,EAAEe,gBAAgBnB;IACvCC,WAAWO,MAAKC,CAACC,MAAEC,EAAbS,IAAehB,EAAEiB,iBAAiBrB;IACxCC,WAAWO,MAAKC,CAACC,MAAEC,EAAbW,IAAelB,EAAEmB,kBAAkBvB;;;IAGzCC,WAAWC,aAALsB,IAASpB,EAAEqB,cAAczB;IAC/BC,WAAWC,aAALwB,IAAStB,EAAEuB,eAAe3B;IAChCC,WAAWC,aAAL0B,IAASxB,EAAEyB,gBAAgB7B;;;IAGjCC,WAAWO,MAAKC,CAACqB,OAAGnB,EAAdoB,IAAgB3B,EAAE4B,+BAA+BhC;IACvDC,WAAWO,MAAKC,CAACqB,OAAGnB,EAAdsB,IAAgB7B,EAAE8B,oCAAoClC;IAC5DC,WAAWO,MAAKC,CAACqB,OAAGnB,EAAdwB,IAAgB/B,EAAEgC,qCAAqCpC;;;IAG7DC,WAAcO,MAAKC,CAACC,MAAEC,EAAhB0B,OAAkBjC,EAAEkC,EAAEtC;IAC5BC,WAAcO,MAAKC,CAACC,MAAEC,EAAhB4B,OAAkBnC,EAAEoC,EAAExC;IAC5BC,WAAcO,MAAKC,CAACC,MAAEC,EAAhB8B,OAAkBrC,EAAEsC,EAAE1C;IAC5BC,WAAcO,MAAKC,CAACC,MAAEC,EAAhBgC,OAAkBvC,EAAEwC,EAAE5C;IAC5BC,WAAcO,MAAKC,CAACC,MAAEC,EAAhBkC,OAAkBzC,EAAE0C,EAAE9C;IAC5BC,WAAcO,MAAKC,CAACC,MAAEC,EAAhBoC,OAAkB3C,EAAE4C,EAAEhD;;;IAG5BC,WAAaC,aAAP+C,MAAW7C,EAAE8C,qBAAqBlD;IACxCC,WAAaC,aAAPiD,MAAW/C,EAAEgD,iCAAiCpD;IACpDC,WAAaC,aAAPmD,MAAWjD,EAAEkD,iCAAiCtD;IACpDC,WAAaC,aAAPqD,MAAWnD,EAAEoD,iCAAiCxD;IACpDC,WAAaC,aAAPuD,MAAWrD,EAAEsD,iCAAiC1D;AACxD2D"} \ No newline at end of file diff --git a/testcases/map/testcases/sv/02_builtin_type.sv.map b/testcases/map/testcases/sv/02_builtin_type.sv.map index c0342278..3fbe44c4 100644 --- a/testcases/map/testcases/sv/02_builtin_type.sv.map +++ b/testcases/map/testcases/sv/02_builtin_type.sv.map @@ -1 +1 @@ -{"version":3,"file":"02_builtin_type.sv.map","sources":["../../../veryl/02_builtin_type.veryl"],"names":["","module","Module02",";","int unsigned","_a","=","1","longint unsigned","_aa","int signed","_b","longint signed","_bb","shortreal","_c","real","_cc","logic","_d","[","10","]","_dd","][","_ddd","bit","_e","_ee","_eee","_f","_ff","_fff","_ffff","_fffff","_ffffff","endmodule"],"mappings":"AAAAA,AAAAC,sBAAOC,QAASC;;IAEHC,iBAALC;mBAASC,EAAEC,CAACJ;IACPK,iBAALC;oBAASH,EAAEC,CAACJ;;;IAGPO,eAALC;mBAASL,EAAEC,CAACJ;IACPS,eAALC;oBAASP,EAAEC,CAACJ;;;IAGPW,UAALC;mBAAST,EAAEC,CAACJ;IACPa,UAALC;oBAASX,EAAEC,CAACJ;;;IAGNe,uBAANC;mBAAoBb,EAAEC,CAACJ;IACjBe,MAAKE,CAACC,MAAEC,UAAdC;oBAAoBjB,EAAEC,CAACJ;IACjBe,MAAKE,CAACC,MAAEG,EAAEH,MAAEC,EAAlBG;qBAAoBnB,EAAEC,CAACJ;;;IAGjBuB,qBAANC;mBAAkBrB,EAAEC,CAACJ;IACfuB,IAAGN,CAACC,MAAEC,UAAZM;oBAAkBtB,EAAEC,CAACJ;IACfuB,IAAGN,CAACC,MAAEG,EAAEH,MAAEC,EAAhBO;qBAAkBvB,EAAEC,CAACJ;;;IAGZC,iBAAT0B,QAAaV,GAACC,IAAEC;mBAAEhB,EAAEC,CAACJ;IACZK,iBAATuB,QAAaX,GAACC,IAAEC;oBAAEhB,EAAEC,CAACJ;IACZO,iBAATsB,QAAaZ,GAACC,IAAEC;qBAAEhB,EAAEC,CAACJ;IACZS,iBAATqB,QAAab,GAACC,IAAEC;sBAAEhB,EAAEC,CAACJ;IACZW,iBAAToB,QAAad,GAACC,IAAEC;uBAAEhB,EAAEC,CAACJ;IACZa,iBAATmB,QAAaf,GAACC,IAAEC;wBAAEhB,EAAEC,CAACJ;AAC7BiC"} \ No newline at end of file +{"version":3,"file":"02_builtin_type.sv.map","sources":["../../../veryl/02_builtin_type.veryl"],"names":["","module","Module02",";","int unsigned","_a","=","1","longint unsigned","_aa","int signed","_b","longint signed","_bb","shortreal","_c","real","_cc","logic","_d","[","10","]","_dd","][","_ddd","bit","_e","_ee","_eee","_f","2","'{",",","}","_ff","_fff","_ffff","_fffff","_ffffff","endmodule"],"mappings":"AAAAA,AAAAC,sBAAOC,QAASC;;IAEHC,iBAALC;mBAASC,EAAEC,CAACJ;IACPK,iBAALC;oBAASH,EAAEC,CAACJ;;;IAGPO,eAALC;mBAASL,EAAEC,CAACJ;IACPS,eAALC;oBAASP,EAAEC,CAACJ;;;IAGPW,UAALC;mBAAST,EAAEC,CAACJ;IACPa,UAALC;oBAASX,EAAEC,CAACJ;;;IAGNe,uBAANC;mBAAoBb,EAAEC,CAACJ;IACjBe,MAAKE,CAACC,MAAEC,UAAdC;oBAAoBjB,EAAEC,CAACJ;IACjBe,MAAKE,CAACC,MAAEG,EAAEH,MAAEC,EAAlBG;qBAAoBnB,EAAEC,CAACJ;;;IAGjBuB,qBAANC;mBAAkBrB,EAAEC,CAACJ;IACfuB,IAAGN,CAACC,MAAEC,UAAZM;oBAAkBtB,EAAEC,CAACJ;IACfuB,IAAGN,CAACC,MAAEG,EAAEH,MAAEC,EAAhBO;qBAAkBvB,EAAEC,CAACJ;;;IAGZC,iBAAT0B,QAAaV,GAACW,GAACT;mBAAEhB,EAAE0B,EAAEzB,CAAC0B,EAAE1B,CAAC2B,CAAC/B;IACjBK,iBAAT2B,QAAaf,GAACW,GAACT;oBAAEhB,EAAE0B,EAAEzB,CAAC0B,EAAE1B,CAAC2B,CAAC/B;IACjBO,iBAAT0B,QAAahB,GAACW,GAACT;qBAAEhB,EAAE0B,EAAEzB,CAAC0B,EAAE1B,CAAC2B,CAAC/B;IACjBS,iBAATyB,QAAajB,GAACW,GAACT;sBAAEhB,EAAE0B,EAAEzB,CAAC0B,EAAE1B,CAAC2B,CAAC/B;IACjBW,iBAATwB,QAAalB,GAACW,GAACT;uBAAEhB,EAAE0B,EAAEzB,CAAC0B,EAAE1B,CAAC2B,CAAC/B;IACjBa,iBAATuB,QAAanB,GAACW,GAACT;wBAAEhB,EAAE0B,EAAEzB,CAAC0B,EAAE1B,CAAC2B,CAAC/B;AAClCqC"} \ No newline at end of file diff --git a/testcases/map/testcases/sv/12_always.sv.map b/testcases/map/testcases/sv/12_always.sv.map index f9bab109..44d80a76 100644 --- a/testcases/map/testcases/sv/12_always.sv.map +++ b/testcases/map/testcases/sv/12_always.sv.map @@ -1 +1 @@ -{"version":3,"file":"12_always.sv.map","sources":["../../../veryl/12_always.veryl"],"names":["","module","Module12_1","(","input","logic","i_clk",",","i_rst_n",")",";","a","b","c","always_ff","begin","if","=","0","end","else","~","endmodule","Module12_2","i_clk_p","i_clk_n","i_rst_ah","i_rst_al","i_rst_sh","i_rst_sl","aa","1","1'b0","[","]","5",":","10","d","for","i","g","e","int unsigned","always_comb","10'b0",".","10'b01z","+","16'hffff","*","3","/","4"],"mappings":"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"} \ No newline at end of file +{"version":3,"file":"12_always.sv.map","sources":["../../../veryl/12_always.veryl"],"names":["","module","Module12_1","(","input","logic","i_clk",",","i_rst_n",")",";","a","b","c","always_ff","begin","if","=","0","end","else","~","endmodule","Module12_2","i_clk_p","i_clk_n","i_rst_ah","i_rst_al","i_rst_sh","i_rst_sl","aa","1","[","10","]","1'b0","5",":","d","for","i","g","e","int unsigned","always_comb","10'b0",".","10'b01z","+","16'hffff","*","3","/","4"],"mappings":"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"} \ No newline at end of file diff --git a/testcases/map/testcases/sv/13_range_operator.sv.map b/testcases/map/testcases/sv/13_range_operator.sv.map index 98288146..52b25992 100644 --- a/testcases/map/testcases/sv/13_range_operator.sv.map +++ b/testcases/map/testcases/sv/13_range_operator.sv.map @@ -1 +1 @@ -{"version":3,"file":"13_range_operator.sv.map","sources":["../../../veryl/13_range_operator.veryl"],"names":["","module","Module13",";","logic","a","b","c","d","e","X","=","1","always_comb","[","0","]",":","+:","2","-:","endmodule"],"mappings":"AAAAA,AAAAC,sBAAOC,QAASC;IACLC,MAAHC,CAAQF;IACLC,MAAHE,CAAQH;IACLC,MAAHG,CAAQJ;IACLC,MAAHI,CAAQL;IACLC,MAAHK,CAAQN;IACLC,MAAHM;kBAASC,EAAEC,CAACT;;;IAGhBU,YAAOR,EAAEM,EAAED,CAACI,CAACC,CAACC,CAACb;;;IAGfU,YAAOP,EAAEK,EAAED,CAACI,CAACF,CAACK,CAACF,CAACC,CAACb;;;IAGjBU,YAAON,EAAEI,EAAED,CAACI,CAACF,CAACM,EAAEC,CAACH,CAACb;IAClBU,YAAOL,EAAEG,EAAED,CAACI,CAACF,CAACQ,EAAED,CAACH,CAACb;;;IAGlBU,YAAOJ,EAAEE,EAAED,CAACI,CAACF,GAAOO,KAAAA,EAACH,CAACb;AAC1BkB"} \ No newline at end of file +{"version":3,"file":"13_range_operator.sv.map","sources":["../../../veryl/13_range_operator.veryl"],"names":["","module","Module13",";","logic","a","b","c","d","e","[","10","]","X","=","1","always_comb","0",":","+:","2","-:","endmodule"],"mappings":"AAAAA,AAAAC,sBAAOC,QAASC;IACLC,eAAHC,CAAYF;IACTC,eAAHE,CAAYH;IACTC,eAAHG,CAAYJ;IACTC,eAAHI,CAAYL;IACTC,eAAHK,CAAYN;IACTC,MAAKM,CAACC,MAAEC,EAAXC;kBAAaC,EAAEC,CAACZ;;;IAGpBa,YAAOX,EAAES,EAAED,CAACH,CAACO,CAACL,CAACT;;;IAGfa,YAAOV,EAAEQ,EAAED,CAACH,CAACK,CAACG,CAACD,CAACL,CAACT;;;IAGjBa,YAAOT,EAAEO,EAAED,CAACH,CAACK,CAACI,EAAEC,CAACR,CAACT;IAClBa,YAAOR,EAAEM,EAAED,CAACH,CAACK,CAACM,EAAED,CAACR,CAACT;;;IAGlBa,YAAOP,EAAEK,EAAED,CAACH,CAACK,GAAOK,KAAAA,EAACR,CAACT;AAC1BmB"} \ No newline at end of file diff --git a/testcases/map/testcases/sv/18_concatenation.sv.map b/testcases/map/testcases/sv/18_concatenation.sv.map index 6771a3d9..433e56d3 100644 --- a/testcases/map/testcases/sv/18_concatenation.sv.map +++ b/testcases/map/testcases/sv/18_concatenation.sv.map @@ -1 +1 @@ -{"version":3,"file":"18_concatenation.sv.map","sources":["../../../veryl/18_concatenation.veryl"],"names":["","module","Module18",";","logic","a","b","c","=","1","always_comb","{","[","10",":","0","]",",","}","4","endmodule"],"mappings":"AAAAA,AAAAC,sBAAOC,QAASC;IACLC,MAAHC,CAAQF;IACLC,MAAHE,CAAQH;IACLC,MAAHG;kBAASC,EAAEC,CAACN;;IAEhBO,YAAOL,EAAEG,EAAEG,CAACN,CAACO,CAACC,EAAEC,CAACC,CAACC,CAACC,EAAEV,CAAEW,CAACf;IACxBO,YAAOJ,EAAEE,EAAEG,EAAgBE,GAAfR,CAACO,CAACC,EAAEC,CAACC,CAACC,GAAWC,GAAWE,EAATZ,GAAUW,CAACf;AAC9CiB"} \ No newline at end of file +{"version":3,"file":"18_concatenation.sv.map","sources":["../../../veryl/18_concatenation.veryl"],"names":["","module","Module18",";","logic","[","20","]","a","b","c","=","1","always_comb","{","10",":","0",",","}","4","endmodule"],"mappings":"AAAAA,AAAAC,sBAAOC,QAASC;IACLC,MAAKC,CAACC,MAAEC,EAAXC,CAAYL;IACTC,eAAHK,CAAYN;IACTC,eAAHM;kBAAaC,EAAEC,CAACT;;IAEpBU,YAAOL,EAAEG,EAAEG,CAACN,CAACH,CAACU,EAAEC,CAACC,CAACV,CAACW,EAAER,CAAES,CAAChB;IACxBU,YAAOJ,EAAEE,EAAEG,EAAgBC,GAAfP,CAACH,CAACU,EAAEC,CAACC,CAACV,GAAWW,GAAWE,EAATV,GAAUS,CAAChB;AAC9CkB"} \ No newline at end of file diff --git a/testcases/map/testcases/sv/26_array.sv.map b/testcases/map/testcases/sv/26_array.sv.map index 89881fc4..d4099e7f 100644 --- a/testcases/map/testcases/sv/26_array.sv.map +++ b/testcases/map/testcases/sv/26_array.sv.map @@ -1 +1 @@ -{"version":3,"file":"26_array.sv.map","sources":["../../../veryl/26_array.veryl"],"names":["","module","Module26",";","logic","[","10","]","_a","=","1","][","_b","_c","_d","endmodule"],"mappings":"AAAAA,AAAAC,sBAAOC,QAASC;IACJC,MAAKC,CAACC,MAAEC,UAAZC;mBAA2BC,EAAEC,CAACP;IAC1BC,MAAKC,CAACC,MAAEK,EAAEL,MAAEC,EAAhBK;mBAA2BH,EAAEC,CAACP;IAC1BC,MAAKC,CAACC,MAAEK,EAAEL,MAAEC,EAAhBM,GAAkBR,GAACC,IAAEC;mBAAME,EAAEC,CAACP;IAC1BC,MAAKC,CAACC,MAAEK,EAAEL,MAAEC,EAAhBO,GAAkBT,GAACC,IAAEK,IAAEL,IAAEC;mBAAEE,EAAEC,CAACP;AACtCY"} \ No newline at end of file +{"version":3,"file":"26_array.sv.map","sources":["../../../veryl/26_array.veryl"],"names":["","module","Module26",";","logic","[","10","]","_a","=","1","][","_b","_c","2","'{",",","}","_d","endmodule"],"mappings":"AAAAA,AAAAC,sBAAOC,QAASC;IACJC,MAAKC,CAACC,MAAEC,UAAZC;mBAAyBC,EAAEC,CAACP;IACxBC,MAAKC,CAACC,MAAEK,EAAEL,MAAEC,EAAhBK;mBAAyBH,EAAEC,CAACP;IACxBC,MAAKC,CAACC,MAAEK,EAAEL,MAAEC,EAAhBM,GAAkBR,GAACS,GAACP;mBAAKE,EAAEM,EAAEL,CAACM,EAAEN,CAACO,CAACd;IAC9BC,MAAKC,CAACC,MAAEK,EAAEL,MAAEC,EAAhBW,GAAkBb,GAACS,GAACH,IAAEG,GAACP;mBAAEE,EAAEM,EAAEA,EAAEL,CAACM,EAAEN,CAACO,CAACD,EAAED,EAAEL,CAACM,EAAEN,CAACO,CAACA,CAACd;AACtDgB"} \ No newline at end of file diff --git a/testcases/map/testcases/sv/34_width_all_set.sv.map b/testcases/map/testcases/sv/34_width_all_set.sv.map index bffed72e..0c6c26ed 100644 --- a/testcases/map/testcases/sv/34_width_all_set.sv.map +++ b/testcases/map/testcases/sv/34_width_all_set.sv.map @@ -1 +1 @@ -{"version":3,"file":"34_width_all_set.sv.map","sources":["../../../veryl/34_width_all_set.veryl"],"names":["","module","Module34",";","localparam","int unsigned","a0","=","'0","a1","'1","a2","'x","a3","'z","a4","10'b0000000000","a5","10'b1111111111","a6","10'bxxxxxxxxxx","a7","10'bzzzzzzzzzz","endmodule"],"mappings":"AAAAA,AAAAC,sBAAOC,QAASC;IACZC,WAAUC,aAAJC,GAAQC,EAAEC,EAAEL;IAClBC,WAAUC,aAAJI,GAAQF,EAAEG,EAAEP;IAClBC,WAAUC,aAAJM,GAAQJ,EAAEK,EAAET;IAClBC,WAAUC,aAAJQ,GAAQN,EAAEO,EAAEX;IAClBC,WAAUC,aAAJU,GAAQR,EAAES,cAAIb;IACpBC,WAAUC,aAAJY,GAAQV,EAAEW,cAAIf;IACpBC,WAAUC,aAAJc,GAAQZ,EAAEa,cAAIjB;IACpBC,WAAUC,aAAJgB,GAAQd,EAAEe,cAAInB;AACxBoB"} \ No newline at end of file +{"version":3,"file":"34_width_all_set.sv.map","sources":["../../../veryl/34_width_all_set.veryl"],"names":["","module","Module34",";","logic","[","32","]","_a0","=","'0","_a1","'1","_a2","'x","_a3","'z","_a4","10'b0000000000","_a5","10'b1111111111","_a6","10'bxxxxxxxxxx","_a7","10'bzzzzzzzzzz","endmodule"],"mappings":"AAAAA,AAAAC,sBAAOC,QAASC;IACHC,MAAKC,CAACC,MAAEC,EAAbC;oBAAeC,EAAEC,EAAEP;IACdC,MAAKC,CAACC,MAAEC,EAAbI;oBAAeF,EAAEG,EAAET;IACdC,MAAKC,CAACC,MAAEC,EAAbM;oBAAeJ,EAAEK,EAAEX;IACdC,MAAKC,CAACC,MAAEC,EAAbQ;oBAAeN,EAAEO,EAAEb;IACdC,MAAKC,CAACC,MAAEC,EAAbU;oBAAeR,EAAES,cAAIf;IAChBC,MAAKC,CAACC,MAAEC,EAAbY;oBAAeV,EAAEW,cAAIjB;IAChBC,MAAKC,CAACC,MAAEC,EAAbc;oBAAeZ,EAAEa,cAAInB;IAChBC,MAAKC,CAACC,MAAEC,EAAbgB;oBAAed,EAAEe,cAAIrB;AAC7BsB"} \ No newline at end of file diff --git a/testcases/sv/01_number.sv b/testcases/sv/01_number.sv index 278c6ad7..630b0a45 100644 --- a/testcases/sv/01_number.sv +++ b/testcases/sv/01_number.sv @@ -4,14 +4,14 @@ module veryl_testcase_Module01; localparam int unsigned aa = 01234_56789; // binary - localparam int unsigned b = 32'b01xzXZ; - localparam int unsigned bb = 32'b01_xz_XZ; - localparam int unsigned bbb = 32'sb01_xz_XZ; + localparam logic [32-1:0] b = 32'b01xzXZ; + localparam logic [32-1:0] bb = 32'b01_xz_XZ; + localparam logic [32-1:0] bbb = 32'sb01_xz_XZ; // octal - localparam int unsigned c = 32'o01234567xzXZ; - localparam int unsigned cc = 32'o01234_567xzXZ; - localparam int unsigned ccc = 32'so01234_567xzXZ; + localparam logic [32-1:0] c = 32'o01234567xzXZ; + localparam logic [32-1:0] cc = 32'o01234_567xzXZ; + localparam logic [32-1:0] ccc = 32'so01234_567xzXZ; // decimal localparam int unsigned d = 32'd0123456789; @@ -19,17 +19,17 @@ module veryl_testcase_Module01; localparam int unsigned ddd = 32'sd01234_56789; // hex - localparam int unsigned e = 128'h0123456789abcdefxzABCDEFXZ; - localparam int unsigned ee = 128'h01234_5678_9abc_defxz_ABCD_EFXZ; - localparam int unsigned eee = 128'sh01234_5678_9abc_defxz_ABCD_EFXZ; + localparam logic [128-1:0] e = 128'h0123456789abcdefxzABCDEFXZ; + localparam logic [128-1:0] ee = 128'h01234_5678_9abc_defxz_ABCD_EFXZ; + localparam logic [128-1:0] eee = 128'sh01234_5678_9abc_defxz_ABCD_EFXZ; // all0, all1, allx, allz - localparam int unsigned f = '0; - localparam int unsigned ff = '1; - localparam int unsigned fff = 'x; - localparam int unsigned ffff = 'X; - localparam int unsigned fffff = 'z; - localparam int unsigned ffffff = 'Z; + localparam logic [32-1:0] f = '0; + localparam logic [32-1:0] ff = '1; + localparam logic [32-1:0] fff = 'x; + localparam logic [32-1:0] ffff = 'X; + localparam logic [32-1:0] fffff = 'z; + localparam logic [32-1:0] ffffff = 'Z; // floating point localparam int unsigned g = 0123456789.0123456789; diff --git a/testcases/sv/02_builtin_type.sv b/testcases/sv/02_builtin_type.sv index 819350af..d4ddd108 100644 --- a/testcases/sv/02_builtin_type.sv +++ b/testcases/sv/02_builtin_type.sv @@ -34,17 +34,17 @@ module veryl_testcase_Module02; always_comb _eee = 1; // array - int unsigned _f [0:10-1]; - always_comb _f = 1; - longint unsigned _ff [0:10-1]; - always_comb _ff = 1; - int signed _fff [0:10-1]; - always_comb _fff = 1; - longint signed _ffff [0:10-1]; - always_comb _ffff = 1; - shortreal _fffff [0:10-1]; - always_comb _fffff = 1; - real _ffffff [0:10-1]; - always_comb _ffffff = 1; + int unsigned _f [0:2-1]; + always_comb _f = '{1, 1}; + longint unsigned _ff [0:2-1]; + always_comb _ff = '{1, 1}; + int signed _fff [0:2-1]; + always_comb _fff = '{1, 1}; + longint signed _ffff [0:2-1]; + always_comb _ffff = '{1, 1}; + shortreal _fffff [0:2-1]; + always_comb _fffff = '{1, 1}; + real _ffffff [0:2-1]; + always_comb _ffffff = '{1, 1}; endmodule //# sourceMappingURL=../map/testcases/sv/02_builtin_type.sv.map diff --git a/testcases/sv/12_always.sv b/testcases/sv/12_always.sv index ac2822c0..98b408c9 100644 --- a/testcases/sv/12_always.sv +++ b/testcases/sv/12_always.sv @@ -37,11 +37,11 @@ module veryl_testcase_Module12_2 ( input logic i_rst_sh, input logic i_rst_sl ); - logic a ; - logic aa; - logic b ; + logic a ; + logic aa; + logic b ; always_comb b = 1; - logic c ; + logic [10-1:0] c ; always_comb c = 1; // always_ff declaration with default polarity diff --git a/testcases/sv/13_range_operator.sv b/testcases/sv/13_range_operator.sv index 1e26f036..72e95556 100644 --- a/testcases/sv/13_range_operator.sv +++ b/testcases/sv/13_range_operator.sv @@ -1,10 +1,10 @@ module veryl_testcase_Module13; - logic a; - logic b; - logic c; - logic d; - logic e; - logic X; + logic a; + logic b; + logic c; + logic d; + logic e; + logic [10-1:0] X; always_comb X = 1; // bit select diff --git a/testcases/sv/18_concatenation.sv b/testcases/sv/18_concatenation.sv index 025af14f..a09bc181 100644 --- a/testcases/sv/18_concatenation.sv +++ b/testcases/sv/18_concatenation.sv @@ -1,7 +1,7 @@ module veryl_testcase_Module18; - logic a; - logic b; - logic c; + logic [20-1:0] a; + logic b; + logic c; always_comb c = 1; always_comb a = {a[10:0], c}; diff --git a/testcases/sv/26_array.sv b/testcases/sv/26_array.sv index e2562f22..d4091c82 100644 --- a/testcases/sv/26_array.sv +++ b/testcases/sv/26_array.sv @@ -1,11 +1,11 @@ module veryl_testcase_Module26; - logic [10-1:0] _a ; + logic [10-1:0] _a ; always_comb _a = 1; - logic [10-1:0][10-1:0] _b ; + logic [10-1:0][10-1:0] _b ; always_comb _b = 1; - logic [10-1:0][10-1:0] _c [0:10-1] ; - always_comb _c = 1; - logic [10-1:0][10-1:0] _d [0:10-1][0:10-1]; - always_comb _d = 1; + logic [10-1:0][10-1:0] _c [0:2-1] ; + always_comb _c = '{1, 1}; + logic [10-1:0][10-1:0] _d [0:2-1][0:2-1]; + always_comb _d = '{'{1, 1}, '{1, 1}}; endmodule //# sourceMappingURL=../map/testcases/sv/26_array.sv.map diff --git a/testcases/sv/34_width_all_set.sv b/testcases/sv/34_width_all_set.sv index 25d65f0c..fdb16ee8 100644 --- a/testcases/sv/34_width_all_set.sv +++ b/testcases/sv/34_width_all_set.sv @@ -1,11 +1,19 @@ module veryl_testcase_Module34; - localparam int unsigned a0 = '0; - localparam int unsigned a1 = '1; - localparam int unsigned a2 = 'x; - localparam int unsigned a3 = 'z; - localparam int unsigned a4 = 10'b0000000000; - localparam int unsigned a5 = 10'b1111111111; - localparam int unsigned a6 = 10'bxxxxxxxxxx; - localparam int unsigned a7 = 10'bzzzzzzzzzz; + logic [32-1:0] _a0; + always_comb _a0 = '0; + logic [32-1:0] _a1; + always_comb _a1 = '1; + logic [32-1:0] _a2; + always_comb _a2 = 'x; + logic [32-1:0] _a3; + always_comb _a3 = 'z; + logic [32-1:0] _a4; + always_comb _a4 = 10'b0000000000; + logic [32-1:0] _a5; + always_comb _a5 = 10'b1111111111; + logic [32-1:0] _a6; + always_comb _a6 = 10'bxxxxxxxxxx; + logic [32-1:0] _a7; + always_comb _a7 = 10'bzzzzzzzzzz; endmodule //# sourceMappingURL=../map/testcases/sv/34_width_all_set.sv.map diff --git a/testcases/veryl/01_number.veryl b/testcases/veryl/01_number.veryl index 5dcb1064..e0191e7a 100644 --- a/testcases/veryl/01_number.veryl +++ b/testcases/veryl/01_number.veryl @@ -4,14 +4,14 @@ module Module01 { const aa: u32 = 01234_56789; // binary - const b : u32 = 32'b01xzXZ; - const bb : u32 = 32'b01_xz_XZ; - const bbb: u32 = 32'sb01_xz_XZ; + const b : logic<32> = 32'b01xzXZ; + const bb : logic<32> = 32'b01_xz_XZ; + const bbb: logic<32> = 32'sb01_xz_XZ; // octal - const c : u32 = 32'o01234567xzXZ; - const cc : u32 = 32'o01234_567xzXZ; - const ccc: u32 = 32'so01234_567xzXZ; + const c : logic<32> = 32'o01234567xzXZ; + const cc : logic<32> = 32'o01234_567xzXZ; + const ccc: logic<32> = 32'so01234_567xzXZ; // decimal const d : u32 = 32'd0123456789; @@ -19,17 +19,17 @@ module Module01 { const ddd: u32 = 32'sd01234_56789; // hex - const e : u32 = 128'h0123456789abcdefxzABCDEFXZ; - const ee : u32 = 128'h01234_5678_9abc_defxz_ABCD_EFXZ; - const eee: u32 = 128'sh01234_5678_9abc_defxz_ABCD_EFXZ; + const e : logic<128> = 128'h0123456789abcdefxzABCDEFXZ; + const ee : logic<128> = 128'h01234_5678_9abc_defxz_ABCD_EFXZ; + const eee: logic<128> = 128'sh01234_5678_9abc_defxz_ABCD_EFXZ; // all0, all1, allx, allz - const f : u32 = '0; - const ff : u32 = '1; - const fff : u32 = 'x; - const ffff : u32 = 'X; - const fffff : u32 = 'z; - const ffffff: u32 = 'Z; + const f : logic<32> = '0; + const ff : logic<32> = '1; + const fff : logic<32> = 'x; + const ffff : logic<32> = 'X; + const fffff : logic<32> = 'z; + const ffffff: logic<32> = 'Z; // floating point const g : u32 = 0123456789.0123456789; diff --git a/testcases/veryl/02_builtin_type.veryl b/testcases/veryl/02_builtin_type.veryl index 959fa40e..f71d6101 100644 --- a/testcases/veryl/02_builtin_type.veryl +++ b/testcases/veryl/02_builtin_type.veryl @@ -22,10 +22,10 @@ module Module02 { let _eee: bit<10, 10> = 1; // array - let _f : u32 [10] = 1; - let _ff : u64 [10] = 1; - let _fff : i32 [10] = 1; - let _ffff : i64 [10] = 1; - let _fffff : f32 [10] = 1; - let _ffffff: f64 [10] = 1; + let _f : u32 [2] = '{1, 1}; + let _ff : u64 [2] = '{1, 1}; + let _fff : i32 [2] = '{1, 1}; + let _ffff : i64 [2] = '{1, 1}; + let _fffff : f32 [2] = '{1, 1}; + let _ffffff: f64 [2] = '{1, 1}; } diff --git a/testcases/veryl/12_always.veryl b/testcases/veryl/12_always.veryl index 5df209e5..f42d9714 100644 --- a/testcases/veryl/12_always.veryl +++ b/testcases/veryl/12_always.veryl @@ -37,10 +37,10 @@ module Module12_2 ( i_rst_sh: input `_ reset_sync_high , i_rst_sl: input `_ reset_sync_low , ) { - var a : logic; - var aa: logic; - let b : logic = 1; - let c : logic = 1; + var a : logic ; + var aa: logic ; + let b : logic = 1; + let c : logic<10> = 1; // always_ff declaration with default polarity always_ff (i_clk, i_rst) { diff --git a/testcases/veryl/13_range_operator.veryl b/testcases/veryl/13_range_operator.veryl index 56d55489..a096fb0c 100644 --- a/testcases/veryl/13_range_operator.veryl +++ b/testcases/veryl/13_range_operator.veryl @@ -1,10 +1,10 @@ module Module13 { - var a: logic; - var b: logic; - var c: logic; - var d: logic; - var e: logic; - let X: logic = 1; + var a: logic ; + var b: logic ; + var c: logic ; + var d: logic ; + var e: logic ; + let X: logic<10> = 1; // bit select assign a = X[0]; diff --git a/testcases/veryl/18_concatenation.veryl b/testcases/veryl/18_concatenation.veryl index c8cf2866..0cd027c5 100644 --- a/testcases/veryl/18_concatenation.veryl +++ b/testcases/veryl/18_concatenation.veryl @@ -1,7 +1,7 @@ module Module18 { - var a: logic; - var b: logic; - let c: logic = 1; + var a: logic<20>; + var b: logic ; + let c: logic = 1; assign a = {a[10:0], c,}; assign b = {a[10:0] repeat 10, c repeat 4}; diff --git a/testcases/veryl/26_array.veryl b/testcases/veryl/26_array.veryl index e9d713aa..0b8d027c 100644 --- a/testcases/veryl/26_array.veryl +++ b/testcases/veryl/26_array.veryl @@ -1,6 +1,6 @@ module Module26 { - let _a: logic<10> = 1; - let _b: logic<10, 10> = 1; - let _c: logic<10, 10> [10] = 1; - let _d: logic<10, 10> [10, 10] = 1; + let _a: logic<10> = 1; + let _b: logic<10, 10> = 1; + let _c: logic<10, 10> [2] = '{1, 1}; + let _d: logic<10, 10> [2, 2] = '{'{1, 1}, '{1, 1}}; } diff --git a/testcases/veryl/34_width_all_set.veryl b/testcases/veryl/34_width_all_set.veryl index 722ad320..68b7831f 100644 --- a/testcases/veryl/34_width_all_set.veryl +++ b/testcases/veryl/34_width_all_set.veryl @@ -1,10 +1,10 @@ module Module34 { - const a0: u32 = '0; - const a1: u32 = '1; - const a2: u32 = 'x; - const a3: u32 = 'z; - const a4: u32 = 10'0; - const a5: u32 = 10'1; - const a6: u32 = 10'x; - const a7: u32 = 10'z; + let _a0: logic<32> = '0; + let _a1: logic<32> = '1; + let _a2: logic<32> = 'x; + let _a3: logic<32> = 'z; + let _a4: logic<32> = 10'0; + let _a5: logic<32> = 10'1; + let _a6: logic<32> = 10'x; + let _a7: logic<32> = 10'z; }