8000 miniquad/src/log.rs at vita-dxt5 · Anezium/miniquad · GitHub
[go: up one dir, main page]
Skip to content

log.rs

Latest commit

 

History

History
256 lines (226 loc) · 6.6 KB

log.rs

File metadata and controls

256 lines (226 loc) · 6.6 KB
Raw
/// This module is disabled by default
///
/// Most of the code gleaned from log-rs crate
///
/// Will send log calls like debug!(), warn!() and error!() to appropriate console_* call on wasm
/// and just println! on PC.
/// If you need better control of log messages - just dont use "log-impl" feature and use appropriate loggers from log-rs
use std::cmp;
#[repr(usize)]
#[derive(Copy, Clone, Eq, PartialEq, Debug, Hash)]
pub enum Level {
/// The "error" level.
///
/// Designates very serious errors.
Error = 1, // This way these line up with the discriminants for LevelFilter below
/// The "warn" level.
///
/// Designates hazardous situations.
Warn,
/// The "info" level.
///
/// Designates useful information.
Info,
/// The "debug" level.
///
/// Designates lower priority information.
Debug,
/// The "trace" level.
///
/// Designates very low priority, often extremely verbose, information.
Trace,
}
impl PartialOrd for Level {
#[inline]
fn partial_cmp(&self, other: &Level) -> Option<cmp::Ordering> {
Some(self.cmp(other))
}
#[inline]
fn lt(&self, other: &Level) -> bool {
(*self as usize) < *other as usize
}
#[inline]
fn le(&self, other: &Level) -> bool {
*self as usize <= *other as usize
}
#[inline]
fn gt(&self, other: &Level) -> bool {
*self as usize > *other as usize
}
#[inline]
fn ge(&self, other: &Level) -> bool {
*self as usize >= *other as usize
}
}
impl Ord for Level {
#[inline]
fn cmp(&self, other: &Level) -> cmp::Ordering {
(*self as usize).cmp(&(*other as usize))
}
}
#[macro_export(local_inner_macros)]
macro_rules! log {
(target: $target:expr, $lvl:expr, $message:expr) => ({
let lvl = $lvl;
//if lvl <= $crate::STATIC_MAX_LEVEL && lvl <= $crate::max_level() {
// ensure that $message is a valid format string literal
let _ = __log_format_args!($message);
$crate::log::__private_api_log_lit(
$message,
lvl,
&($target, __log_module_path!(), __log_file!(), __log_line!()),
);
//}
});
(target: $target:expr, $lvl:expr, $($arg:tt)+) => ({
let lvl = $lvl;
//if lvl <= $crate::STATIC_MAX_LEVEL && lvl <= $crate::max_level() {
$crate::log::__private_api_log_lit(
&__log_format_args!($($arg)+),
lvl,
&($target, __log_module_path!(), __log_file!(), __log_line!()),
);
//}
});
($lvl:expr, $($arg:tt)+) => (log!(target: __log_module_path!(), $lvl, $($arg)+))
}
#[macro_export(local_inner_macros)]
macro_rules! error {
(target: $target:expr, $($arg:tt)+) => (
log!(target: $target, $crate::Level::Error, $($arg)+);
);
($($arg:tt)+) => (
log!($crate::log::Level::Error, $($arg)+);
)
}
#[macro_export(local_inner_macros)]
macro_rules! warn {
(target: $target:expr, $($arg:tt)+) => (
log!(target: $target, $crate::Level::Warn, $($arg)+);
);
($($arg:tt)+) => (
log!($crate::log::Level::Warn, $($arg)+);
)
}
#[macro_export(local_inner_macros)]
macro_rules! info {
(target: $target:expr, $($arg:tt)+) => (
log!(target: $target, $crate::Level::Info, $($arg)+);
);
($($arg:tt)+) => (
log!($crate::log::Level::Info, $($arg)+);
)
}
#[macro_export(local_inner_macros)]
macro_rules! debug {
(target: $target:expr, $($arg:tt)+) => (
log!(target: $target, $crate::Level::Debug, $($arg)+);
);
($($arg:tt)+) => (
log!($crate::log::Level::Debug, $($arg)+);
)
}
#[macro_export(local_inner_macros)]
macro_rules! trace {
(target: $target:expr, $($arg:tt)+) => (
log!(target: $target, $crate::Level::Trace, $($arg)+);
);
($($arg:tt)+) => (
log!($crate::log::Level::Trace, $($arg)+);
)
}
/// log-rs used `macro_export(local_inner_macros)` instead of $crate::log! to support older rustc version
/// but actually there is an other difference - $crate::log does not support macros reexport :(
/// so even miniquad is fine with 1.31+ rustc version, we need to use local_inner_macros as well
#[doc(hidden)]
#[macro_export]
macro_rules! __log_format_args {
($($args:tt)*) => {
format!($($args)*)
};
}
#[doc(hidden)]
#[macro_export]
macro_rules! __log_module_path {
() => {
module_path!()
};
}
#[doc(hidden)]
#[macro_export]
macro_rules! __log_file {
() => {
file!()
};
}
#[doc(hidden)]
#[macro_export]
macro_rules! __log_line {
() => {
line!()
};
}
#[cfg(not(any(target_arch = "wasm32", target_os = "android", target_os = "ios")))]
pub fn __private_api_log_lit(
message: &str,
_level: Level,
&(_target, _module_path, _file, _line): &(&str, &'static str, &'static str, u32),
) {
eprintln!("{}", message);
}
#[cfg(target_arch = "wasm32")]
pub fn __private_api_log_lit(
message: &str,
level: Level,
&(_target, _module_path, _file, _line): &(&str, &'static str, &'static str, u32),
) {
use crate::native::wasm;
use std::ffi::CString;
let log_fn = match level {
Level::Debug => wasm::console_debug,
Level::Warn => wasm::console_warn,
Level::Info => wasm::console_info,
Level::Trace => wasm::console_debug,
Level::Error => wasm::console_error,
};
let msg = CString::new(message).unwrap_or_else(|_| panic!());
unsafe { log_fn(msg.as_ptr()) };
}
#[cfg(target_os = "android")]
pub fn __private_api_log_lit(
message: &str,
level: Level,
&(_target, _module_path, _file, _line): &(&str, &'static str, &'static str, u32),
) {
use std::ffi::CString;
let log_fn = match level {
Level::Debug => crate::native::android::console_debug,
Level::Warn => crate::native::android::console_warn,
Level::Info => crate::native::android::console_info,
Level::Trace => crate::native::android::console_debug,
Level::Error => crate::native::android::console_error,
};
let msg = CString::new(message).unwrap_or_else(|_| panic!());
unsafe { log_fn(msg.as_ptr()) };
}
#[cfg(target_os = "ios")]
pub fn __private_api_log_lit(
message: &str,
_level: Level,
&(_target, _module_path, _file, _line): &(&str, &'static str, &'static str, u32),
) {
crate::native::ios::log(message);
}
#[test]
fn test_logs() {
trace!("info");
trace!("info: {}", 1);
debug!("info");
debug!("info: {}", 1);
info!("info");
info!("info: {}", 1);
warn!("info");
warn!("info: {}", 1);
error!("info");
error!("info: {}", 1);
}
0