Call rule printf when format string is not static

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -2311,8 +2311,13 @@ std::optional<Converter::TempMaterializationCtx>
 Converter::ConvertCallExpr(clang::CallExpr *expr) {
   auto *callee = expr->getCallee();
 
-  if (auto fn = Printer::ToString(ctx_, callee);
-      fn.starts_with("int printf") || fn.starts_with("int fprintf")) {
+  auto fn = Printer::ToString(ctx_, callee);
+  bool is_printf = fn.starts_with("int printf");
+  bool is_fprintf = fn.starts_with("int fprintf");
+  unsigned format_arg = is_fprintf ? 1 : 0;
+  if ((is_printf || is_fprintf) &&
+      clang::isa<clang::StringLiteral>(
+          expr->getArg(format_arg)->IgnoreImplicit())) {
     ConvertPrintf(expr);
   } else if (IsTransparentStdCall(expr)) {
     Convert(expr->getArg(0));

cpp2rust/converter/models/converter_refcount.cpp

@@ -1244,16 +1244,8 @@ static std::vector<const char *> printf2fmt(std::string &format) {
 void ConverterRefCount::ConvertPrintf(clang::CallExpr *expr) {
   bool is_fprintf =
       Printer::ToString(ctx_, expr->getCallee()).starts_with("int fprintf");
-  std::string format;
-  if (auto *str = clang::dyn_cast<clang::StringLiteral>(
-          expr->getArg(is_fprintf)->IgnoreImplicit())) {
-    format = GetEscapedStringLiteral(str);
-  } else {
-    llvm::errs() << "Unknown fprintf format: ";
-    expr->getArg(1)->dump();
-    llvm::errs() << '\n';
-    exit(1);
-  }
+  auto format = GetEscapedStringLiteral(clang::cast<clang::StringLiteral>(
+      expr->getArg(is_fprintf)->IgnoreImplicit()));
   bool ends_newline = format.ends_with("\\n\"");
 
   auto fd = is_fprintf ? Printer::ToString(ctx_, expr->getArg(0)) : "stdout";

rules/stdio/src.c

@@ -75,3 +75,7 @@ int f25(void) { return SEEK_SET; }
 int f26(void) { return SEEK_CUR; }
 
 int f27(void) { return SEEK_END; }
+
+int (*f28)(FILE *, const char *, ...) = fprintf;
+
+int (*f29)(const char *, ...) = printf;

rules/stdio/tgt_refcount.rs

@@ -189,3 +189,13 @@ fn f23(a0: Ptr<CFile>) -> i32 {
 fn f24(a0: Ptr<CFile>, a1: Ptr<i8>, a2: i32, a3: usize) -> i32 {
     0
 }
+
+fn f28(a0: Ptr<CFile>, a1: Ptr<i8>, va: &[VaArg]) -> i32 {
+    let __s = libcc2rs::format_c(&a1.to_rust_string(), va);
+    a0.with_mut(|__f| __f.write(__s.as_bytes())) as i32
+}
+
+fn f29(a0: Ptr<i8>, va: &[VaArg]) -> i32 {
+    let __s = libcc2rs::format_c(&a0.to_rust_string(), va);
+    libcc2rs::c_stdout().with_mut(|__f| __f.write(__s.as_bytes())) as i32
+}

rules/stdio/tgt_unsafe.rs

@@ -116,3 +116,11 @@ unsafe fn f26() -> i32 {
 unsafe fn f27() -> i32 {
     ::libc::SEEK_END
 }
+
+unsafe extern "C" {
+    fn f28(a0: *mut ::libc::FILE, a1: *const libc::c_char, ...) -> i32;
+}
+
+unsafe extern "C" {
+    fn f29(a0: *const libc::c_char, ...) -> i32;
+}

tests/unit/printfs.cpp

@@ -6,6 +6,12 @@ std::string fn(std::string v) { return v + " str"; }
 
 const std::string &fn2(const std::string &v) { return v; }
 
+template <class... Args> void log_to(FILE *out, const char *fmt, Args... args) {
+  fprintf(out, fmt, args...);
+}
+
+void log_fmt(const char *fmt, int v) { printf(fmt, v); }
+
 int main() {
   fprintf(stdout, "%s\n", "fprintf stdout");
   fprintf(stdout, "%d %u %ld\n", 1, 2U, 3L);
@@ -18,5 +24,8 @@ int main() {
   printf("%s\n", s.data());
   printf("%s\n", fn("foo").c_str());
   printf("%s\n", fn2(s).c_str());
+  log_to(stdout, "%s %d\n", "runtime", 4);
+  log_to(stderr, "%d\n", 5);
+  log_fmt("%d\n", 6);
   return 0;
 }