artichoke_backend/extn/core/time/
mruby.rs

1//! FFI glue between the Rust trampolines and the mruby C interpreter.
2
3use std::ffi::CStr;
4
5use crate::extn::core::time::{self, trampoline};
6use crate::extn::prelude::*;
7
8const TIME_CSTR: &CStr = c"Time";
9
10pub fn init(interp: &mut Artichoke) -> InitializeResult<()> {
11    if interp.is_class_defined::<time::Time>() {
12        return Ok(());
13    }
14
15    let spec = class::Spec::new("Time", TIME_CSTR, None, Some(def::box_unbox_free::<time::Time>))?;
16    // NOTE: The ordering of method declarations in the builder below is the
17    // same as in `Init_Time` in MRI `time.c`.
18    class::Builder::for_spec(interp, &spec)
19        .value_is_rust_object()
20        // Constructor
21        .add_self_method("now", time_self_now, sys::mrb_args_none())?
22        .add_self_method("at", time_self_at, sys::mrb_args_req_and_opt(1, 3))?
23        .add_self_method("utc", time_self_mkutc, sys::mrb_args_any())?
24        .add_self_method("gm", time_self_mkutc, sys::mrb_args_any())?
25        .add_self_method("local", time_self_mktime, sys::mrb_args_any())?
26        .add_self_method("mktime", time_self_mktime, sys::mrb_args_any())?
27        // Core
28        .add_method("to_i", time_to_int, sys::mrb_args_none())?
29        .add_method("to_f", time_to_float, sys::mrb_args_none())?
30        .add_method("to_r", time_to_rational, sys::mrb_args_none())?
31        .add_method("<=>", time_cmp, sys::mrb_args_req(1))?
32        .add_method("eql?", time_eql, sys::mrb_args_none())?
33        .add_method("hash", time_hash, sys::mrb_args_none())?
34        .add_method("initialize", time_initialize, sys::mrb_args_any())?
35        .add_method(
36            "initialize_copy",
37            time_initialize_copy,
38            sys::mrb_args_req(1),
39        )?
40        // Mutators and converters
41        .add_method("localtime", time_mutate_to_local, sys::mrb_args_opt(1))?
42        .add_method("gmtime", time_mutate_to_utc, sys::mrb_args_none())?
43        .add_method("utc", time_mutate_to_utc, sys::mrb_args_none())?
44        .add_method("getlocal", time_as_local, sys::mrb_args_opt(1))?
45        .add_method("getgm", time_as_utc, sys::mrb_args_none())?
46        .add_method("getutc", time_as_utc, sys::mrb_args_none())?
47        // Inspect
48        .add_method("ctime", time_asctime, sys::mrb_args_none())?
49        .add_method("asctime", time_asctime, sys::mrb_args_none())?
50        .add_method("to_s", time_to_string, sys::mrb_args_none())?
51        .add_method("inspect", time_to_string, sys::mrb_args_none())?
52        .add_method("to_a", time_to_array, sys::mrb_args_none())?
53        // Math
54        .add_method("+", time_plus, sys::mrb_args_req(1))?
55        .add_method("-", time_minus, sys::mrb_args_req(1))?
56        // Coarse math
57        .add_method("succ", time_succ, sys::mrb_args_none())?
58        .add_method("round", time_round, sys::mrb_args_req(1))?
59        // Datetime
60        .add_method("sec", time_second, sys::mrb_args_none())?
61        .add_method("min", time_minute, sys::mrb_args_none())?
62        .add_method("hour", time_hour, sys::mrb_args_none())?
63        .add_method("mday", time_day, sys::mrb_args_none())?
64        .add_method("day", time_day, sys::mrb_args_none())?
65        .add_method("mon", time_month, sys::mrb_args_none())?
66        .add_method("month", time_month, sys::mrb_args_none())?
67        .add_method("year", time_year, sys::mrb_args_none())?
68        .add_method("wday", time_weekday, sys::mrb_args_none())?
69        .add_method("yday", time_year_day, sys::mrb_args_none())?
70        .add_method("isdst", time_is_dst, sys::mrb_args_none())?
71        .add_method("dst?", time_is_dst, sys::mrb_args_none())?
72        .add_method("zone", time_zone, sys::mrb_args_none())?
73        .add_method("gmtoff", time_utc_offset, sys::mrb_args_none())?
74        .add_method("gmt_offset", time_utc_offset, sys::mrb_args_none())?
75        .add_method("utc_offset", time_utc_offset, sys::mrb_args_none())?
76        // Timezone mode
77        .add_method("gmt?", time_is_utc, sys::mrb_args_none())?
78        .add_method("utc?", time_is_utc, sys::mrb_args_none())?
79        // Day of week
80        .add_method("sunday?", time_is_sunday, sys::mrb_args_none())?
81        .add_method("monday?", time_is_monday, sys::mrb_args_none())?
82        .add_method("tuesday?", time_is_tuesday, sys::mrb_args_none())?
83        .add_method("wednesday?", time_is_wednesday, sys::mrb_args_none())?
84        .add_method("thursday?", time_is_thursday, sys::mrb_args_none())?
85        .add_method("friday?", time_is_friday, sys::mrb_args_none())?
86        .add_method("saturday?", time_is_saturday, sys::mrb_args_none())?
87        // Unix time value
88        .add_method("tv_sec", time_to_int, sys::mrb_args_none())?
89        .add_method("tv_usec", time_microsecond, sys::mrb_args_none())?
90        .add_method("usec", time_microsecond, sys::mrb_args_none())?
91        .add_method("tv_nsec", time_nanosecond, sys::mrb_args_none())?
92        .add_method("nsec", time_nanosecond, sys::mrb_args_none())?
93        .add_method("subsec", time_subsec, sys::mrb_args_none())?
94        // Time format
95        .add_method("strftime", time_strftime, sys::mrb_args_req(1))?
96        .define()?;
97    interp.def_class::<time::Time>(spec)?;
98
99    Ok(())
100}
101
102// Constructor
103
104unsafe extern "C-unwind" fn time_self_now(mrb: *mut sys::mrb_state, _slf: sys::mrb_value) -> sys::mrb_value {
105    mrb_get_args!(mrb, none);
106    unwrap_interpreter!(mrb, to => guard);
107    let result = trampoline::now(&mut guard);
108    match result {
109        Ok(value) => value.inner(),
110        Err(exception) => {
111            // SAFETY: only Copy objects remain on the stack
112            unsafe { error::raise(guard, exception) }
113        }
114    }
115}
116
117unsafe extern "C-unwind" fn time_self_at(mrb: *mut sys::mrb_state, _slf: sys::mrb_value) -> sys::mrb_value {
118    let (seconds, opt1, opt2, opt3) = mrb_get_args!(mrb, required = 1, optional = 3);
119    unwrap_interpreter!(mrb, to => guard);
120    let seconds = Value::from(seconds);
121
122    let opt1 = opt1.map(Value::from);
123    let opt2 = opt2.map(Value::from);
124    let opt3 = opt3.map(Value::from);
125
126    let result = trampoline::at(&mut guard, seconds, opt1, opt2, opt3);
127    match result {
128        Ok(value) => value.inner(),
129        Err(exception) => {
130            // SAFETY: only Copy objects remain on the stack
131            unsafe { error::raise(guard, exception) }
132        }
133    }
134}
135
136unsafe extern "C-unwind" fn time_self_mkutc(mrb: *mut sys::mrb_state, _slf: sys::mrb_value) -> sys::mrb_value {
137    let args = mrb_get_args!(mrb, *args);
138    unwrap_interpreter!(mrb, to => guard);
139    let mut args = args.iter().copied().map(Value::from).collect::<Vec<Value>>();
140    let result = trampoline::mkutc(&mut guard, &mut args);
141    match result {
142        Ok(value) => value.inner(),
143        Err(exception) => {
144            // SAFETY: only Copy objects remain on the stack
145            unsafe { error::raise(guard, exception) }
146        }
147    }
148}
149
150unsafe extern "C-unwind" fn time_self_mktime(mrb: *mut sys::mrb_state, _slf: sys::mrb_value) -> sys::mrb_value {
151    let args = mrb_get_args!(mrb, *args);
152    unwrap_interpreter!(mrb, to => guard);
153    let mut args = args.iter().copied().map(Value::from).collect::<Vec<Value>>();
154    let result = trampoline::mktime(&mut guard, &mut args);
155    match result {
156        Ok(value) => value.inner(),
157        Err(exception) => {
158            // SAFETY: only Copy objects remain on the stack
159            unsafe { error::raise(guard, exception) }
160        }
161    }
162}
163
164// Core
165
166unsafe extern "C-unwind" fn time_to_int(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
167    mrb_get_args!(mrb, none);
168    unwrap_interpreter!(mrb, to => guard);
169    let time = Value::from(slf);
170    let result = trampoline::to_int(&mut guard, time);
171    match result {
172        Ok(value) => value.inner(),
173        Err(exception) => {
174            // SAFETY: only Copy objects remain on the stack
175            unsafe { error::raise(guard, exception) }
176        }
177    }
178}
179
180unsafe extern "C-unwind" fn time_to_float(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
181    mrb_get_args!(mrb, none);
182    unwrap_interpreter!(mrb, to => guard);
183    let time = Value::from(slf);
184    let result = trampoline::to_float(&mut guard, time);
185    match result {
186        Ok(value) => value.inner(),
187        Err(exception) => {
188            // SAFETY: only Copy objects remain on the stack
189            unsafe { error::raise(guard, exception) }
190        }
191    }
192}
193
194unsafe extern "C-unwind" fn time_to_rational(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
195    mrb_get_args!(mrb, none);
196    unwrap_interpreter!(mrb, to => guard);
197    let time = Value::from(slf);
198    let result = trampoline::to_rational(&mut guard, time);
199    match result {
200        Ok(value) => value.inner(),
201        Err(exception) => {
202            // SAFETY: only Copy objects remain on the stack
203            unsafe { error::raise(guard, exception) }
204        }
205    }
206}
207
208unsafe extern "C-unwind" fn time_cmp(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
209    let other = mrb_get_args!(mrb, required = 1);
210    unwrap_interpreter!(mrb, to => guard);
211    let time = Value::from(slf);
212    let other = Value::from(other);
213    let result = trampoline::cmp(&mut guard, time, other);
214    match result {
215        Ok(value) => value.inner(),
216        Err(exception) => {
217            // SAFETY: only Copy objects remain on the stack
218            unsafe { error::raise(guard, exception) }
219        }
220    }
221}
222
223unsafe extern "C-unwind" fn time_eql(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
224    let other = mrb_get_args!(mrb, required = 1);
225    unwrap_interpreter!(mrb, to => guard);
226    let time = Value::from(slf);
227    let other = Value::from(other);
228    let result = trampoline::eql(&mut guard, time, other);
229    match result {
230        Ok(value) => value.inner(),
231        Err(exception) => {
232            // SAFETY: only Copy objects remain on the stack
233            unsafe { error::raise(guard, exception) }
234        }
235    }
236}
237
238unsafe extern "C-unwind" fn time_hash(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
239    mrb_get_args!(mrb, none);
240    unwrap_interpreter!(mrb, to => guard);
241    let time = Value::from(slf);
242    let result = trampoline::hash(&mut guard, time);
243    match result {
244        Ok(value) => value.inner(),
245        Err(exception) => {
246            // SAFETY: only Copy objects remain on the stack
247            unsafe { error::raise(guard, exception) }
248        }
249    }
250}
251
252unsafe extern "C-unwind" fn time_initialize(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
253    let args = mrb_get_args!(mrb, *args);
254    unwrap_interpreter!(mrb, to => guard);
255    let time = Value::from(slf);
256    let args = args.iter().copied().map(Value::from);
257    let result = trampoline::initialize(&mut guard, time, args);
258    match result {
259        Ok(value) => value.inner(),
260        Err(exception) => {
261            // SAFETY: only Copy objects remain on the stack
262            unsafe { error::raise(guard, exception) }
263        }
264    }
265}
266
267unsafe extern "C-unwind" fn time_initialize_copy(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
268    let other = mrb_get_args!(mrb, required = 1);
269    unwrap_interpreter!(mrb, to => guard);
270    let time = Value::from(slf);
271    let other = Value::from(other);
272    let result = trampoline::initialize_copy(&mut guard, time, other);
273    match result {
274        Ok(value) => value.inner(),
275        Err(exception) => {
276            // SAFETY: only Copy objects remain on the stack
277            unsafe { error::raise(guard, exception) }
278        }
279    }
280}
281
282// Mutators and converters
283
284unsafe extern "C-unwind" fn time_mutate_to_local(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
285    let utc_offset = mrb_get_args!(mrb, optional = 1);
286    unwrap_interpreter!(mrb, to => guard);
287    let time = Value::from(slf);
288    let utc_offset = utc_offset.map(Value::from);
289    let result = trampoline::mutate_to_local(&mut guard, time, utc_offset);
290    match result {
291        Ok(value) => value.inner(),
292        Err(exception) => {
293            // SAFETY: only Copy objects remain on the stack
294            unsafe { error::raise(guard, exception) }
295        }
296    }
297}
298
299unsafe extern "C-unwind" fn time_mutate_to_utc(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
300    mrb_get_args!(mrb, none);
301    unwrap_interpreter!(mrb, to => guard);
302    let time = Value::from(slf);
303    let result = trampoline::mutate_to_utc(&mut guard, time);
304    match result {
305        Ok(value) => value.inner(),
306        Err(exception) => {
307            // SAFETY: only Copy objects remain on the stack
308            unsafe { error::raise(guard, exception) }
309        }
310    }
311}
312
313unsafe extern "C-unwind" fn time_as_local(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
314    let utc_offset = mrb_get_args!(mrb, optional = 1);
315    unwrap_interpreter!(mrb, to => guard);
316    let time = Value::from(slf);
317    let utc_offset = utc_offset.map(Value::from);
318    let result = trampoline::as_local(&mut guard, time, utc_offset);
319    match result {
320        Ok(value) => value.inner(),
321        Err(exception) => {
322            // SAFETY: only Copy objects remain on the stack
323            unsafe { error::raise(guard, exception) }
324        }
325    }
326}
327
328unsafe extern "C-unwind" fn time_as_utc(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
329    mrb_get_args!(mrb, none);
330    unwrap_interpreter!(mrb, to => guard);
331    let time = Value::from(slf);
332    let result = trampoline::as_utc(&mut guard, time);
333    match result {
334        Ok(value) => value.inner(),
335        Err(exception) => {
336            // SAFETY: only Copy objects remain on the stack
337            unsafe { error::raise(guard, exception) }
338        }
339    }
340}
341
342// Inspect
343
344unsafe extern "C-unwind" fn time_asctime(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
345    mrb_get_args!(mrb, none);
346    unwrap_interpreter!(mrb, to => guard);
347    let time = Value::from(slf);
348    let result = trampoline::asctime(&mut guard, time);
349    match result {
350        Ok(value) => value.inner(),
351        Err(exception) => {
352            // SAFETY: only Copy objects remain on the stack
353            unsafe { error::raise(guard, exception) }
354        }
355    }
356}
357
358unsafe extern "C-unwind" fn time_to_string(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
359    mrb_get_args!(mrb, none);
360    unwrap_interpreter!(mrb, to => guard);
361    let time = Value::from(slf);
362    let result = trampoline::to_string(&mut guard, time);
363    match result {
364        Ok(value) => value.inner(),
365        Err(exception) => {
366            // SAFETY: only Copy objects remain on the stack
367            unsafe { error::raise(guard, exception) }
368        }
369    }
370}
371
372unsafe extern "C-unwind" fn time_to_array(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
373    mrb_get_args!(mrb, none);
374    unwrap_interpreter!(mrb, to => guard);
375    let time = Value::from(slf);
376    let result = trampoline::to_array(&mut guard, time);
377    match result {
378        Ok(value) => value.inner(),
379        Err(exception) => {
380            // SAFETY: only Copy objects remain on the stack
381            unsafe { error::raise(guard, exception) }
382        }
383    }
384}
385
386// Math
387
388unsafe extern "C-unwind" fn time_plus(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
389    let other = mrb_get_args!(mrb, required = 1);
390    unwrap_interpreter!(mrb, to => guard);
391    let time = Value::from(slf);
392    let other = Value::from(other);
393    let result = trampoline::plus(&mut guard, time, other);
394    match result {
395        Ok(value) => value.inner(),
396        Err(exception) => {
397            // SAFETY: only Copy objects remain on the stack
398            unsafe { error::raise(guard, exception) }
399        }
400    }
401}
402
403unsafe extern "C-unwind" fn time_minus(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
404    let other = mrb_get_args!(mrb, required = 1);
405    unwrap_interpreter!(mrb, to => guard);
406    let time = Value::from(slf);
407    let other = Value::from(other);
408    let result = trampoline::minus(&mut guard, time, other);
409    match result {
410        Ok(value) => value.inner(),
411        Err(exception) => {
412            // SAFETY: only Copy objects remain on the stack
413            unsafe { error::raise(guard, exception) }
414        }
415    }
416}
417
418// Coarse math
419
420unsafe extern "C-unwind" fn time_succ(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
421    mrb_get_args!(mrb, none);
422    unwrap_interpreter!(mrb, to => guard);
423    let time = Value::from(slf);
424    let result = trampoline::succ(&mut guard, time);
425    match result {
426        Ok(value) => value.inner(),
427        Err(exception) => {
428            // SAFETY: only Copy objects remain on the stack
429            unsafe { error::raise(guard, exception) }
430        }
431    }
432}
433
434unsafe extern "C-unwind" fn time_round(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
435    let num_digits = mrb_get_args!(mrb, optional = 1);
436    unwrap_interpreter!(mrb, to => guard);
437    let time = Value::from(slf);
438    let num_digits = num_digits.map(Value::from);
439    let result = trampoline::round(&mut guard, time, num_digits);
440    match result {
441        Ok(value) => value.inner(),
442        Err(exception) => {
443            // SAFETY: only Copy objects remain on the stack
444            unsafe { error::raise(guard, exception) }
445        }
446    }
447}
448
449// Datetime
450
451unsafe extern "C-unwind" fn time_second(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
452    mrb_get_args!(mrb, none);
453    unwrap_interpreter!(mrb, to => guard);
454    let time = Value::from(slf);
455    let result = trampoline::second(&mut guard, time);
456    match result {
457        Ok(value) => value.inner(),
458        Err(exception) => {
459            // SAFETY: only Copy objects remain on the stack
460            unsafe { error::raise(guard, exception) }
461        }
462    }
463}
464
465unsafe extern "C-unwind" fn time_minute(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
466    mrb_get_args!(mrb, none);
467    unwrap_interpreter!(mrb, to => guard);
468    let time = Value::from(slf);
469    let result = trampoline::minute(&mut guard, time);
470    match result {
471        Ok(value) => value.inner(),
472        Err(exception) => {
473            // SAFETY: only Copy objects remain on the stack
474            unsafe { error::raise(guard, exception) }
475        }
476    }
477}
478
479unsafe extern "C-unwind" fn time_hour(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
480    mrb_get_args!(mrb, none);
481    unwrap_interpreter!(mrb, to => guard);
482    let time = Value::from(slf);
483    let result = trampoline::hour(&mut guard, time);
484    match result {
485        Ok(value) => value.inner(),
486        Err(exception) => {
487            // SAFETY: only Copy objects remain on the stack
488            unsafe { error::raise(guard, exception) }
489        }
490    }
491}
492
493unsafe extern "C-unwind" fn time_day(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
494    mrb_get_args!(mrb, none);
495    unwrap_interpreter!(mrb, to => guard);
496    let time = Value::from(slf);
497    let result = trampoline::day(&mut guard, time);
498    match result {
499        Ok(value) => value.inner(),
500        Err(exception) => {
501            // SAFETY: only Copy objects remain on the stack
502            unsafe { error::raise(guard, exception) }
503        }
504    }
505}
506
507unsafe extern "C-unwind" fn time_month(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
508    mrb_get_args!(mrb, none);
509    unwrap_interpreter!(mrb, to => guard);
510    let time = Value::from(slf);
511    let result = trampoline::month(&mut guard, time);
512    match result {
513        Ok(value) => value.inner(),
514        Err(exception) => {
515            // SAFETY: only Copy objects remain on the stack
516            unsafe { error::raise(guard, exception) }
517        }
518    }
519}
520
521unsafe extern "C-unwind" fn time_year(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
522    mrb_get_args!(mrb, none);
523    unwrap_interpreter!(mrb, to => guard);
524    let time = Value::from(slf);
525    let result = trampoline::year(&mut guard, time);
526    match result {
527        Ok(value) => value.inner(),
528        Err(exception) => {
529            // SAFETY: only Copy objects remain on the stack
530            unsafe { error::raise(guard, exception) }
531        }
532    }
533}
534
535unsafe extern "C-unwind" fn time_weekday(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
536    mrb_get_args!(mrb, none);
537    unwrap_interpreter!(mrb, to => guard);
538    let time = Value::from(slf);
539    let result = trampoline::weekday(&mut guard, time);
540    match result {
541        Ok(value) => value.inner(),
542        Err(exception) => {
543            // SAFETY: only Copy objects remain on the stack
544            unsafe { error::raise(guard, exception) }
545        }
546    }
547}
548
549unsafe extern "C-unwind" fn time_year_day(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
550    mrb_get_args!(mrb, none);
551    unwrap_interpreter!(mrb, to => guard);
552    let time = Value::from(slf);
553    let result = trampoline::year_day(&mut guard, time);
554    match result {
555        Ok(value) => value.inner(),
556        Err(exception) => {
557            // SAFETY: only Copy objects remain on the stack
558            unsafe { error::raise(guard, exception) }
559        }
560    }
561}
562
563unsafe extern "C-unwind" fn time_is_dst(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
564    mrb_get_args!(mrb, none);
565    unwrap_interpreter!(mrb, to => guard);
566    let time = Value::from(slf);
567    let result = trampoline::is_dst(&mut guard, time);
568    match result {
569        Ok(value) => value.inner(),
570        Err(exception) => {
571            // SAFETY: only Copy objects remain on the stack
572            unsafe { error::raise(guard, exception) }
573        }
574    }
575}
576
577unsafe extern "C-unwind" fn time_zone(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
578    mrb_get_args!(mrb, none);
579    unwrap_interpreter!(mrb, to => guard);
580    let time = Value::from(slf);
581    let result = trampoline::timezone(&mut guard, time);
582    match result {
583        Ok(value) => value.inner(),
584        Err(exception) => {
585            // SAFETY: only Copy objects remain on the stack
586            unsafe { error::raise(guard, exception) }
587        }
588    }
589}
590
591unsafe extern "C-unwind" fn time_utc_offset(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
592    mrb_get_args!(mrb, none);
593    unwrap_interpreter!(mrb, to => guard);
594    let time = Value::from(slf);
595    let result = trampoline::utc_offset(&mut guard, time);
596    match result {
597        Ok(value) => value.inner(),
598        Err(exception) => {
599            // SAFETY: only Copy objects remain on the stack
600            unsafe { error::raise(guard, exception) }
601        }
602    }
603}
604
605// Timezone mode
606
607unsafe extern "C-unwind" fn time_is_utc(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
608    mrb_get_args!(mrb, none);
609    unwrap_interpreter!(mrb, to => guard);
610    let time = Value::from(slf);
611    let result = trampoline::is_utc(&mut guard, time);
612    match result {
613        Ok(value) => value.inner(),
614        Err(exception) => {
615            // SAFETY: only Copy objects remain on the stack
616            unsafe { error::raise(guard, exception) }
617        }
618    }
619}
620
621// Day of week
622
623unsafe extern "C-unwind" fn time_is_sunday(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
624    mrb_get_args!(mrb, none);
625    unwrap_interpreter!(mrb, to => guard);
626    let time = Value::from(slf);
627    let result = trampoline::is_sunday(&mut guard, time);
628    match result {
629        Ok(value) => value.inner(),
630        Err(exception) => {
631            // SAFETY: only Copy objects remain on the stack
632            unsafe { error::raise(guard, exception) }
633        }
634    }
635}
636
637unsafe extern "C-unwind" fn time_is_monday(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
638    mrb_get_args!(mrb, none);
639    unwrap_interpreter!(mrb, to => guard);
640    let time = Value::from(slf);
641    let result = trampoline::is_monday(&mut guard, time);
642    match result {
643        Ok(value) => value.inner(),
644        Err(exception) => {
645            // SAFETY: only Copy objects remain on the stack
646            unsafe { error::raise(guard, exception) }
647        }
648    }
649}
650
651unsafe extern "C-unwind" fn time_is_tuesday(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
652    mrb_get_args!(mrb, none);
653    unwrap_interpreter!(mrb, to => guard);
654    let time = Value::from(slf);
655    let result = trampoline::is_tuesday(&mut guard, time);
656    match result {
657        Ok(value) => value.inner(),
658        Err(exception) => {
659            // SAFETY: only Copy objects remain on the stack
660            unsafe { error::raise(guard, exception) }
661        }
662    }
663}
664
665unsafe extern "C-unwind" fn time_is_wednesday(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
666    mrb_get_args!(mrb, none);
667    unwrap_interpreter!(mrb, to => guard);
668    let time = Value::from(slf);
669    let result = trampoline::is_wednesday(&mut guard, time);
670    match result {
671        Ok(value) => value.inner(),
672        Err(exception) => {
673            // SAFETY: only Copy objects remain on the stack
674            unsafe { error::raise(guard, exception) }
675        }
676    }
677}
678
679unsafe extern "C-unwind" fn time_is_thursday(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
680    mrb_get_args!(mrb, none);
681    unwrap_interpreter!(mrb, to => guard);
682    let time = Value::from(slf);
683    let result = trampoline::is_thursday(&mut guard, time);
684    match result {
685        Ok(value) => value.inner(),
686        Err(exception) => {
687            // SAFETY: only Copy objects remain on the stack
688            unsafe { error::raise(guard, exception) }
689        }
690    }
691}
692
693unsafe extern "C-unwind" fn time_is_friday(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
694    mrb_get_args!(mrb, none);
695    unwrap_interpreter!(mrb, to => guard);
696    let time = Value::from(slf);
697    let result = trampoline::is_friday(&mut guard, time);
698    match result {
699        Ok(value) => value.inner(),
700        Err(exception) => {
701            // SAFETY: only Copy objects remain on the stack
702            unsafe { error::raise(guard, exception) }
703        }
704    }
705}
706
707unsafe extern "C-unwind" fn time_is_saturday(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
708    mrb_get_args!(mrb, none);
709    unwrap_interpreter!(mrb, to => guard);
710    let time = Value::from(slf);
711    let result = trampoline::is_saturday(&mut guard, time);
712    match result {
713        Ok(value) => value.inner(),
714        Err(exception) => {
715            // SAFETY: only Copy objects remain on the stack
716            unsafe { error::raise(guard, exception) }
717        }
718    }
719}
720
721// Unix time value
722
723unsafe extern "C-unwind" fn time_microsecond(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
724    mrb_get_args!(mrb, none);
725    unwrap_interpreter!(mrb, to => guard);
726    let time = Value::from(slf);
727    let result = trampoline::microsecond(&mut guard, time);
728    match result {
729        Ok(value) => value.inner(),
730        Err(exception) => {
731            // SAFETY: only Copy objects remain on the stack
732            unsafe { error::raise(guard, exception) }
733        }
734    }
735}
736
737unsafe extern "C-unwind" fn time_nanosecond(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
738    mrb_get_args!(mrb, none);
739    unwrap_interpreter!(mrb, to => guard);
740    let time = Value::from(slf);
741    let result = trampoline::nanosecond(&mut guard, time);
742    match result {
743        Ok(value) => value.inner(),
744        Err(exception) => {
745            // SAFETY: only Copy objects remain on the stack
746            unsafe { error::raise(guard, exception) }
747        }
748    }
749}
750
751unsafe extern "C-unwind" fn time_subsec(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
752    mrb_get_args!(mrb, none);
753    unwrap_interpreter!(mrb, to => guard);
754    let time = Value::from(slf);
755    let result = trampoline::subsec(&mut guard, time);
756    match result {
757        Ok(value) => value.inner(),
758        Err(exception) => {
759            // SAFETY: only Copy objects remain on the stack
760            unsafe { error::raise(guard, exception) }
761        }
762    }
763}
764
765// Time format
766
767unsafe extern "C-unwind" fn time_strftime(mrb: *mut sys::mrb_state, slf: sys::mrb_value) -> sys::mrb_value {
768    let format = mrb_get_args!(mrb, required = 1);
769    unwrap_interpreter!(mrb, to => guard);
770    let time = Value::from(slf);
771    let format = Value::from(format);
772    let result = trampoline::strftime(&mut guard, time, format);
773    match result {
774        Ok(value) => value.inner(),
775        Err(exception) => {
776            // SAFETY: only Copy objects remain on the stack
777            unsafe { error::raise(guard, exception) }
778        }
779    }
780}
artichoke_backend/extn/core/time/mruby.rs

artichoke_backend/extn/core/time/
mruby.rs
