libc-print-0.1.14/.cargo_vcs_info.json0000644000000001121373224423500132570ustar00{ "git": { "sha1": "88c607f50882a337ab31cdefa24accdf2f948665" } } libc-print-0.1.14/.gitignore010064400007650000024000000000231341201042700140340ustar0000000000000000/target **/*.rs.bk libc-print-0.1.14/.travis.yml010064400007650000024000000001311341201752100141570ustar0000000000000000os: - linux - osx - windows language: rust rust: - stable - beta - nightly libc-print-0.1.14/Cargo.toml0000644000000016221373224423500112640ustar00# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO # # When uploading crates to the registry Cargo will automatically # "normalize" Cargo.toml files for maximal compatibility # with all versions of Cargo and also rewrite `path` dependencies # to registry (e.g., crates.io) dependencies # # If you believe there's an error in this file please file an # issue against the rust-lang/cargo repository. If you're # editing this file be aware that the upstream Cargo.toml # will likely look very different (and much more reasonable) [package] edition = "2018" name = "libc-print" version = "0.1.14" authors = ["Matt Mastracci "] description = "println! and eprintln! macros on libc without stdlib" readme = "README.md" license = "Apache-2.0 OR MIT" repository = "https://github.com/mmastrac/rust-libc-print" [lib] name = "libc_print" [dependencies.libc] version = "0.2.77" default-features = false libc-print-0.1.14/Cargo.toml.orig010064400007650000024000000006151373224411400147510ustar0000000000000000[package] name = "libc-print" version = "0.1.14" authors = ["Matt Mastracci "] edition = "2018" description = "println! and eprintln! macros on libc without stdlib" license = "Apache-2.0 OR MIT" repository = "https://github.com/mmastrac/rust-libc-print" readme = "README.md" [lib] name = "libc_print" [dependencies] libc = { version = "0.2.77", default-features = false } libc-print-0.1.14/README.md010064400007650000024000000016461341206103200133350ustar0000000000000000# no_std libc print/println/eprint/eprintln [![Build Status](https://api.travis-ci.org/mmastrac/rust-libc-print.svg?branch=master)](https://travis-ci.org/mmastrac/rust-libc-print) [![docs.rs](https://docs.rs/libc-print/badge.svg)](https://docs.rs/libc-print) [![crates.io](https://img.shields.io/crates/v/libc-print.svg)](https://crates.io/crates/libc-print) Implements `println!` and `eprintln!` on the `libc` crate without requiring the use of an allocator. Allows you to use these macros in a `#![no_std]` context, or in a situation where the traditional Rust streams might not be available (ie: at process shutdown time). By default this crate provides `libc_`-prefixed macros, but also allows consumers to import macros with the same name as the stdlib printing macros via the `std_name` module. ## Usage Exactly as you'd use `println!` or `eprintln!`. ``` #![no_std] // ... libc_println!("Hello {}!", "world"); ``` libc-print-0.1.14/src/lib.rs010064400007650000024000000165121365041705600137760ustar0000000000000000//! Implements `println!` and `eprintln!` on top of the `libc `crate without requiring //! the use of an allocator. //! //! Allows you to use these macros in a #![no_std] context, or in a situation where the //! traditional Rust streams might not be available (ie: at process shutdown time). //! //! [`libc_writeln`] and [`libc_ewriteln`] are provided for cases where you may not wish //! to pull in the overhead of the formatter code and simply wish to print C-style strings. //! //! ## Usage //! //! Exactly as you'd use `println!` or `eprintln!`. #![no_std] #![allow(dead_code)] /// This forces a "C" library linkage #[cfg(not(windows))] #[link(name="c")] mod c { extern "C" {} } // These constants are used by the macros but we don't want to expose // them to library users. #[doc(hidden)] pub const __LIBC_NEWLINE: &str = "\n"; #[doc(hidden)] pub const __LIBC_STDOUT: i32 = 1; #[doc(hidden)] pub const __LIBC_STDERR: i32 = 2; #[doc(hidden)] pub struct __LibCWriter(i32); impl core::fmt::Write for __LibCWriter { #[inline] fn write_str(&mut self, s: &str) -> core::fmt::Result { __libc_println(self.0, s) } } impl __LibCWriter { #[inline] pub fn new(handle: i32) -> __LibCWriter { __LibCWriter(handle) } #[inline] pub fn write_fmt(&mut self, args: core::fmt::Arguments) -> core::fmt::Result { core::fmt::Write::write_fmt(self, args) } #[inline] pub fn write_str(&mut self, s: &str) -> core::fmt::Result { __libc_println(self.0, s) } #[inline] pub fn write_nl(&mut self) -> core::fmt::Result { __libc_println(self.0, __LIBC_NEWLINE) } } #[cfg(not(windows))] #[doc(hidden)] #[inline] pub fn __libc_println(handle: i32, msg: &str) -> core::fmt::Result { unsafe { libc::write( handle, msg.as_ptr() as *const core::ffi::c_void, msg.len() as libc::size_t, ); Ok(()) } } #[cfg(windows)] #[doc(hidden)] #[inline] pub fn __libc_println(handle: i32, msg: &str) -> core::fmt::Result { unsafe { libc::write( handle, msg.as_ptr() as *const core::ffi::c_void, msg.len() as u32, ); Ok(()) } } /// Macro for printing to the standard output, with a newline. /// /// Does not panic on failure to write - instead silently ignores errors. /// /// See [`println!`](https://doc.rust-lang.org/std/macro.println.html) for /// full documentation. /// /// You may wish to `use libc_print::std_name::*` to use a replacement /// `println!` macro instead of this longer name. #[macro_export] macro_rules! libc_println { () => { $crate::libc_println!("") }; ($($arg:tt)*) => { #[allow(unused_must_use)] { let mut stm = $crate::__LibCWriter::new($crate::__LIBC_STDOUT); stm.write_fmt(format_args!($($arg)*)); stm.write_nl(); } }; } /// Macro for printing to the standard output. /// /// Does not panic on failure to write - instead silently ignores errors. /// /// See [`print!`](https://doc.rust-lang.org/std/macro.print.html) for /// full documentation. /// /// You may wish to `use libc_print::std_name::*` to use a replacement /// `print!` macro instead of this longer name. #[macro_export] macro_rules! libc_print { ($($arg:tt)*) => { #[allow(unused_must_use)] { let mut stm = $crate::__LibCWriter::new($crate::__LIBC_STDOUT); stm.write_fmt(format_args!($($arg)*)); } }; } /// Macro for printing to the standard error, with a newline. /// /// Does not panic on failure to write - instead silently ignores errors. /// /// See [`eprintln!`](https://doc.rust-lang.org/std/macro.eprintln.html) for /// full documentation. /// /// You may wish to `use libc_print::std_name::*` to use a replacement /// `eprintln!` macro instead of this longer name. #[macro_export] macro_rules! libc_eprintln { () => { $crate::libc_eprintln!("") }; ($($arg:tt)*) => { #[allow(unused_must_use)] { let mut stm = $crate::__LibCWriter::new($crate::__LIBC_STDERR); stm.write_fmt(format_args!($($arg)*)); stm.write_nl(); } }; } /// Macro for printing to the standard error. /// /// Does not panic on failure to write - instead silently ignores errors. /// /// See [`eprint!`](https://doc.rust-lang.org/std/macro.eprint.html) for /// full documentation. /// /// You may wish to `use libc_print::std_name::*` to use a replacement /// `eprint!` macro instead of this longer name. #[macro_export] macro_rules! libc_eprint { ($($arg:tt)*) => { #[allow(unused_must_use)] { let mut stm = $crate::__LibCWriter::new($crate::__LIBC_STDERR); stm.write_fmt(format_args!($($arg)*)); } }; } /// Macro for printing a static string to the standard output. /// /// Does not panic on failure to write - instead silently ignores errors. #[macro_export] macro_rules! libc_write { ($arg:expr) => { #[allow(unused_must_use)] { let mut stm = $crate::__LibCWriter::new($crate::__LIBC_STDOUT); stm.write_str($arg); } } } /// Macro for printing a static string to the standard error. /// /// Does not panic on failure to write - instead silently ignores errors. #[macro_export] macro_rules! libc_ewrite { ($arg:expr) => { #[allow(unused_must_use)] { let mut stm = $crate::__LibCWriter::new($crate::__LIBC_STDERR); stm.write_str($arg); } } } /// Macro for printing a static string to the standard output, with a newline. /// /// Does not panic on failure to write - instead silently ignores errors. #[macro_export] macro_rules! libc_writeln { ($arg:expr) => { #[allow(unused_must_use)] { let mut stm = $crate::__LibCWriter::new($crate::__LIBC_STDOUT); stm.write_str($arg); stm.write_nl(); } } } /// Macro for printing a static string to the standard error, with a newline. /// /// Does not panic on failure to write - instead silently ignores errors. #[macro_export] macro_rules! libc_ewriteln { ($arg:expr) => { #[allow(unused_must_use)] { let mut stm = $crate::__LibCWriter::new($crate::__LIBC_STDERR); stm.write_str($arg); stm.write_nl(); } } } /// This package contains the `libc_print` macros, but using the stdlib names /// such as `println!`, `print!`, etc. pub mod std_name { pub use super::libc_print as print; pub use super::libc_println as println; pub use super::libc_eprint as eprint; pub use super::libc_eprintln as eprintln; #[cfg(test)] mod tests_std_name { use super::{println, eprintln}; #[test] fn test_stdout() { println!("stdout fd = {}", crate::__LIBC_STDOUT); } #[test] fn test_stderr() { eprintln!("stderr fd = {}", crate::__LIBC_STDERR); } } } #[cfg(test)] mod tests { #[test] fn test_stdout() { super::libc_println!("stdout fd = {}", super::__LIBC_STDOUT); } #[test] fn test_stderr() { super::libc_eprintln!("stderr fd = {}", super::__LIBC_STDERR); } #[test] fn test_stdout_write() { super::libc_writeln!("stdout!"); } #[test] fn test_stderr_write() { super::libc_ewriteln!("stderr!"); } }