Add rules + tests for fputc/fputs

Author: lucic71

rules/stdio/ir_unsafe.json

@@ -264,6 +264,142 @@
       "is_unsafe_pointer": true
     }
   },
+  "f11": {
+    "body": [
+      {
+        "text": "match "
+      },
+      {
+        "method_call": {
+          "receiver": [
+            {
+              "text": "(*"
+            },
+            {
+              "placeholder": {
+                "arg": 1,
+                "access": "write"
+              }
+            },
+            {
+              "text": ")"
+            }
+          ],
+          "body": [
+            {
+              "text": ".write_all(&["
+            },
+            {
+              "placeholder": {
+                "arg": 0,
+                "access": "read"
+              }
+            },
+            {
+              "text": " as u8])"
+            }
+          ]
+        }
+      },
+      {
+        "text": " {\n        Ok(()) => "
+      },
+      {
+        "placeholder": {
+          "arg": 0,
+          "access": "read"
+        }
+      },
+      {
+        "text": " & 0xff,\n        Err(_) => -1,\n    }"
+      }
+    ],
+    "params": {
+      "a0": {
+        "type": "i32"
+      },
+      "a1": {
+        "type": "*mut ::std::fs::File",
+        "is_unsafe_pointer": true
+      }
+    },
+    "return_type": {
+      "type": "i32"
+    }
+  },
+  "f12": {
+    "body": [
+      {
+        "text": "let bytes = "
+      },
+      {
+        "method_call": {
+          "receiver": [
+            {
+              "text": "std::ffi::CStr::from_ptr("
+            },
+            {
+              "placeholder": {
+                "arg": 0,
+                "access": "read"
+              }
+            },
+            {
+              "text": " as *const i8)"
+            }
+          ],
+          "body": [
+            {
+              "text": ".to_bytes()"
+            }
+          ]
+        }
+      },
+      {
+        "text": ";\n    match "
+      },
+      {
+        "method_call": {
+          "receiver": [
+            {
+              "text": "(*"
+            },
+            {
+              "placeholder": {
+                "arg": 1,
+                "access": "write"
+              }
+            },
+            {
+              "text": ")"
+            }
+          ],
+          "body": [
+            {
+              "text": ".write_all(bytes)"
+            }
+          ]
+        }
+      },
+      {
+        "text": " {\n        Ok(()) => 0,\n        Err(_) => -1,\n    }"
+      }
+    ],
+    "multi_statement": true,
+    "params": {
+      "a0": {
+        "type": "*const u8",
+        "is_unsafe_pointer": true
+      },
+      "a1": {
+        "type": "*mut ::std::fs::File",
+        "is_unsafe_pointer": true
+      }
+    },
+    "return_type": {
+      "type": "i32"
+    }
+  },
   "f2": {
     "body": [
       {

rules/stdio/src.cpp

@@ -32,3 +32,7 @@ FILE *f8() { return stdout; }
 FILE *f9() { return stderr; }
 
 FILE *f10() { return stdin; }
+
+int f11(int c, FILE *stream) { return fputc(c, stream); }
+
+int f12(const char *s, FILE *stream) { return fputs(s, stream); }

rules/stdio/tgt_unsafe.rs

@@ -105,3 +105,18 @@ unsafe fn f9() -> *mut ::std::fs::File {
 unsafe fn f10() -> *mut ::std::fs::File {
     libcc2rs::cin_unsafe()
 }
+
+unsafe fn f11(a0: i32, a1: *mut ::std::fs::File) -> i32 {
+    match (*a1).write_all(&[a0 as u8]) {
+        Ok(()) => a0 & 0xff,
+        Err(_) => -1,
+    }
+}
+
+unsafe fn f12(a0: *const u8, a1: *mut ::std::fs::File) -> i32 {
+    let bytes = std::ffi::CStr::from_ptr(a0 as *const i8).to_bytes();
+    match (*a1).write_all(bytes) {
+        Ok(()) => 0,
+        Err(_) => -1,
+    }
+}

tests/unit/out/unsafe/stdio.rs

@@ -0,0 +1,77 @@
+extern crate libc;
+use libc::*;
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::collections::BTreeMap;
+use std::io::{Read, Seek, Write};
+use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
+use std::rc::Rc;
+pub unsafe fn test_fputc_0() {
+    match (*libcc2rs::cout_unsafe()).write_all(&[('H' as i32) as u8]) {
+        Ok(()) => ('H' as i32) & 0xff,
+        Err(_) => -1,
+    };
+    match (*libcc2rs::cout_unsafe()).write_all(&[('i' as i32) as u8]) {
+        Ok(()) => ('i' as i32) & 0xff,
+        Err(_) => -1,
+    };
+    match (*libcc2rs::cout_unsafe()).write_all(&[('\n' as i32) as u8]) {
+        Ok(()) => ('\n' as i32) & 0xff,
+        Err(_) => -1,
+    };
+}
+pub unsafe fn test_fputs_1() {
+    {
+        let bytes =
+            std::ffi::CStr::from_ptr((b"hello\0".as_ptr().cast_mut()).cast_const() as *const i8)
+                .to_bytes();
+        match (*libcc2rs::cout_unsafe()).write_all(bytes) {
+            Ok(()) => 0,
+            Err(_) => -1,
+        }
+    };
+    match (*libcc2rs::cout_unsafe()).write_all(&[('\n' as i32) as u8]) {
+        Ok(()) => ('\n' as i32) & 0xff,
+        Err(_) => -1,
+    };
+    let mut s: *const u8 = (b"from variable\0".as_ptr().cast_mut()).cast_const();
+    {
+        let bytes = std::ffi::CStr::from_ptr(s as *const i8).to_bytes();
+        match (*libcc2rs::cout_unsafe()).write_all(bytes) {
+            Ok(()) => 0,
+            Err(_) => -1,
+        }
+    };
+    match (*libcc2rs::cout_unsafe()).write_all(&[('\n' as i32) as u8]) {
+        Ok(()) => ('\n' as i32) & 0xff,
+        Err(_) => -1,
+    };
+    let mut buf: [u8; 4] = [
+        (('b' as i32) as u8),
+        (('u' as i32) as u8),
+        (('f' as i32) as u8),
+        (('\0' as i32) as u8),
+    ];
+    {
+        let bytes =
+            std::ffi::CStr::from_ptr((buf.as_mut_ptr()).cast_const() as *const i8).to_bytes();
+        match (*libcc2rs::cout_unsafe()).write_all(bytes) {
+            Ok(()) => 0,
+            Err(_) => -1,
+        }
+    };
+    match (*libcc2rs::cout_unsafe()).write_all(&[('\n' as i32) as u8]) {
+        Ok(()) => ('\n' as i32) & 0xff,
+        Err(_) => -1,
+    };
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    (unsafe { test_fputc_0() });
+    (unsafe { test_fputs_1() });
+    return 0;
+}

tests/unit/stdio.c

@@ -0,0 +1,25 @@
+// no-compile: refcount
+#include <stdio.h>
+
+static void test_fputc(void) {
+  fputc('H', stdout);
+  fputc('i', stdout);
+  fputc('\n', stdout);
+}
+
+static void test_fputs(void) {
+  fputs("hello", stdout);
+  fputc('\n', stdout);
+  const char *s = "from variable";
+  fputs(s, stdout);
+  fputc('\n', stdout);
+  char buf[] = {'b', 'u', 'f', '\0'};
+  fputs(buf, stdout);
+  fputc('\n', stdout);
+}
+
+int main(void) {
+  test_fputc();
+  test_fputs();
+  return 0;
+}