extendr_api/robj/debug.rs
1use crate::wrapper::*;
2// use crate::robj::GetSexp;
3use crate::robj::Attributes;
4use crate::robj::Rany;
5use crate::robj::Rinternals;
6use crate::robj::Robj;
7use crate::robj::Types;
8
9impl std::fmt::Debug for Symbol {
10 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11 if self.is_missing_arg() {
12 write!(f, "missing_arg()")
13 } else {
14 #[cfg(not(r_4_5))]
15 if self.is_unbound_value() {
16 return write!(f, "unbound_value()");
17 }
18 write!(f, "sym!({})", self.as_symbol().unwrap().as_str())
19 }
20 }
21}
22
23/// Implement {:?} formatting.
24impl std::fmt::Debug for Robj {
25 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
26 match self.as_any() {
27 Rany::Null(_) => write!(f, "()"),
28 Rany::Symbol(value) => value.fmt(f),
29 Rany::Pairlist(value) => value.fmt(f),
30 Rany::Function(value) => value.fmt(f),
31 Rany::Environment(value) => value.fmt(f),
32 Rany::Promise(value) => value.fmt(f),
33 Rany::Language(value) => value.fmt(f),
34 Rany::Special(value) => value.fmt(f),
35 Rany::Builtin(value) => value.fmt(f),
36 Rany::Rstr(value) => value.fmt(f),
37 Rany::Logicals(value) => value.fmt(f),
38 Rany::Integers(value) => value.fmt(f),
39 Rany::Doubles(value) => value.fmt(f),
40 Rany::Complexes(value) => value.fmt(f),
41 Rany::Strings(value) => write!(f, "{:?}", value.as_slice()),
42 Rany::Dot(_dot) => write!(f, "Dot"),
43 Rany::Any(_any) => write!(f, "Any"),
44 Rany::List(value) => value.fmt(f),
45 Rany::Expressions(value) => value.fmt(f),
46 Rany::Bytecode(_bytecode) => write!(f, "Bytecode"),
47 Rany::ExternalPtr(_externalptr) => write!(f, "ExternalPtr"),
48 Rany::WeakRef(_weakref) => write!(f, "Weakref"),
49 Rany::Raw(value) => value.fmt(f),
50 Rany::S4(value) => value.fmt(f),
51 Rany::Unknown(_unknown) => write!(f, "Unknown"),
52 }?;
53 /*
54 match self.sexptype() {
55 NILSXP => write!(f, "r!(NULL)"),
56 SYMSXP => {
57 if self.is_missing_arg() {
58 write!(f, "missing_arg()")
59 } else if self.is_unbound_value() {
60 write!(f, "unbound_value()")
61 } else {
62 write!(f, "sym!({})", self.as_symbol().unwrap().as_str())
63 }
64 }
65 LISTSXP => {
66 let pairlist = self.as_pairlist().unwrap().iter();
67 write!(f, "r!({:?})", pairlist)
68 }
69 CLOSXP => {
70 let func = self.as_function().unwrap();
71 let formals = func.formals();
72 let body = func.body();
73 let environment = func.environment();
74 write!(
75 f,
76 "r!(Function::from_parts({:?}, {:?}, {:?}))",
77 formals, body, environment
78 )
79 }
80 ENVSXP => unsafe {
81 let sexp = self.get();
82 if sexp == R_GlobalEnv {
83 write!(f, "global_env()")
84 } else if sexp == R_BaseEnv {
85 write!(f, "base_env()")
86 } else if sexp == R_EmptyEnv {
87 write!(f, "empty_env()")
88 } else {
89 write!(f, "r!(Environment::from_pairs(...))")
90 }
91 },
92 PROMSXP => {
93 let p = self.as_promise().unwrap();
94 write!(
95 f,
96 "r!(Promise::from_parts({:?}, {:?}))",
97 p.code(),
98 p.environment()
99 )
100 }
101 LANGSXP => write!(
102 f,
103 "r!(Language::from_values({:?}))",
104 self.as_language().unwrap().values().collect::<Vec<_>>()
105 ),
106 SPECIALSXP => write!(f, "r!(Special())"),
107 BUILTINSXP => write!(f, "r!(Builtin())"),
108 CHARSXP => {
109 let c = Rstr::try_from(self.clone()).unwrap();
110 write!(f, "r!(Rstr::from_string({:?}))", c.as_str())
111 }
112 LGLSXP => {
113 let slice = self.as_logical_slice().unwrap();
114 if slice.len() == 1 {
115 write!(f, "r!({:?})", slice[0])
116 } else {
117 write!(f, "r!({:?})", slice)
118 }
119 }
120 INTSXP => {
121 let slice = self.as_integer_slice().unwrap();
122 if slice.len() == 1 {
123 write!(f, "r!({:?})", slice[0])
124 } else {
125 write!(f, "r!({:?})", self.as_integer_slice().unwrap())
126 }
127 }
128 REALSXP => {
129 let slice = self.as_real_slice().unwrap();
130 if slice.len() == 1 {
131 write!(f, "r!({:?})", slice[0])
132 } else {
133 write!(f, "r!({:?})", slice)
134 }
135 }
136 VECSXP => {
137 let list = self.as_list().unwrap();
138 if self.names().is_some() {
139 write!(f, "r!(List::from_pairs({:?}))", list.iter())
140 } else {
141 write!(f, "r!(List::from_values({:?}))", list.values())
142 }
143 }
144 EXPRSXP => write!(
145 f,
146 "r!(Expressions::from_values({:?}))",
147 self.as_expressions().unwrap().values()
148 ),
149 WEAKREFSXP => write!(f, "r!(Weakref())"),
150 // CPLXSXP => false,
151 STRSXP => {
152 write!(f, "r!([")?;
153 let mut sep = "";
154 for s in self.as_str_iter().unwrap() {
155 // if s.is_na() {
156 // write!(f, "{}na_str()", sep)?;
157 // } else {
158 write!(f, "{}{:?}", sep, s)?;
159 // }
160 sep = ", ";
161 }
162 write!(f, "])")
163 }
164 DOTSXP => write!(f, "r!(Dot())"),
165 ANYSXP => write!(f, "r!(Any())"),
166 BCODESXP => write!(f, "r!(Bcode())"),
167 EXTPTRSXP => {
168 write!(f, "r!(ExternalPtr())")
169 }
170 RAWSXP => {
171 write!(
172 f,
173 "r!(Raw::from_bytes({:?}))",
174 self.as_raw().unwrap().as_slice()
175 )
176 }
177 S4SXP => write!(f, "r!(S4())"),
178 NEWSXP => write!(f, "r!(New())"),
179 FREESXP => write!(f, "r!(Free())"),
180 _ => write!(f, "??"),
181 }?;
182 */
183 if let Some(c) = self.class() {
184 write!(f, ".set_class({:?}", c)?;
185 }
186 Ok(())
187 }
188}