chore: Decouple c.funcpack generator options from generator cli

Author: schilkp

reginald_cli/src/cmd/generate/c/funcpack.rs

@@ -0,0 +1,162 @@
+use clap::Parser;
+use reginald_codegen::{
+    builtin::c::{self, funcpack::Element},
+    regmap::TypeBitwidth,
+    utils::Endianess,
+};
+
+#[derive(Debug, Clone, Parser)]
+pub struct Cli {
+    /// Generate functions and enums with the given endianess.
+    ///
+    /// May be given multiple times. If not specified, both endianess
+    /// versions will be generated.
+    #[arg(long)]
+    #[arg(action = clap::ArgAction::Append)]
+    #[arg(verbatim_doc_comment)]
+    #[arg(conflicts_with("dont_generate"))]
+    pub endian: Vec<Endianess>,
+
+    /// For other endianess, generate only simple functions that defers to this implementation.
+    ///
+    /// If generating both endianess versions, only generate one complete
+    /// function implementation and have the other endianess defer to this
+    #[arg(long)]
+    #[arg(action = clap::ArgAction::Set)]
+    #[arg(verbatim_doc_comment)]
+    pub defer_to_endian: Option<Endianess>,
+
+    /// Make register structs bitfields to reduce their memory size
+    ///
+    /// May reduce performance. Note that their memory layout will not match the actual register
+    /// and the (un)packing functions must still be used.
+    #[arg(long)]
+    #[arg(action = clap::ArgAction::Set)]
+    #[arg(default_value_t = Self::default().registers_as_bitfields)]
+    #[arg(verbatim_doc_comment)]
+    pub registers_as_bitfields: bool,
+
+    /// Max enum bitwidth before it is represented using macros instead of an enum.
+    ///
+    /// Set to zero to have all enums be represented using macros.
+    #[arg(long)]
+    #[arg(action = clap::ArgAction::Set)]
+    #[arg(default_value_t = Self::default().max_enum_bitwidth)]
+    #[arg(verbatim_doc_comment)]
+    pub max_enum_bitwidth: TypeBitwidth,
+
+    /// Header file that should be included at the top of the generated header
+    ///
+    /// May be given multiple times.
+    #[arg(long)]
+    #[arg(action = clap::ArgAction::Append)]
+    #[arg(verbatim_doc_comment)]
+    pub add_include: Vec<String>,
+
+    /// Make all functions static inline.
+    ///
+    /// May be disabled if splitting code into header and source.
+    #[arg(long)]
+    #[arg(action = clap::ArgAction::Set)]
+    #[arg(default_value_t = Self::default().funcs_static_inline)]
+    #[arg(verbatim_doc_comment)]
+    pub funcs_static_inline: bool,
+
+    /// Generate function prototypes instead of full implementations.
+    ///
+    /// May be enabled if splitting code into header and source.
+    #[arg(long)]
+    #[arg(action = clap::ArgAction::Set)]
+    #[arg(default_value_t = Self::default().funcs_as_prototypes)]
+    #[arg(verbatim_doc_comment)]
+    pub funcs_as_prototypes: bool,
+
+    /// Surround file with a clang-format off guard
+    #[arg(long)]
+    #[arg(action = clap::ArgAction::Set)]
+    #[arg(default_value_t = Self::default().clang_format_guard)]
+    #[arg(verbatim_doc_comment)]
+    pub clang_format_guard: bool,
+
+    /// Generate include guard
+    #[arg(long)]
+    #[arg(action = clap::ArgAction::Set)]
+    #[arg(default_value_t = Self::default().include_guards)]
+    #[arg(verbatim_doc_comment)]
+    pub include_guards: bool,
+
+    /// Only generate a subset of the elements/sections usually included in
+    /// a complete output file.
+    ///
+    /// This option is mutually exclusive with 'dont_generate'
+    /// If this option is not given, all elements are generated. This option
+    /// may be given multiple times.
+    /// Note that different components depend on each other. It is up to the
+    /// user to generate all required sections, or add includes that provide
+    /// those elements.
+    #[arg(long)]
+    #[arg(action = clap::ArgAction::Append)]
+    #[arg(verbatim_doc_comment)]
+    #[arg(conflicts_with("dont_generate"))]
+    pub only_generate: Vec<Element>,
+
+    /// Skip generation of some element/section usually included in a complete
+    /// output file.
+    ///
+    /// This option is mutually exclusive with 'only_generate'
+    /// Note that different components depend on each other. It is up to the
+    /// user to generate all required sections, or add includes that provide
+    /// those elements.
+    #[arg(long)]
+    #[arg(action = clap::ArgAction::Append)]
+    #[arg(verbatim_doc_comment)]
+    #[arg(conflicts_with("only_generate"))]
+    pub dont_generate: Vec<Element>,
+}
+
+impl Default for Cli {
+    fn default() -> Self {
+        Self {
+            endian: vec![],
+            defer_to_endian: None,
+            registers_as_bitfields: false,
+            max_enum_bitwidth: 31,
+            add_include: vec![],
+            funcs_static_inline: true,
+            funcs_as_prototypes: false,
+            clang_format_guard: true,
+            include_guards: true,
+            only_generate: vec![],
+            dont_generate: vec![],
+        }
+    }
+}
+
+impl From<&Cli> for c::funcpack::GeneratorOpts {
+    fn from(cli: &Cli) -> Self {
+        let mut to_generate = c::funcpack::GeneratorOpts::default().to_generate;
+
+        if !cli.only_generate.is_empty() {
+            for to_gen in &cli.only_generate {
+                to_generate.insert(*to_gen);
+            }
+        } else if !cli.dont_generate.is_empty() {
+            for to_skip in &cli.only_generate {
+                to_generate.remove(to_skip);
+            }
+        };
+
+        c::funcpack::GeneratorOpts {
+            endian: cli.endian.clone(),
+            defer_to_endian: cli.defer_to_endian,
+            registers_as_bitfields: cli.registers_as_bitfields,
+            max_enum_bitwidth: cli.max_enum_bitwidth,
+            add_include: cli.add_include.clone(),
+            funcs_static_inline: cli.funcs_static_inline,
+            funcs_as_prototypes: cli.funcs_as_prototypes,
+            clang_format_guard: cli.clang_format_guard,
+            include_guards: cli.include_guards,
+            to_generate,
+        }
+    }
+}

reginald_cli/src/cmd/generate/c/macromap.rs

@@ -0,0 +1 @@
+

reginald_cli/src/cmd/generate/c/mod.rs

@@ -0,0 +1,2 @@
+pub mod funcpack;
+pub mod macromap;

reginald_cli/src/cmd/generate.rs reginald_cli/src/cmd/generate/mod.rsreginald_cli/src/cmd/generate.rs renamed to reginald_cli/src/cmd/generate/mod.rs

@@ -1,8 +1,10 @@
+mod c;
+
 use std::fs;
 use std::path::PathBuf;
 
 use clap::Parser;
-use reginald_codegen::builtin::c;
+use reginald_codegen::builtin::c as codegen_c;
 use reginald_codegen::builtin::md;
 use reginald_codegen::builtin::rs;
 use reginald_codegen::error::Error;
@@ -43,9 +45,9 @@ pub struct Command {
 #[derive(Parser, Debug)]
 pub enum Generator {
     /// C header with register structs, and packing/unpacking functions
-    CFuncpack(c::funcpack::GeneratorOpts),
+    CFuncpack(c::funcpack::Cli),
     /// C header with field mask/shift macros
-    CMacromap(c::macromap::GeneratorOpts),
+    CMacromap(codegen_c::macromap::GeneratorOpts),
     /// Markdown datasheet
     MdDatasheet,
     /// Markdown decode report of register dump
@@ -65,8 +67,8 @@ pub fn cmd(generate: Command) -> Result<(), Error> {
     // Generate output:
     let mut out = String::new();
     match &generate.generator {
-        Generator::CFuncpack(opts) => c::funcpack::generate(&mut out, &map, &generate.output, opts)?,
-        Generator::CMacromap(opts) => c::macromap::generate(&mut out, &map, &generate.output, opts)?,
+        Generator::CFuncpack(opts) => codegen_c::funcpack::generate(&mut out, &map, &generate.output, opts.into())?,
+        Generator::CMacromap(opts) => codegen_c::macromap::generate(&mut out, &map, &generate.output, opts)?,
         Generator::MdDatasheet => md::datasheet::generate(&mut out, &map)?,
         Generator::MdRegdumpDecode(opts) => md::datasheet::regdump::generate(&mut out, &map, opts)?,
         Generator::RsStructs(opts) => rs::structs::generate(&mut out, &map, opts)?,

reginald_codegen/src/builtin/c/funcpack/enums.rs

@@ -7,11 +7,11 @@ use crate::{
 
 use reginald_utils::numbers_as_ranges;
 
-use super::{Element, Input, c_code, c_generate_doxy_comment, c_macro, generate_multiline_macro, is_enabled};
+use super::{Element, Input, c_code, c_generate_doxy_comment, c_macro, generate_multiline_macro};
 
 /// Generate an enum
 pub fn generate_enum(out: &mut dyn Write, inp: &Input, e: &Enum) -> Result<(), Error> {
-    if !is_enabled(inp, Element::Enums) {
+    if !inp.opts.is_enabled(Element::Enums) {
         return Ok(());
     }
 
@@ -48,7 +48,7 @@ pub fn generate_enum(out: &mut dyn Write, inp: &Input, e: &Enum) -> Result<(), E
 
 /// Generate an enum validation func
 pub fn generate_enum_validation_macro(out: &mut dyn Write, inp: &Input, e: &Enum) -> Result<(), Error> {
-    if !is_enabled(inp, Element::EnumValidationMacros) {
+    if !inp.opts.is_enabled(Element::EnumValidationMacros) {
         return Ok(());
     }
 

reginald_codegen/src/builtin/c/funcpack/layouts.rs

@@ -14,7 +14,7 @@ use crate::{
 
 use super::{
     Element, Input, assemble_numeric_field, c_code, c_fitting_unsigned_type, c_generate_doxy_comment, c_macro, enums,
-    func_prefix, is_enabled, swap_loop,
+    func_prefix, swap_loop,
 };
 
 pub fn generate_layout(out: &mut dyn Write, inp: &Input, layout: &Layout) -> Result<(), Error> {
@@ -61,7 +61,7 @@ pub fn generate_layout(out: &mut dyn Write, inp: &Input, layout: &Layout) -> Res
 }
 
 fn generate_layout_struct(out: &mut dyn Write, inp: &Input, layout: &Layout) -> Result<(), Error> {
-    if !is_enabled(inp, Element::Structs) {
+    if !inp.opts.is_enabled(Element::Structs) {
         return Ok(());
     }
 
@@ -110,18 +110,18 @@ fn generate_layout_struct(out: &mut dyn Write, inp: &Input, layout: &Layout) ->
 
 /// Generate register packing/unpacking funcs
 fn generate_layout_funcs(out: &mut dyn Write, inp: &Input, layout: &Layout) -> Result<(), Error> {
-    if !is_enabled(inp, Element::StructConversionFuncs) {
+    if !inp.opts.is_enabled(Element::StructConversionFuncs) {
         return Ok(());
     }
 
-    for endian in &inp.endian {
+    for endian in &inp.opts.endian {
         generate_layout_pack_func(out, inp, layout, *endian)?;
     }
-    for endian in &inp.endian {
+    for endian in &inp.opts.endian {
         generate_layout_unpack_func(out, inp, layout, *endian)?;
     }
     generate_layout_validation_func(out, inp, layout)?;
-    for endian in &inp.endian {
+    for endian in &inp.opts.endian {
         generate_layout_try_unpack_func(out, inp, layout, *endian)?;
     }