Add translation rule for stdin

Author: lucic71

libcc2rs/src/io.rs

@@ -7,12 +7,25 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 
 thread_local! {
+    static SAFE_STDIN: Value<std::fs::File> = Rc::new(RefCell::new(std::fs::File::from(
+        std::io::stdin().as_fd().try_clone_to_owned().unwrap(),
+    )));
     static SAFE_STDOUT: Value<std::fs::File> = Rc::new(RefCell::new(std::fs::File::from(
         std::io::stdout().as_fd().try_clone_to_owned().unwrap(),
     )));
     static SAFE_STDERR: Value<std::fs::File> = Rc::new(RefCell::new(std::fs::File::from(
         std::io::stderr().as_fd().try_clone_to_owned().unwrap(),
     )));
+    static UNSAFE_STDIN: UnsafeCell<std::fs::File> = unsafe {
+        UnsafeCell::new(
+            std::fs::File::from_raw_fd(
+                std::io::stdin()
+                    .as_fd()
+                    .try_clone_to_owned()
+                    .unwrap()
+                    .into_raw_fd(),
+        ))
+    };
     static UNSAFE_STDOUT: UnsafeCell<std::fs::File> = unsafe {
         UnsafeCell::new(
             std::fs::File::from_raw_fd(
@@ -35,6 +48,10 @@ thread_local! {
     };
 }
 
+pub fn cin() -> Ptr<std::fs::File> {
+    SAFE_STDIN.with(AsPointer::as_pointer)
+}
+
 pub fn cout() -> Ptr<std::fs::File> {
     SAFE_STDOUT.with(AsPointer::as_pointer)
 }
@@ -43,6 +60,14 @@ pub fn cerr() -> Ptr<std::fs::File> {
     SAFE_STDERR.with(AsPointer::as_pointer)
 }
 
+/// # Safety
+///
+/// The caller must ensure that the returned pointer is not used after the
+//  thread finishes.
+pub unsafe fn cin_unsafe() -> *mut std::fs::File {
+    UNSAFE_STDIN.with(UnsafeCell::get)
+}
+
 /// # Safety
 ///
 /// The caller must ensure that the returned pointer is not used after the

rules/stdio/ir_refcount.json

@@ -890,6 +890,17 @@
       "is_refcount_pointer": true
     }
   },
+  "f10": {
+    "body": [
+      {
+        "text": "libcc2rs::cin()"
+      }
+    ],
+    "return_type": {
+      "type": "Ptr<::std::fs::File>",
+      "is_refcount_pointer": true
+    }
+  },
   "t1": {
     "init": "Ptr::null()",
     "type": "Ptr<::std::fs::File>",

rules/stdio/ir_unsafe.json

@@ -861,6 +861,17 @@
       "is_unsafe_pointer": true
     }
   },
+  "f10": {
+    "body": [
+      {
+        "text": "libcc2rs::cin_unsafe()"
+      }
+    ],
+    "return_type": {
+      "type": "*mut ::std::fs::File",
+      "is_unsafe_pointer": true
+    }
+  },
   "t1": {
     "init": "Default::default()",
     "type": "*mut ::std::fs::File",

rules/stdio/src.cpp

@@ -30,3 +30,5 @@ int f7(FILE *stream) { return fflush(stream); }
 FILE *f8() { return stdout; }
 
 FILE *f9() { return stderr; }
+
+FILE *f10() { return stdin; }

tests/unit/out/refcount/printfs.rs

@@ -26,6 +26,8 @@ fn main_0() -> i32 {
     println!("{}", Ptr::from_string_literal("fprintf stdout"));
     println!("{} {} {}", 1, 2_u32, 3_i64);
     print!("hello world");
+    let in_: Value<Ptr<::std::fs::File>> = Rc::new(RefCell::new((libcc2rs::cin()).clone()));
+    assert!(((*in_.borrow()) != Default::default()));
     println!("{}", Ptr::from_string_literal("printf"));
     print!("hello world");
     let s: Value<Vec<u8>> = Rc::new(RefCell::new(

tests/unit/out/unsafe/printfs.rs

@@ -34,6 +34,8 @@ unsafe fn main_0() -> i32 {
     );
     printf(b"%d %u %ld\n\0".as_ptr() as *const i8, 1, 2_u32, 3_i64);
     printf(b"hello world\0".as_ptr() as *const i8);
+    let mut in_: *mut ::std::fs::File = libcc2rs::cin_unsafe();
+    assert!(((in_) != (std::ptr::null_mut())));
     printf(b"%s\n\0".as_ptr() as *const i8, b"printf\0".as_ptr());
     printf(b"hello world\0".as_ptr() as *const i8);
     let mut s: Vec<u8> = {

tests/unit/printfs.cpp

@@ -1,6 +1,7 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
+#include <cassert>
 #include <cstdio>
 #include <string>
 
@@ -12,6 +13,8 @@ int main() {
   fprintf(stdout, "%s\n", "fprintf stdout");
   fprintf(stdout, "%d %u %ld\n", 1, 2U, 3L);
   fprintf(stdout, "hello world");
+  FILE *in = stdin;
+  assert(in != NULL);
   printf("%s\n", "printf");
   printf("hello world");
   std::string s = "a string";