kirigaya/digital-lsp-server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix some unwrap node None exception

Browse Source
This commit is contained in:
light-ly 2024-09-24 23:56:24 +08:00
parent 30c83dd9a3
commit ad6d2735a1
3 changed files with 352 additions and 370 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

143
src/core/fast_hdlparam.rs
View File

@ -144,90 +144,93 @@ impl FastHdlparam {
pub fn add_parameter(&mut self, name: &str, net_type: &str, init: &str, pub fn add_parameter(&mut self, name: &str, net_type: &str, init: &str,
start_line: u32, start_character: u32, end_line: u32, end_character: u32) { start_line: u32, start_character: u32, end_line: u32, end_character: u32) {
let last_module = self.content.last_mut().unwrap(); if let Some(last_module) = self.content.last_mut() {
let parameter = Parameter { let parameter = Parameter {
name: name.to_string(), name: name.to_string(),
net_type: net_type.to_string(), net_type: net_type.to_string(),
init: init.to_string(), init: init.to_string(),
range: Range { range: Range {
start: Position { start: Position {
line: start_line, character: start_character line: start_line, character: start_character
}, },
end: Position { end: Position {
line:end_line, character: end_character line:end_line, character: end_character
}
} }
} };
}; last_module.params.push(parameter);
last_module.params.push(parameter); }
} }
pub fn add_port(&mut self, name: &str, dir_type: &str, net_type: &str, width: &str, pub fn add_port(&mut self, name: &str, dir_type: &str, net_type: &str, width: &str,
start_line: u32, start_character: u32, end_line: u32, end_character: u32) { start_line: u32, start_character: u32, end_line: u32, end_character: u32) {
let last_module = self.content.last_mut().unwrap(); if let Some(last_module) = self.content.last_mut() {
let port = Port { let port = Port {
name: name.to_string(), name: name.to_string(),
dir_type: dir_type.to_string(), dir_type: dir_type.to_string(),
net_type: net_type.to_string(), net_type: net_type.to_string(),
width: width.to_string(), width: width.to_string(),
signed: "unsigned".to_string(), signed: "unsigned".to_string(),
range: Range { range: Range {
start: Position { start: Position {
line: start_line, character: start_character line: start_line, character: start_character
}, },
end: Position { end: Position {
line:end_line, character: end_character line:end_line, character: end_character
}
} }
} };
}; last_module.ports.push(port);
last_module.ports.push(port); last_module.ports.dedup();
last_module.ports.dedup(); }
} }
pub fn add_instance(&mut self, name: &str, inst_type: &str, line: u32, character: u32, end_character: u32, pub fn add_instance(&mut self, name: &str, inst_type: &str, line: u32, character: u32, end_character: u32,
param_start_line: u32, param_start_character: u32, param_end_line: u32, param_end_character: u32, param_start_line: u32, param_start_character: u32, param_end_line: u32, param_end_character: u32,
port_start_line: u32, port_start_character: u32, port_end_line: u32, port_end_character: u32 ) { port_start_line: u32, port_start_character: u32, port_end_line: u32, port_end_character: u32 ) {
let last_module = self.content.last_mut().unwrap(); if let Some(last_module) = self.content.last_mut() {
let instance = Instance { let instance = Instance {
name: name.to_string(), name: name.to_string(),
inst_type: inst_type.to_string(), inst_type: inst_type.to_string(),
instparams: if param_start_line == 0 { instparams: if param_start_line == 0 {
None None
} else { } else {
Some( Some(
Range { Range {
start: Position { start: Position {
line: param_start_line, character: param_start_character line: param_start_line, character: param_start_character
}, },
end: Position { end: Position {
line: param_end_line, character: param_end_character line: param_end_line, character: param_end_character
}
} }
} )
)
},
instports: if port_start_line == 0 {
None
} else {
Some(
Range {
start: Position {
line: port_start_line, character: port_start_character
},
end: Position {
line: port_end_line, character: port_end_character
}
}
)
},
range: Range {
start: Position {
line, character
}, },
end: Position { instports: if port_start_line == 0 {
line, character: end_character None
} else {
Some(
Range {
start: Position {
line: port_start_line, character: port_start_character
},
end: Position {
line: port_end_line, character: port_end_character
}
}
)
},
range: Range {
start: Position {
line, character
},
end: Position {
line, character: end_character
}
} }
} };
}; last_module.instances.push(instance);
last_module.instances.push(instance); }
} }
// pub fn print_fast(&self) { // pub fn print_fast(&self) {

577
src/core/sv_parser.rs
View File

@ -3,10 +3,9 @@ use std::io::BufRead;
use std::{collections::HashMap, io::BufReader}; use std::{collections::HashMap, io::BufReader};
use std::path::PathBuf; use std::path::PathBuf;
use anyhow::Error; use anyhow::Error;
use log::info;
use percent_encoding::percent_decode_str; use percent_encoding::percent_decode_str;
use std::env::consts::OS; use std::env::consts::OS;
use sv_parser::{parse_sv, unwrap_node, ConstantMintypmaxExpression, GateInstantiation, ListOfParameterAssignments, ListOfPortConnections, Locate, PackedDimensionRange, RefNode, SyntaxTree}; use sv_parser::{parse_sv, unwrap_node, Locate, RefNode, SyntaxTree};
use super::fast_hdlparam::{FastHdlparam, Macro}; use super::fast_hdlparam::{FastHdlparam, Macro};
@ -58,43 +57,50 @@ pub fn make_fast_from_syntaxtree(syntax_tree: &SyntaxTree, path: &PathBuf) -> Re
let content = syntax_tree.text.text().split('\n') let content = syntax_tree.text.text().split('\n')
.map(|s| s.to_string()) .map(|s| s.to_string())
.collect::<Vec<String>>(); .collect::<Vec<String>>();
// println!("{:?}", syntax_tree);
// &SyntaxTree is iterable // &SyntaxTree is iterable
for node in syntax_tree { for node in syntax_tree {
match node { match node {
RefNode::TextMacroDefinition(x) => { RefNode::TextMacroDefinition(x) => {
let start = unwrap_node!(x, TextMacroDefinition).unwrap(); if let Some(start) = unwrap_node!(x, TextMacroDefinition) {
let start = get_identifier(start).unwrap(); let start = get_identifier(start).unwrap();
let (start_line, start_character) = (start.line, get_column_by_offset(&content, start.offset)); let (start_line, start_character) = (start.line, get_column_by_offset(&content, start.offset));
let name = unwrap_node!(x, TextMacroName).unwrap(); let name = if let Some(name) = unwrap_node!(x, TextMacroName) {
let name = get_identifier(name).unwrap(); let name = get_identifier(name).unwrap();
let name = syntax_tree.get_str(&name).unwrap(); syntax_tree.get_str(&name).unwrap()
} else {
"unknown"
};
let mut params_vec = Vec::new(); let mut params_vec = Vec::new();
if let Some(RefNode::ListOfFormalArguments(x)) = unwrap_node!(x, ListOfFormalArguments) { if let Some(RefNode::ListOfFormalArguments(x)) = unwrap_node!(x, ListOfFormalArguments) {
for node in x { for node in x {
if let RefNode::FormalArgument(x) = node { if let RefNode::FormalArgument(x) = node {
let param_name = unwrap_node!(x, SimpleIdentifier).unwrap(); let param_name = if let Some(param_name) = unwrap_node!(x, SimpleIdentifier) {
let param_name = get_identifier(param_name).unwrap(); let param_name = get_identifier(param_name).unwrap();
let param_name = syntax_tree.get_str(&param_name).unwrap(); syntax_tree.get_str(&param_name).unwrap()
let param_val = match unwrap_node!(x, DefaultText) { } else {
Some(RefNode::DefaultText(x)) => syntax_tree.get_str(&x.nodes.0).unwrap(), "unknown"
_ => "Unknown" };
}; let param_val = match unwrap_node!(x, DefaultText) {
params_vec.push(crate::core::fast_hdlparam::DefineParam { name: param_name.to_string(), value: param_val.to_string() }); Some(RefNode::DefaultText(x)) => syntax_tree.get_str(&x.nodes.0).unwrap(),
_ => "Unknown"
};
params_vec.push(crate::core::fast_hdlparam::DefineParam { name: param_name.to_string(), value: param_val.to_string() });
}
} }
} }
let (end_line, end_character, replacement) = if let Some(RefNode::MacroText(x)) = unwrap_node!(x, MacroText) {
let replacement = x.nodes.0;
(replacement.line, get_column_by_offset(&content, replacement.offset) + replacement.len, syntax_tree.get_str(&replacement).unwrap())
} else {
(start_line, start_character + start.len, "unknown")
};
hdlparam.add_define(name, replacement, start_line, start_character as u32, end_line, end_character as u32, params_vec);
} }
let replacement = match unwrap_node!(x, MacroText) {
Some(RefNode::MacroText(x)) => Some(x.nodes.0),
// TODO ： 把下面的 contine 替换为 None 会报错
_ => continue
}.unwrap();
let (end_line, end_character) = (replacement.line, get_column_by_offset(&content, replacement.offset) + replacement.len);
let replacement = syntax_tree.get_str(&replacement).unwrap();
hdlparam.add_define(name, replacement, start_line, start_character as u32, end_line, end_character as u32, params_vec);
} }
RefNode::ModuleDeclaration(x) => { RefNode::ModuleDeclaration(x) => {
let id = unwrap_node!(x, ModuleIdentifier).unwrap(); let id = unwrap_node!(x, ModuleIdentifier).unwrap();
@ -105,110 +111,61 @@ pub fn make_fast_from_syntaxtree(syntax_tree: &SyntaxTree, path: &PathBuf) -> Re
hdlparam.new_module(name, line, character, end_character); hdlparam.new_module(name, line, character, end_character);
} }
RefNode::ParameterPortDeclaration(x) => { RefNode::ParameterPortDeclaration(x) => {
let id = unwrap_node!(x, ParameterIdentifier).unwrap(); if let Some(id) = unwrap_node!(x, ParameterIdentifier) {
let id = get_identifier(id).unwrap(); let id = get_identifier(id).unwrap();
let name = syntax_tree.get_str(&id).unwrap(); let name = syntax_tree.get_str(&id).unwrap();
match unwrap_node!(x, ParameterDeclarationParam, ParameterPortDeclarationParamList) { match unwrap_node!(x, ParameterDeclarationParam, ParameterPortDeclarationParamList) {
Some(RefNode::ParameterDeclarationParam(param_node)) => { Some(RefNode::ParameterDeclarationParam(param_node)) => {
// println!("{:?}", param_node); // println!("{:?}", param_node);
let keyword_locate = param_node.nodes.0.nodes.0; let keyword_locate = param_node.nodes.0.nodes.0;
// println!("keyword {:#?}", keyword_locate); // println!("keyword {:#?}", keyword_locate);
let (start_line, start_character) = (id.line, get_column_by_offset(&content, keyword_locate.offset) as u32); let (start_line, start_character) = (id.line, get_column_by_offset(&content, keyword_locate.offset) as u32);
let (mut end_line, mut end_character) = (id.line, start_character + id.len as u32); let (mut end_line, mut end_character) = (id.line, start_character + id.len as u32);
let net_type = match unwrap_node!(param_node, DataType) { let net_type = match unwrap_node!(param_node, DataType) {
Some(RefNode::DataType(data_type)) => { Some(RefNode::DataType(data_type)) => {
let id = unwrap_node!(data_type, SimpleIdentifier, Keyword); let id = unwrap_node!(data_type, SimpleIdentifier, Keyword);
if id == None { if id == None {
"wire" "wire"
} else { } else {
let id = get_identifier(id.unwrap()).unwrap(); let id = get_identifier(id.unwrap()).unwrap();
syntax_tree.get_str(&id).unwrap() syntax_tree.get_str(&id).unwrap()
}
} }
} _ => "wire"
_ => "wire" };
}; let init = if let Some(init) = unwrap_node!(param_node, ConstantMintypmaxExpression) {
let init = match unwrap_node!(param_node, ConstantMintypmaxExpression).unwrap() { match init {
RefNode::ConstantMintypmaxExpression(expression) => { RefNode::ConstantMintypmaxExpression(expression) => {
// println!("expression {:?}", expression); // println!("expression {:?}", x);
let (exp, last_locate) = parse_parameter_expression(&syntax_tree, expression); let param_init = sv_parser::NeedParseExpression::Parameter(expression.clone());
(end_line, end_character) = if last_locate != None { let (exp, last_locate) = parse_expression(&syntax_tree, &param_init);
// println!("param {:?} lastlocate {:?}", name, last_locate); (end_line, end_character) = if last_locate != None {
(last_locate.unwrap().line, (get_column_by_offset(&content, last_locate.unwrap().offset) + last_locate.unwrap().len) as u32) // println!("param {:?} lastlocate {:?}", name, last_locate);
} else { (last_locate.unwrap().line, (get_column_by_offset(&content, last_locate.unwrap().offset) + last_locate.unwrap().len) as u32)
(end_line, end_character) } else {
}; (end_line, end_character)
// println!("end pos {} {}", end_line, end_character); };
exp // println!("end pos {} {}", end_line, end_character);
} exp
_ => "unknown".to_string() }
}; _ => "unknown".to_string()
hdlparam.add_parameter(name, net_type, init.as_str(), start_line, start_character, end_line, end_character); }
} else {
"unknown".to_string()
};
hdlparam.add_parameter(name, net_type, init.as_str(), start_line, start_character, end_line, end_character);
}
_ => ()
} }
_ => ()
} }
} }
RefNode::PortDeclaration(x) => { RefNode::PortDeclaration(x) => {
let id = unwrap_node!(x, InputDeclaration, OutputDeclaration, InoutDeclaration).unwrap(); if let Some(id) = unwrap_node!(x, InputDeclaration, OutputDeclaration, InoutDeclaration) {
let id = get_identifier(id).unwrap(); let id = get_identifier(id).unwrap();
let dir_type = syntax_tree.get_str(&id).unwrap(); let dir_type = syntax_tree.get_str(&id).unwrap();
let (dir_line, dir_character) = (id.line, get_column_by_offset(&content, id.offset) as u32); let (dir_line, dir_character) = (id.line, get_column_by_offset(&content, id.offset) as u32);
let net_type = match unwrap_node!(x, DataType, ImplicitDataType) { let net_type = match unwrap_node!(x, DataType, ImplicitDataType) {
Some(RefNode::DataType(x)) => {
let id = unwrap_node!(x, Keyword);
if id != None {
syntax_tree.get_str(&get_identifier(id.unwrap()).unwrap()).unwrap()
} else {
"unknown"
}
},
Some(RefNode::ImplicitDataType(_)) => "wire",
_ => "unknown"
};
let width = match unwrap_node!(x, PackedDimensionRange) {
Some(RefNode::PackedDimensionRange(x)) => {
parse_port_expression(&syntax_tree, x)
}
_ => "1".to_string()
};
if let Some(RefNode::ListOfPortIdentifiers(x)) = unwrap_node!(x, ListOfPortIdentifiers) {
for node in x {
if let RefNode::PortIdentifier(x) = node {
let id = unwrap_node!(x, Identifier).unwrap();
let id = get_identifier(id).unwrap();
let name = syntax_tree.get_str(&id).unwrap();
let (start_line, start_character, end_line, end_character) =
(dir_line, dir_character, id.line, (get_column_by_offset(&content, id.offset) + id.len) as u32);
hdlparam.add_port(name, dir_type, net_type, width.as_str(), start_line, start_character,
end_line, end_character);
}
}
}
}
RefNode::AnsiPortDeclaration(x) => {
let id = unwrap_node!(x, PortIdentifier).unwrap();
let name_locate = get_identifier(id).unwrap();
let name = syntax_tree.get_str(&name_locate).unwrap();
let character = get_column_by_offset(&content, name_locate.offset);
let (end_line, end_character) = (name_locate.line, (character + name_locate.len) as u32);
let id = unwrap_node!(x, PortDirection);
let (start_line, start_character) = if id != None {
let id = id.unwrap();
let dir_locate = get_identifier(id).unwrap();
ansi_port_last_dir = syntax_tree.get_str(&dir_locate).unwrap();
(dir_locate.line, get_column_by_offset(&content, dir_locate.offset) as u32)
} else {
(name_locate.line, character as u32)
};
let net_type = if unwrap_node!(x, AnsiPortDeclarationVariable) != None {
"wire"
} else {
match unwrap_node!(x, DataType, ImplicitDataType) {
Some(RefNode::DataType(x)) => { Some(RefNode::DataType(x)) => {
let id = unwrap_node!(x, Keyword); let id = unwrap_node!(x, Keyword);
if id != None { if id != None {
@ -219,92 +176,139 @@ pub fn make_fast_from_syntaxtree(syntax_tree: &SyntaxTree, path: &PathBuf) -> Re
}, },
Some(RefNode::ImplicitDataType(_)) => "wire", Some(RefNode::ImplicitDataType(_)) => "wire",
_ => "unknown" _ => "unknown"
} };
};
let width = match unwrap_node!(x, PackedDimensionRange) { let width = match unwrap_node!(x, PackedDimensionRange) {
Some(RefNode::PackedDimensionRange(x)) => { Some(RefNode::PackedDimensionRange(x)) => {
parse_port_expression(&syntax_tree, x) let port_width = sv_parser::NeedParseExpression::Port(x.clone());
} let (width, _) = parse_expression(&syntax_tree, &port_width);
_ => "1".to_string() width
}; }
_ => "1".to_string()
};
hdlparam.add_port(name, ansi_port_last_dir, net_type, width.as_str(), start_line, start_character, end_line, end_character); if let Some(RefNode::ListOfPortIdentifiers(x)) = unwrap_node!(x, ListOfPortIdentifiers) {
for node in x {
if let RefNode::PortIdentifier(x) = node {
let id = unwrap_node!(x, Identifier).unwrap();
let id = get_identifier(id).unwrap();
let name = syntax_tree.get_str(&id).unwrap();
let (start_line, start_character, end_line, end_character) =
(dir_line, dir_character, id.line, (get_column_by_offset(&content, id.offset) + id.len) as u32);
hdlparam.add_port(name, dir_type, net_type, width.as_str(), start_line, start_character,
end_line, end_character);
}
}
}
}
}
RefNode::AnsiPortDeclaration(x) => {
if let Some(id) = unwrap_node!(x, PortIdentifier) {
let name_locate = get_identifier(id).unwrap();
let name = syntax_tree.get_str(&name_locate).unwrap();
let character = get_column_by_offset(&content, name_locate.offset);
let (end_line, end_character) = (name_locate.line, (character + name_locate.len) as u32);
let id = unwrap_node!(x, PortDirection);
let (start_line, start_character) = if id != None {
let id = id.unwrap();
let dir_locate = get_identifier(id).unwrap();
ansi_port_last_dir = syntax_tree.get_str(&dir_locate).unwrap();
(dir_locate.line, get_column_by_offset(&content, dir_locate.offset) as u32)
} else {
(name_locate.line, character as u32)
};
let net_type = if unwrap_node!(x, AnsiPortDeclarationVariable) != None {
"wire"
} else {
match unwrap_node!(x, DataType, ImplicitDataType) {
Some(RefNode::DataType(x)) => {
let id = unwrap_node!(x, Keyword);
if id != None {
syntax_tree.get_str(&get_identifier(id.unwrap()).unwrap()).unwrap()
} else {
"unknown"
}
},
Some(RefNode::ImplicitDataType(_)) => "wire",
_ => "unknown"
}
};
let width = match unwrap_node!(x, PackedDimensionRange) {
Some(RefNode::PackedDimensionRange(x)) => {
let port_width = sv_parser::NeedParseExpression::Port(x.clone());
let (width, _) = parse_expression(&syntax_tree, &port_width);
width
}
_ => "1".to_string()
};
hdlparam.add_port(name, ansi_port_last_dir, net_type, width.as_str(), start_line, start_character, end_line, end_character);
}
} }
RefNode::ModuleInstantiation(x) => { RefNode::ModuleInstantiation(x) => {
let id = unwrap_node!(x, ModuleIdentifier).unwrap(); if let Some(id) = unwrap_node!(x, ModuleIdentifier) {
let id = get_identifier(id).unwrap(); let id = get_identifier(id).unwrap();
let inst_type = syntax_tree.get_str(&id).unwrap(); let inst_type = syntax_tree.get_str(&id).unwrap();
let id = unwrap_node!(x, HierarchicalInstance).unwrap(); if let Some(id) = unwrap_node!(x, HierarchicalInstance) {
let id = get_identifier(id).unwrap(); let id = get_identifier(id).unwrap();
let name = syntax_tree.get_str(&id).unwrap(); let name = syntax_tree.get_str(&id).unwrap();
let (line, character) = (id.line, get_column_by_offset(&content, id.offset) as u32); let (line, character) = (id.line, get_column_by_offset(&content, id.offset) as u32);
let end_character = character + id.len as u32; let end_character = character + id.len as u32;
let (param_start_line, param_start_character, let (param_start_line, param_start_character,
param_end_line, param_end_character) = match unwrap_node!(x, ListOfParameterAssignments) { param_end_line, param_end_character) = match unwrap_node!(x, ListOfParameterAssignments) {
Some(RefNode::ListOfParameterAssignments(x)) => { Some(RefNode::ListOfParameterAssignments(x)) => {
let locate = get_inst_param_last_locate(x); let param_assignments = sv_parser::NeedGetLocate::ParamAssignments(x.clone());
if locate.is_none() { get_port_parameter_range(&content, &param_assignments)
(0, 0, 0, 0) }
} else { _ => (0, 0, 0, 0)
( };
locate.unwrap().0.line, get_column_by_offset(&content, locate.unwrap().0.offset) as u32,
locate.unwrap().1.line, (get_column_by_offset(&content, locate.unwrap().1.offset) + locate.unwrap().1.len) as u32 let (port_start_line, port_start_character,
) port_end_line, port_end_character) = match unwrap_node!(x, ListOfPortConnections) {
} Some(RefNode::ListOfPortConnections(x)) => {
let param_assignments = sv_parser::NeedGetLocate::PortConnections(x.clone());
get_port_parameter_range(&content, &param_assignments)
}
_ => (0, 0, 0, 0)
};
hdlparam.add_instance(name, inst_type, line, character, end_character,
param_start_line, param_start_character, param_end_line, param_end_character,
port_start_line, port_start_character, port_end_line, port_end_character
);
} }
_ => (0, 0, 0, 0) }
};
let (port_start_line, port_start_character,
port_end_line, port_end_character) = match unwrap_node!(x, ListOfPortConnections) {
Some(RefNode::ListOfPortConnections(x)) => {
let locate = get_inst_port_last_locate(x);
if locate.is_none() {
(0, 0, 0, 0)
} else {
(
locate.unwrap().0.line, get_column_by_offset(&content, locate.unwrap().0.offset) as u32,
locate.unwrap().1.line, (get_column_by_offset(&content, locate.unwrap().1.offset) + locate.unwrap().1.len) as u32
)
}
}
_ => (0, 0, 0, 0)
};
hdlparam.add_instance(name, inst_type, line, character, end_character,
param_start_line, param_start_character, param_end_line, param_end_character,
port_start_line, port_start_character, port_end_line, port_end_character
);
} }
RefNode::GateInstantiation(x) => { RefNode::GateInstantiation(x) => {
let id = unwrap_node!(x, GateInstantiation).unwrap(); let id = unwrap_node!(x, GateInstantiation).unwrap();
let id = get_identifier(id).unwrap(); let id = get_identifier(id).unwrap();
let inst_type = syntax_tree.get_str(&id).unwrap(); let inst_type = syntax_tree.get_str(&id).unwrap();
let id = unwrap_node!(x, NInputGateInstance, NOutputGateInstance).unwrap(); match unwrap_node!(x, NInputGateInstance, NOutputGateInstance) {
let id = get_identifier(id).unwrap(); Some(id) => {
let name = syntax_tree.get_str(&id).unwrap(); let id = get_identifier(id).unwrap();
let (line, character) = (id.line, get_column_by_offset(&content, id.offset) as u32); let name = syntax_tree.get_str(&id).unwrap();
let end_character = character + id.len as u32; let (line, character) = (id.line, get_column_by_offset(&content, id.offset) as u32);
let end_character = character + id.len as u32;
let locate = get_gateinst_port_locate(x);
let (param_start_line, param_start_character, param_end_line, param_end_character) = (0, 0, 0, 0); let gate_instance = sv_parser::NeedGetLocate::GateInstantiation(x.clone());
let (port_start_line, port_start_character, port_end_line, port_end_character) = if locate.is_none() { let (param_start_line, param_start_character, param_end_line, param_end_character) = (0, 0, 0, 0);
(0,0,0,0) let (port_start_line, port_start_character,
} else { port_end_line, port_end_character) = get_port_parameter_range(&content, &gate_instance);
(
locate.unwrap().0.line, get_column_by_offset(&content, locate.unwrap().0.offset) as u32, hdlparam.add_instance(name, inst_type, line, character, end_character,
locate.unwrap().1.line, (get_column_by_offset(&content, locate.unwrap().1.offset) + locate.unwrap().1.len) as u32 param_start_line, param_start_character, param_end_line, param_end_character,
) port_start_line, port_start_character, port_end_line, port_end_character
}; );
}
hdlparam.add_instance(name, inst_type, line, character, end_character, _ => ()
param_start_line, param_start_character, param_end_line, param_end_character, }
port_start_line, port_start_character, port_end_line, port_end_character
);
} }
_ => () _ => ()
} }
@ -313,81 +317,66 @@ pub fn make_fast_from_syntaxtree(syntax_tree: &SyntaxTree, path: &PathBuf) -> Re
Ok(hdlparam) Ok(hdlparam)
} }
fn get_inst_param_last_locate(x: &ListOfParameterAssignments) -> Option<(Locate, Locate)> { fn get_port_parameter_range(content: &[String], x: &sv_parser::NeedGetLocate) -> (u32, u32, u32, u32) {
let mut first_locate = Locate { offset: 0, line: 0, len: 0 }; let locate = get_first_last_locate(&x);
let mut last_locate = Locate { offset: 0, line: 0, len: 0 }; if locate.is_none() {
(0,0,0,0)
for node in x {
match unwrap_node!(node, SimpleIdentifier, Symbol) {
Some(RefNode::SimpleIdentifier(x)) => {
let locate = x.nodes.0;
if locate != last_locate { last_locate = locate; }
if first_locate.offset == 0 { first_locate = locate; };
}
Some(RefNode::Symbol(x)) => {
let locate = x.nodes.0;
if locate != last_locate { last_locate = locate; }
if first_locate.offset == 0 { first_locate = locate; };
}
_ => ()
}
}
if last_locate.offset == 0 {
None
} else { } else {
Some((first_locate, last_locate)) (
locate.unwrap().0.line, get_column_by_offset(&content, locate.unwrap().0.offset) as u32,
locate.unwrap().1.line, (get_column_by_offset(&content, locate.unwrap().1.offset) + locate.unwrap().1.len) as u32
)
} }
} }
fn get_inst_port_last_locate(x: &ListOfPortConnections) -> Option<(Locate, Locate)> { fn get_first_last_locate(x: &sv_parser::NeedGetLocate) -> Option<(Locate, Locate)> {
let mut first_locate = Locate { offset: 0, line: 0, len: 0 }; let mut first_locate = Locate { offset: 0, line: 0, len: 0 };
let mut last_locate = Locate { offset: 0, line: 0, len: 0 }; let mut last_locate = Locate { offset: 0, line: 0, len: 0 };
for node in x { match x {
match unwrap_node!(node, SimpleIdentifier, Symbol) { sv_parser::NeedGetLocate::GateInstantiation(gate) => {
Some(RefNode::SimpleIdentifier(x)) => { for node in gate {
let locate = x.nodes.0; match unwrap_node!(node, InputTerminal, OutputTerminal) {
if locate != last_locate { last_locate = locate; } Some(RefNode::InputTerminal(x)) => {
if first_locate.offset == 0 { first_locate = locate; }; if let Some(id) = unwrap_node!(x, Identifier) {
} let locate = get_identifier(id).unwrap();
Some(RefNode::Symbol(x)) => { if locate != last_locate { last_locate = locate; }
let locate = x.nodes.0; if first_locate.offset == 0 { first_locate = locate; };
if locate != last_locate { last_locate = locate; } } else if let Some(RefNode::Expression(x)) = unwrap_node!(x, Expression) {
if first_locate.offset == 0 { first_locate = locate; }; let exp = sv_parser::NeedParseExpression::Expression(x.clone());
} if let Some(locate) = parse_expression_only_locate(&exp) {
_ => () if locate != last_locate { last_locate = locate; }
} if first_locate.offset == 0 { first_locate = locate; };
} }
}
if last_locate.offset == 0 { }
None Some(RefNode::OutputTerminal(x)) => {
} else { let id = unwrap_node!(x, Identifier).unwrap();
Some((first_locate, last_locate)) let locate = get_identifier(id).unwrap();
} if locate != last_locate { last_locate = locate; }
} if first_locate.offset == 0 { first_locate = locate; };
}
fn get_gateinst_port_locate(x: &GateInstantiation) -> Option<(Locate, Locate)> { _ => ()
let mut first_locate = Locate { offset: 0, line: 0, len: 0 };
let mut last_locate = Locate { offset: 0, line: 0, len: 0 };
for node in x {
match unwrap_node!(node, InputTerminal, OutputTerminal) {
Some(RefNode::InputTerminal(x)) => {
let id = unwrap_node!(x, Identifier).unwrap();
let locate = get_identifier(id).unwrap();
if locate != last_locate { last_locate = locate; }
if first_locate.offset == 0 { first_locate = locate; };
}
Some(RefNode::OutputTerminal(x)) => {
let id = unwrap_node!(x, Identifier).unwrap();
let locate = get_identifier(id).unwrap();
if locate != last_locate {
last_locate = locate;
} }
} }
_ => ()
} }
_ => {
for node in x {
match unwrap_node!(node, SimpleIdentifier, Symbol) {
Some(RefNode::SimpleIdentifier(x)) => {
let locate = x.nodes.0;
if locate != last_locate { last_locate = locate; }
if first_locate.offset == 0 { first_locate = locate; };
}
Some(RefNode::Symbol(x)) => {
let locate = x.nodes.0;
if locate != last_locate { last_locate = locate; }
if first_locate.offset == 0 { first_locate = locate; };
}
_ => ()
}
}
}
} }
if last_locate.offset == 0 { if last_locate.offset == 0 {
@ -397,9 +386,9 @@ fn get_gateinst_port_locate(x: &GateInstantiation) -> Option<(Locate, Locate)> {
} }
} }
fn parse_port_expression(syntax_tree: &SyntaxTree, x: &PackedDimensionRange) -> String { fn parse_expression_only_locate(x: &sv_parser::NeedParseExpression) -> Option<Locate> {
let mut last_locate = Locate { offset: 0, line: 0, len: 0 }; let mut last_locate = Locate { offset: 0, line: 0, len: 0 };
let mut expression = String::new();
for node in x { for node in x {
// println!("parse expression::node {:#?}", node); // println!("parse expression::node {:#?}", node);
match unwrap_node!(node, SimpleIdentifier, Symbol, UnsignedNumber, HexNumber, OctalNumber, BinaryNumber) { match unwrap_node!(node, SimpleIdentifier, Symbol, UnsignedNumber, HexNumber, OctalNumber, BinaryNumber) {
@ -407,76 +396,53 @@ fn parse_port_expression(syntax_tree: &SyntaxTree, x: &PackedDimensionRange) ->
let locate = x.nodes.0; let locate = x.nodes.0;
if locate != last_locate { if locate != last_locate {
last_locate = locate; last_locate = locate;
let s = syntax_tree.get_str(&locate).unwrap();
expression = expression + s;
// println!("parse expression {}", s);
} }
} }
Some(RefNode::Symbol(x)) => { Some(RefNode::Symbol(x)) => {
let locate = x.nodes.0; let locate = x.nodes.0;
if locate != last_locate { if locate != last_locate {
last_locate = locate; last_locate = locate;
let s = syntax_tree.get_str(&x.nodes.0).unwrap();
expression = expression + s;
// println!("parse expression {}", s);
} }
} }
Some(RefNode::UnsignedNumber(x)) => { Some(RefNode::UnsignedNumber(x)) => {
let locate = x.nodes.0; let locate = x.nodes.0;
if locate != last_locate { if locate != last_locate {
last_locate = locate; last_locate = locate;
let s = syntax_tree.get_str(&x.nodes.0).unwrap();
expression = expression + s;
// println!("parse expression {}", s);
} }
} }
Some(RefNode::HexNumber(x)) => { Some(RefNode::HexNumber(x)) => {
let locate = x.nodes.1.nodes.0; let locate = x.nodes.1.nodes.0;
if locate != last_locate { if locate != last_locate {
last_locate = locate; last_locate = locate;
let size = if x.nodes.0 != None { syntax_tree.get_str(&x.nodes.0).unwrap() } else { "" };
let base = syntax_tree.get_str(&x.nodes.1.nodes.0).unwrap();
let number = syntax_tree.get_str(&x.nodes.2.nodes.0).unwrap();
expression = expression + size + base + number;
// println!("parse expression {}", expression);
} }
} }
Some(RefNode::OctalNumber(x)) => { Some(RefNode::OctalNumber(x)) => {
let locate = x.nodes.1.nodes.0; let locate = x.nodes.1.nodes.0;
if locate != last_locate { if locate != last_locate {
last_locate = locate; last_locate = locate;
let size = if x.nodes.0 != None { syntax_tree.get_str(&x.nodes.0).unwrap() } else { "" };
let base = syntax_tree.get_str(&x.nodes.1.nodes.0).unwrap();
let number = syntax_tree.get_str(&x.nodes.2.nodes.0).unwrap();
expression = expression + size + base + number;
// println!("parse expression {}", expression);
} }
} }
Some(RefNode::BinaryNumber(x)) => { Some(RefNode::BinaryNumber(x)) => {
let locate = x.nodes.1.nodes.0; let locate = x.nodes.1.nodes.0;
if locate != last_locate { if locate != last_locate {
last_locate = locate; last_locate = locate;
let size = if x.nodes.0 != None { syntax_tree.get_str(&x.nodes.0).unwrap() } else { "" };
let base = syntax_tree.get_str(&x.nodes.1.nodes.0).unwrap();
let number = syntax_tree.get_str(&x.nodes.2.nodes.0).unwrap();
expression = expression + size + base + number;
// println!("parse expression {}", expression);
} }
} }
_ => () _ => ()
} }
} }
if expression == "" {
"unknown".to_string() if last_locate.offset == 0 {
Some(last_locate)
} else { } else {
// println!("get {}", expression); None
expression
} }
} }
fn parse_parameter_expression(syntax_tree: &SyntaxTree, x: &ConstantMintypmaxExpression) -> (String, Option<Locate>) { fn parse_expression(syntax_tree: &SyntaxTree, x: &sv_parser::NeedParseExpression) -> (String, Option<Locate>) {
let mut last_locate = Locate { offset: 0, line: 0, len: 0 }; let mut last_locate = Locate { offset: 0, line: 0, len: 0 };
let mut expression = String::new(); let mut expression = String::new();
for node in x { for node in x {
// println!("parse expression::node {:#?}", node); // println!("parse expression::node {:#?}", node);
match unwrap_node!(node, SimpleIdentifier, Symbol, UnsignedNumber, HexNumber, OctalNumber, BinaryNumber) { match unwrap_node!(node, SimpleIdentifier, Symbol, UnsignedNumber, HexNumber, OctalNumber, BinaryNumber) {
@ -549,8 +515,8 @@ fn parse_parameter_expression(syntax_tree: &SyntaxTree, x: &ConstantMintypmaxExp
// println!("parse function lastlocate {:?}", last_locate); // println!("parse function lastlocate {:?}", last_locate);
(expression, Some(last_locate)) (expression, Some(last_locate))
} }
} }
fn get_identifier(node: RefNode) -> Option<Locate> { fn get_identifier(node: RefNode) -> Option<Locate> {
// unwrap_node! can take multiple types // unwrap_node! can take multiple types
match unwrap_node!(node, SimpleIdentifier, EscapedIdentifier, Keyword) { match unwrap_node!(node, SimpleIdentifier, EscapedIdentifier, Keyword) {
@ -688,6 +654,19 @@ mod tests {
if let Some(ext) = path.extension() { if let Some(ext) = path.extension() {
if ext == "v" || ext == "sv" { if ext == "v" || ext == "sv" {
println!("Test file: {:?}", path); println!("Test file: {:?}", path);
// TODO: Check Stack Overflow tests
if path.to_str().unwrap() == "/home/dide/project/Digital-Test/Digital-IDE-test/user/src/svlog/tools/ivtest/comp1001.sv" {
continue;
}
if path.to_str().unwrap() == "/home/dide/project/Digital-Test/Digital-IDE-test/user/src/svlog/tools/ivtest/comp1000.sv" {
continue;
}
if path.to_str().unwrap() == "/home/dide/project/Digital-Test/Digital-IDE-test/user/src/svlog/tools/ivtest/br_gh330.sv" {
continue;
}
if path.to_str().unwrap() == "/home/dide/project/Digital-Test/Digital-IDE-test/user/src/svlog/tools/hdlconv/pri_encoder_using_assign.sv" {
continue;
}
let file_path = path.to_str().unwrap(); let file_path = path.to_str().unwrap();
let _ = sv_parser(file_path); let _ = sv_parser(file_path);
} }

2
sv-parser

@ -1 +1 @@
Subproject commit 4960ea3fb7c848462ce6e78dbae454ffc775803f Subproject commit 90e9d4cb3ba4e3a55a9b3fcd0fb83389a376ec35