use std::fmt::{self, Write};
use crate::{
Attribute, DocComment, Expr, Format, Formatter, StorageClass, Type, declare_with,
has_annotations, write_annotations,
};
use tamacro::DisplayFromFormat;
#[derive(Debug, Clone, DisplayFromFormat)]
pub struct Variable {
pub name: String,
pub t: Type,
pub value: Option<Expr>,
pub storage: StorageClass,
pub attrs: Vec<Attribute>,
pub raw_attrs: Vec<String>,
pub doc: Option<DocComment>,
}
impl Variable {
pub fn new(name: String, t: Type) -> VariableBuilder {
VariableBuilder::new(name, t)
}
pub fn to_type(&self) -> Type {
self.t.clone()
}
}
impl Format for Variable {
fn format(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
if let Some(doc) = &self.doc {
doc.format(fmt)?;
}
if has_annotations(&self.raw_attrs, &self.attrs) {
write_annotations(fmt, &self.raw_attrs, &self.attrs)?;
write!(fmt, " ")?;
}
if let Some(kw) = self.storage.keyword() {
write!(fmt, "{kw} ")?;
}
write!(fmt, "{}", declare_with(&self.t, &self.name, fmt.options()))?;
if !self.storage.is_extern()
&& let Some(value) = &self.value {
write!(fmt, " = ")?;
value.format(fmt)?;
}
Ok(())
}
}
pub struct VariableBuilder {
name: String,
t: Type,
value: Option<Expr>,
storage: StorageClass,
attrs: Vec<Attribute>,
raw_attrs: Vec<String>,
doc: Option<DocComment>,
}
impl VariableBuilder {
pub fn new(name: String, t: Type) -> Self {
Self {
name,
t,
value: None,
storage: StorageClass::None,
attrs: vec![],
raw_attrs: vec![],
doc: None,
}
}
pub fn new_with_str(name: &str, t: Type) -> Self {
Self::new(name.to_string(), t)
}
pub fn value(mut self, value: Expr) -> Self {
self.value = Some(value);
self
}
pub fn doc(mut self, doc: DocComment) -> Self {
self.doc = Some(doc);
self
}
pub fn make_static(mut self) -> Self {
self.storage = StorageClass::Static;
self
}
pub fn make_extern(mut self) -> Self {
self.storage = StorageClass::Extern;
self
}
pub fn storage(mut self, storage: StorageClass) -> Self {
self.storage = storage;
self
}
pub fn raw_value(mut self, value: String) -> Self {
self.value = Some(Expr::Raw(value));
self
}
pub fn attr(mut self, attr: Attribute) -> Self {
self.attrs.push(attr);
self
}
pub fn attrs(mut self, attrs: Vec<Attribute>) -> Self {
self.attrs = attrs;
self
}
pub fn raw_attr(mut self, token: &str) -> Self {
self.raw_attrs.push(token.to_string());
self
}
pub fn raw_attrs(mut self, tokens: Vec<String>) -> Self {
self.raw_attrs = tokens;
self
}
pub fn build(self) -> Variable {
Variable {
name: self.name,
t: self.t,
value: self.value,
storage: self.storage,
attrs: self.attrs,
raw_attrs: self.raw_attrs,
doc: self.doc,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::*;
#[test]
fn var() {
let var = VariableBuilder::new_with_str(
"some_var",
TypeBuilder::new(BaseType::Char)
.make_pointer()
.make_const()
.build(),
)
.value(Expr::Str("Hello, world".to_string()))
.build();
let res = "const char *some_var = \"Hello, world\"";
assert_eq!(var.to_string(), res);
let another_var =
VariableBuilder::new_with_str("another_var", TypeBuilder::new(BaseType::Bool).build())
.make_static()
.build();
let another_res = "static bool another_var";
assert_eq!(another_var.to_string(), another_res);
}
#[test]
fn extern_omits_initializer_and_storage_is_exclusive() {
let ext = VariableBuilder::new_with_str("g", TypeBuilder::new(BaseType::Int).build())
.value(Expr::Int(5))
.make_extern()
.build();
assert_eq!(ext.storage, StorageClass::Extern);
assert_eq!(ext.to_string(), "extern int g");
let stat = VariableBuilder::new_with_str("g", TypeBuilder::new(BaseType::Int).build())
.value(Expr::Int(5))
.make_extern()
.make_static()
.build();
assert_eq!(stat.storage, StorageClass::Static);
assert_eq!(stat.to_string(), "static int g = 5");
}
}