| // Copyright 2022 The Fuchsia Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| use crate::common::load_manifest; | |
| use anyhow::{format_err, Context as _, Error}; | |
| use argh::FromArgs; | |
| use config_client::cpp::{create_cpp_wrapper, CppSource}; | |
| use std::fs; | |
| use std::io::Write; | |
| use std::path::PathBuf; | |
| use std::process::{Command as Process, Stdio}; | |
| #[derive(FromArgs, PartialEq, Debug)] | |
| /// Generates a C++ client library from a given manifest. | |
| /// This also requires a FIDL client library to be generated for the given manifest. | |
| #[argh(subcommand, name = "cpp")] | |
| pub struct GenerateCppSource { | |
| /// compiled manifest containing the config declaration | |
| #[argh(option)] | |
| cm: PathBuf, | |
| /// path to which to output a header file | |
| #[argh(option)] | |
| h_output: PathBuf, | |
| /// path to which to output a source file | |
| #[argh(option)] | |
| cc_output: PathBuf, | |
| /// namespace used by library | |
| #[argh(option)] | |
| namespace: String, | |
| /// name for the internal FIDL library | |
| #[argh(option)] | |
| fidl_library_name: String, | |
| /// path to clang-format binary | |
| #[argh(option)] | |
| clang_format: PathBuf, | |
| } | |
| impl GenerateCppSource { | |
| pub fn generate(self) -> Result<(), Error> { | |
| let component = load_manifest(&self.cm).context("loading component manifest")?; | |
| let config_decl = component | |
| .config | |
| .as_ref() | |
| .ok_or_else(|| anyhow::format_err!("missing config declaration in manifest"))?; | |
| let CppSource { h_source, cc_source } = | |
| create_cpp_wrapper(config_decl, self.namespace, self.fidl_library_name) | |
| .context("creating cpp elf wrapper")?; | |
| let formatted_cc_source = format_source(&self.clang_format, cc_source)?; | |
| let formatted_h_source = format_source(&self.clang_format, h_source)?; | |
| // Make sure directories exist | |
| fs::create_dir_all( | |
| &self.cc_output.parent().expect("source output path must have a parent directory"), | |
| ) | |
| .context("Failed to create directories for source files")?; | |
| let mut cc_out_file = fs::OpenOptions::new() | |
| .create(true) | |
| .truncate(true) | |
| .write(true) | |
| .open(&self.cc_output) | |
| .context("opening cc output file")?; | |
| cc_out_file.write(formatted_cc_source.as_bytes()).context("writing cc file to output")?; | |
| let mut h_out_file = fs::OpenOptions::new() | |
| .create(true) | |
| .truncate(true) | |
| .write(true) | |
| .open(&self.h_output) | |
| .context("opening h output file")?; | |
| h_out_file.write(formatted_h_source.as_bytes()).context("writing h file to output")?; | |
| Ok(()) | |
| } | |
| } | |
| fn format_source(clang_format: &PathBuf, contents: String) -> Result<String, Error> { | |
| // TODO(https://fxbug.dev/42126760) Use --style=file and copy the .clang-format file to the correct location. | |
| // An alternate way to do this is to load the config directly from .clang_format and put the | |
| // style as JSON in quotes. | |
| let mut process = Process::new(clang_format) | |
| .arg("--style=google") | |
| .stdin(Stdio::piped()) | |
| .stdout(Stdio::piped()) | |
| .spawn() | |
| .context("could not spawn clang-format process")?; | |
| process | |
| .stdin | |
| .as_mut() | |
| .ok_or_else(|| format_err!("could not get stdin for clang-format process"))? | |
| .write_all(contents.as_bytes()) | |
| .context("Could not write unformatted source to stdin of clang-format")?; | |
| let output = | |
| process.wait_with_output().context("could not wait for clang-format process to exit")?; | |
| if !output.status.success() { | |
| return Err(format_err!("failed to format cpp source: {:#?}", output)); | |
| } | |
| let output = String::from_utf8(output.stdout) | |
| .context("output from clang-format is not UTF-8 compatible")?; | |
| Ok(output) | |
| } |