create std feature and adjust imports

The worst change here is substituting `last_os_error` to just reading
`errno` from `libc`. However, since ALSA can only be used in `linux`
systems, which will always have `errno` in their `libc`, with the
correct semantics, this should be fine.

Author: LGFae

Cargo.toml

@@ -25,3 +25,7 @@ anyhow = "1.0"
 [badges]
 is-it-maintained-issue-resolution = { repository = "diwic/alsa-rs" }
 is-it-maintained-open-issues = { repository = "diwic/alsa-rs" }
+
+[features]
+default = ["std"]
+std = []

src/card.rs

@@ -3,6 +3,7 @@ use libc::{c_int, c_char};
 use super::error::*;
 use crate::alsa;
 use core::ffi::CStr;
+use ::alloc::string::String;
 
 /// An ALSA sound card, uniquely identified by its index.
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
@@ -48,7 +49,8 @@ impl Card {
 
 #[test]
 fn print_cards() {
+    extern crate std;
     for a in Iter::new().map(|a| a.unwrap()) {
-        println!("Card #{}: {} ({})", a.get_index(), a.get_name().unwrap(), a.get_longname().unwrap())
+        std::println!("Card #{}: {} ({})", a.get_index(), a.get_name().unwrap(), a.get_longname().unwrap())
     }
 }

src/chmap.rs

@@ -1,6 +1,8 @@
 use crate::alsa;
 use core::{fmt, mem, slice};
 use super::error::*;
+use ::alloc::vec::Vec;
+use ::alloc::vec;
 
 alsa_enum!(
     /// [SND_CHMAP_TYPE_xxx](http://www.alsa-project.org/alsa-doc/alsa-lib/group___p_c_m.html) constants
@@ -136,6 +138,7 @@ impl Iterator for ChmapsQuery {
 
 #[test]
 fn chmap_for_first_pcm() {
+    extern crate std;
     use super::*;
     use ::alloc::ffi::CString;
     use crate::device_name::HintIter;
@@ -146,18 +149,18 @@ fn chmap_for_first_pcm() {
 
     let i = HintIter::new(None, &*CString::new("pcm").unwrap()).unwrap();
     for p in i.map(|n| n.name.unwrap()) {
-        println!("Chmaps for {:?}:", p);
+        std::println!("Chmaps for {:?}:", p);
         match PCM::open(&CString::new(p).unwrap(),  Direction::Playback, false) {
             Ok(a) => for c in a.query_chmaps() {
-               println!("  {:?}, {}", c.0, c.1);
+               std::println!("  {:?}, {}", c.0, c.1);
             },
-            Err(a) => println!("  {}", a) // It's okay to have entries in the name hint array that can't be opened
+            Err(a) => std::println!("  {}", a) // It's okay to have entries in the name hint array that can't be opened
         }
     }
 
     output.borrow_mut().buffer_string(|buf| {
         let str = CString::new(buf).unwrap();
-        println!("Errors:\n{}", str.to_str().unwrap());
+        std::println!("Errors:\n{}", str.to_str().unwrap());
     });
 
 }

src/config.rs

@@ -36,8 +36,9 @@ impl Config {
 
 #[test]
 fn config_save() {
+    extern crate std;
 	let c = update_ref().unwrap();
     let mut outp = Output::buffer_open().unwrap();
 	c.save(&mut outp).unwrap();
-    println!("== Config save ==\n{}", outp);
-}
+    std::println!("== Config save ==\n{}", outp);
+}

src/ctl_int.rs

@@ -61,7 +61,7 @@ impl Ctl {
     }
 
     pub fn from_card(c: &Card, nonblock: bool) -> Result<Ctl> {
-        let s = format!("hw:{}", c.get_index());
+        let s = ::alloc::format!("hw:{}", c.get_index());
         Ctl::open(&CString::new(s).unwrap(), nonblock)
     }
 
@@ -547,6 +547,7 @@ impl EventMask {
 
 #[test]
 fn print_sizeof() {
+    extern crate std;
     let elemid = unsafe { alsa::snd_ctl_elem_id_sizeof() } as usize;
     let elemvalue = unsafe { alsa::snd_ctl_elem_value_sizeof() } as usize;
     let eleminfo = unsafe { alsa::snd_ctl_elem_info_sizeof() } as usize;
@@ -555,5 +556,5 @@ fn print_sizeof() {
 //    assert!(elemvalue <= ELEM_VALUE_SIZE);
 //    assert!(eleminfo <= ELEM_INFO_SIZE);
 
-    println!("Elem id: {}, Elem value: {}, Elem info: {}", elemid, elemvalue, eleminfo);
+    std::println!("Elem id: {}, Elem value: {}, Elem info: {}", elemid, elemvalue, eleminfo);
 }

src/device_name.rs

@@ -21,6 +21,7 @@ use super::{Card, Direction};
 use super::error::*;
 use core::ffi::CStr;
 use ::alloc::ffi::CString;
+use ::alloc::string::String;
 
 /// [snd_device_name_hint](http://www.alsa-project.org/alsa-doc/alsa-lib/group___control.html) wrapper
 pub struct HintIter(*mut *mut c_void, isize);
@@ -83,9 +84,10 @@ impl Hint {
 
 #[test]
 fn print_hints() {
+    extern crate std;
     for t in &["pcm", "ctl", "rawmidi", "timer", "seq", "hwdep"] {
-        println!("{} devices:", t);
+        std::println!("{} devices:", t);
         let i = HintIter::new(None, &*CString::new(*t).unwrap()).unwrap();
-        for a in i { println!("  {:?}", a) }
+        for a in i { std::println!("  {:?}", a) }
     }
 }

src/direct/pcm.rs

@@ -518,6 +518,7 @@ impl<'a, S: 'static> Drop for CaptureIter<'a, S> {
 #[test]
 #[ignore] // Not everyone has a recording device on plughw:1. So let's ignore this test by default.
 fn record_from_plughw_rw() {
+    extern crate std;
     use crate::pcm::*;
     use crate::{ValueOr, Direction};
     use ::alloc::ffi::CString;
@@ -539,7 +540,7 @@ fn record_from_plughw_rw() {
     assert_eq!(ss.state(), State::Prepared);
     pcm.start().unwrap();
     assert_eq!(c.appl_ptr(), 0);
-    println!("{:?}, {:?}", ss, c);
+    std::println!("{:?}, {:?}", ss, c);
     let mut buf = [0i16; 512*2];
     assert_eq!(pcm.io_i16().unwrap().readi(&mut buf).unwrap(), 512);
     assert_eq!(c.appl_ptr(), 512);
@@ -554,10 +555,12 @@ fn record_from_plughw_rw() {
 #[test]
 #[ignore] // Not everyone has a record device on plughw:1. So let's ignore this test by default.
 fn record_from_plughw_mmap() {
+    extern crate std;
     use crate::pcm::*;
     use crate::{ValueOr, Direction};
     use ::alloc::ffi::CString;
-    use std::{thread, time};
+    use ::alloc::vec::Vec;
+    use std::{thread, time, println};
 
     let pcm = PCM::open(&*CString::new("plughw:1").unwrap(), Direction::Capture, false).unwrap();
     let hwp = HwParams::any(&pcm).unwrap();
@@ -598,6 +601,7 @@ fn record_from_plughw_mmap() {
 #[test]
 #[ignore]
 fn playback_to_plughw_mmap() {
+    extern crate std;
     use crate::pcm::*;
     use crate::{ValueOr, Direction};
     use ::alloc::ffi::CString;
@@ -615,7 +619,7 @@ fn playback_to_plughw_mmap() {
     assert_eq!(m.appl_ptr(), 0);
     assert_eq!(m.hw_ptr(), 0);
 
-    println!("{:?}", m);
+    std::println!("{:?}", m);
     let mut i = (0..(m.buffer_size() * 2)).map(|i|
         (((i / 2) as f32 * 2.0 * ::core::f32::consts::PI / 128.0).sin() * 8192.0) as i16);
     m.write(&mut i);

src/error.rs

@@ -4,6 +4,7 @@ use libc::{c_char, c_int, c_void, free};
 use core::error::Error as StdError;
 use core::ffi::CStr;
 use core::{fmt, str};
+use ::alloc::string::{String, ToString};
 
 /// ALSA error
 ///
@@ -12,10 +13,14 @@ use core::{fmt, str};
 /// An Error is also returned in case ALSA returns a string that
 /// cannot be translated into Rust's UTF-8 strings.
 #[derive(Clone, PartialEq, Copy)]
-pub struct Error(&'static str, i32);
+pub struct Error(&'static str, c_int);
 
 pub type Result<T> = ::core::result::Result<T, Error>;
 
+extern "C" {
+    pub(crate) static errno: c_int;
+}
+
 macro_rules! acheck {
     ($f: ident ( $($x: expr),* ) ) => {{
         let r = unsafe { alsa::$f( $($x),* ) };
@@ -67,9 +72,7 @@ impl Error {
     pub fn last(func: &'static str) -> Error {
         Self(
             func,
-            std::io::Error::last_os_error()
-                .raw_os_error()
-                .unwrap_or_default(),
+            unsafe {errno},
         )
     }
 
@@ -123,8 +126,8 @@ impl fmt::Display for Error {
 ///
 /// Note this doesn't include the total set of possible errno variants, but they
 /// can easily be added in the future for better error messages
-fn desc(errno: i32) -> &'static str {
-    match errno {
+fn desc(err: i32) -> &'static str {
+    match err {
         libc::EPERM => "Operation not permitted",
         libc::ENOENT => "No such file or directory",
         libc::ESRCH => "No such process",

src/hctl.rs

@@ -68,7 +68,7 @@ impl HCtl {
 
     /// Wrapper around open. You probably want to call `load` afterwards.
     pub fn from_card(c: &Card, nonblock: bool) -> Result<HCtl> {
-        let s = format!("hw:{}", c.get_index());
+        let s = ::alloc::format!("hw:{}", c.get_index());
         HCtl::new(&s, nonblock)
     }
 
@@ -144,32 +144,34 @@ impl<'a> Elem<'a> {
 
 #[test]
 fn print_hctls() {
+    extern crate std;
     for a in super::card::Iter::new().map(|x| x.unwrap()) {
         use ::alloc::ffi::CString;
-        let h = HCtl::open(&CString::new(format!("hw:{}", a.get_index())).unwrap(), false).unwrap();
+        let h = HCtl::open(&CString::new(::alloc::format!("hw:{}", a.get_index())).unwrap(), false).unwrap();
         h.load().unwrap();
-        println!("Card {}:", a.get_name().unwrap());
+        std::println!("Card {}:", a.get_name().unwrap());
         for b in h.elem_iter() {
-            println!("  {:?} - {:?}", b.get_id().unwrap(), b.read().unwrap());
+            std::println!("  {:?} - {:?}", b.get_id().unwrap(), b.read().unwrap());
         }
     }
 }
 
 #[test]
 fn print_jacks() {
+    extern crate std;
     for a in super::card::Iter::new().map(|x| x.unwrap()) {
         use ::alloc::ffi::CString;
-        let h = HCtl::open(&CString::new(format!("hw:{}", a.get_index())).unwrap(), false).unwrap();
+        let h = HCtl::open(&CString::new(::alloc::format!("hw:{}", a.get_index())).unwrap(), false).unwrap();
         h.load().unwrap();
         for b in h.elem_iter() {
             let id = b.get_id().unwrap();
             if id.get_interface() != super::ctl_int::ElemIface::Card { continue; }
             let name = id.get_name().unwrap();
             if !name.ends_with(" Jack") { continue; }
             if name.ends_with(" Phantom Jack") {
-                println!("{} is always present", &name[..name.len()-13])
+                std::println!("{} is always present", &name[..name.len()-13])
             }
-            else { println!("{} is {}", &name[..name.len()-5],
+            else { std::println!("{} is {}", &name[..name.len()-5],
                 if b.read().unwrap().get_boolean(0).unwrap() { "plugged in" } else { "unplugged" })
             }
         }

src/io.rs

@@ -10,7 +10,8 @@ pub struct Output(*mut alsa::snd_output_t);
 
 unsafe impl Send for Output {}
 
-thread_local! {
+#[cfg(feature = "std")]
+std::thread_local! {
     static ERROR_OUTPUT: RefCell<Option<Rc<RefCell<Output>>>> = RefCell::new(None);
 }
 
@@ -39,6 +40,7 @@ impl Output {
     ///
     /// Sometimes alsa-lib writes to stderr, but if you prefer, you can write it here instead.
     /// Should you wish to empty the buffer; just call local_error_handler again and drop the old instance.
+    #[cfg(feature = "std")]
     pub fn local_error_handler() -> Result<Rc<RefCell<Output>>> {
         let output = Output::buffer_open()?;
         let r = Rc::new(RefCell::new(output));
@@ -60,14 +62,15 @@ impl fmt::Debug for Output {
 impl fmt::Display for Output {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         self.buffer_string(|b| {
-            let s = String::from_utf8_lossy(b);
+            let s = ::alloc::string::String::from_utf8_lossy(b);
             f.write_str(&*s)
         })
     }
 }
 
 pub fn output_handle(o: &Output) -> *mut alsa::snd_output_t { o.0 }
 
+#[cfg(feature = "std")]
 unsafe extern "C" fn our_error_handler(file: *const c_char,
     line: c_int,
     func: *const c_char,