1 // Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
13 Runtime type reflection
17 #![allow(missing_doc)]
19 use std::intrinsics::{Disr, Opaque, TyDesc, TyVisitor};
24 * Trait for visitor that wishes to reflect on data.
26 * To use this, create a struct that encapsulates the set of pointers you wish
27 * to walk through a data structure, and implement both `MovePtr` for it as well
28 * as `TyVisitor`; then build a MovePtrAdaptor wrapped around your struct.
31 fn move_ptr(&mut self, adjustment: |*u8| -> *u8);
32 fn push_ptr(&mut self);
33 fn pop_ptr(&mut self);
36 /// Helper function for alignment calculation.
38 pub fn align(size: uint, align: uint) -> uint {
39 ((size + align) - 1u) & !(align - 1u)
42 /// Adaptor to wrap around visitors implementing MovePtr.
43 pub struct MovePtrAdaptor<V> {
47 impl<V:TyVisitor + MovePtr> MovePtrAdaptor<V> {
48 pub fn new(v: V) -> MovePtrAdaptor<V> {
49 MovePtrAdaptor { inner: v }
53 pub fn bump(&mut self, sz: uint) {
54 self.inner.move_ptr(|p| ((p as uint) + sz) as *u8)
58 pub fn align(&mut self, a: uint) {
59 self.inner.move_ptr(|p| align(p as uint, a) as *u8)
63 pub fn align_to<T>(&mut self) {
64 self.align(mem::min_align_of::<T>());
68 pub fn bump_past<T>(&mut self) {
69 self.bump(mem::size_of::<T>());
72 pub fn unwrap(self) -> V { self.inner }
75 /// Abstract type-directed pointer-movement using the MovePtr trait
76 impl<V:TyVisitor + MovePtr> TyVisitor for MovePtrAdaptor<V> {
77 fn visit_bot(&mut self) -> bool {
78 self.align_to::<()>();
79 if ! self.inner.visit_bot() { return false; }
80 self.bump_past::<()>();
84 fn visit_nil(&mut self) -> bool {
85 self.align_to::<()>();
86 if ! self.inner.visit_nil() { return false; }
87 self.bump_past::<()>();
91 fn visit_bool(&mut self) -> bool {
92 self.align_to::<bool>();
93 if ! self.inner.visit_bool() { return false; }
94 self.bump_past::<bool>();
98 fn visit_int(&mut self) -> bool {
99 self.align_to::<int>();
100 if ! self.inner.visit_int() { return false; }
101 self.bump_past::<int>();
105 fn visit_i8(&mut self) -> bool {
106 self.align_to::<i8>();
107 if ! self.inner.visit_i8() { return false; }
108 self.bump_past::<i8>();
112 fn visit_i16(&mut self) -> bool {
113 self.align_to::<i16>();
114 if ! self.inner.visit_i16() { return false; }
115 self.bump_past::<i16>();
119 fn visit_i32(&mut self) -> bool {
120 self.align_to::<i32>();
121 if ! self.inner.visit_i32() { return false; }
122 self.bump_past::<i32>();
126 fn visit_i64(&mut self) -> bool {
127 self.align_to::<i64>();
128 if ! self.inner.visit_i64() { return false; }
129 self.bump_past::<i64>();
133 fn visit_uint(&mut self) -> bool {
134 self.align_to::<uint>();
135 if ! self.inner.visit_uint() { return false; }
136 self.bump_past::<uint>();
140 fn visit_u8(&mut self) -> bool {
141 self.align_to::<u8>();
142 if ! self.inner.visit_u8() { return false; }
143 self.bump_past::<u8>();
147 fn visit_u16(&mut self) -> bool {
148 self.align_to::<u16>();
149 if ! self.inner.visit_u16() { return false; }
150 self.bump_past::<u16>();
154 fn visit_u32(&mut self) -> bool {
155 self.align_to::<u32>();
156 if ! self.inner.visit_u32() { return false; }
157 self.bump_past::<u32>();
161 fn visit_u64(&mut self) -> bool {
162 self.align_to::<u64>();
163 if ! self.inner.visit_u64() { return false; }
164 self.bump_past::<u64>();
168 fn visit_f32(&mut self) -> bool {
169 self.align_to::<f32>();
170 if ! self.inner.visit_f32() { return false; }
171 self.bump_past::<f32>();
175 fn visit_f64(&mut self) -> bool {
176 self.align_to::<f64>();
177 if ! self.inner.visit_f64() { return false; }
178 self.bump_past::<f64>();
182 fn visit_f128(&mut self) -> bool {
183 self.align_to::<f128>();
184 if ! self.inner.visit_f128() { return false; }
185 self.bump_past::<f128>();
189 fn visit_char(&mut self) -> bool {
190 self.align_to::<char>();
191 if ! self.inner.visit_char() { return false; }
192 self.bump_past::<char>();
196 fn visit_estr_slice(&mut self) -> bool {
197 self.align_to::<&'static str>();
198 if ! self.inner.visit_estr_slice() { return false; }
199 self.bump_past::<&'static str>();
203 fn visit_estr_fixed(&mut self, n: uint,
205 align: uint) -> bool {
207 if ! self.inner.visit_estr_fixed(n, sz, align) { return false; }
212 fn visit_box(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
213 self.align_to::<Gc<u8>>();
214 if ! self.inner.visit_box(mtbl, inner) { return false; }
215 self.bump_past::<Gc<u8>>();
219 fn visit_uniq(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
220 self.align_to::<Box<u8>>();
221 if ! self.inner.visit_uniq(mtbl, inner) { return false; }
222 self.bump_past::<Box<u8>>();
226 fn visit_ptr(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
227 self.align_to::<*u8>();
228 if ! self.inner.visit_ptr(mtbl, inner) { return false; }
229 self.bump_past::<*u8>();
233 fn visit_rptr(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
234 self.align_to::<&'static u8>();
235 if ! self.inner.visit_rptr(mtbl, inner) { return false; }
236 self.bump_past::<&'static u8>();
240 fn visit_evec_slice(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
241 self.align_to::<&'static [u8]>();
242 if ! self.inner.visit_evec_slice(mtbl, inner) { return false; }
243 self.bump_past::<&'static [u8]>();
247 fn visit_evec_fixed(&mut self, n: uint, sz: uint, align: uint,
248 mtbl: uint, inner: *TyDesc) -> bool {
250 if ! self.inner.visit_evec_fixed(n, sz, align, mtbl, inner) {
257 fn visit_enter_rec(&mut self, n_fields: uint, sz: uint, align: uint) -> bool {
259 if ! self.inner.visit_enter_rec(n_fields, sz, align) { return false; }
263 fn visit_rec_field(&mut self, i: uint, name: &str,
264 mtbl: uint, inner: *TyDesc) -> bool {
265 unsafe { self.align((*inner).align); }
266 if ! self.inner.visit_rec_field(i, name, mtbl, inner) {
269 unsafe { self.bump((*inner).size); }
273 fn visit_leave_rec(&mut self, n_fields: uint, sz: uint, align: uint) -> bool {
274 if ! self.inner.visit_leave_rec(n_fields, sz, align) { return false; }
278 fn visit_enter_class(&mut self, name: &str, named_fields: bool, n_fields: uint, sz: uint,
279 align: uint) -> bool {
281 if ! self.inner.visit_enter_class(name, named_fields, n_fields, sz, align) {
287 fn visit_class_field(&mut self, i: uint, name: &str, named: bool, mtbl: uint,
288 inner: *TyDesc) -> bool {
289 unsafe { self.align((*inner).align); }
290 if ! self.inner.visit_class_field(i, name, named, mtbl, inner) {
293 unsafe { self.bump((*inner).size); }
297 fn visit_leave_class(&mut self, name: &str, named_fields: bool, n_fields: uint, sz: uint,
298 align: uint) -> bool {
299 if ! self.inner.visit_leave_class(name, named_fields, n_fields, sz, align) {
305 fn visit_enter_tup(&mut self, n_fields: uint, sz: uint, align: uint) -> bool {
307 if ! self.inner.visit_enter_tup(n_fields, sz, align) { return false; }
311 fn visit_tup_field(&mut self, i: uint, inner: *TyDesc) -> bool {
312 unsafe { self.align((*inner).align); }
313 if ! self.inner.visit_tup_field(i, inner) { return false; }
314 unsafe { self.bump((*inner).size); }
318 fn visit_leave_tup(&mut self, n_fields: uint, sz: uint, align: uint) -> bool {
319 if ! self.inner.visit_leave_tup(n_fields, sz, align) { return false; }
323 fn visit_enter_fn(&mut self, purity: uint, proto: uint,
324 n_inputs: uint, retstyle: uint) -> bool {
325 if ! self.inner.visit_enter_fn(purity, proto, n_inputs, retstyle) {
331 fn visit_fn_input(&mut self, i: uint, mode: uint, inner: *TyDesc) -> bool {
332 if ! self.inner.visit_fn_input(i, mode, inner) { return false; }
336 fn visit_fn_output(&mut self, retstyle: uint, variadic: bool, inner: *TyDesc) -> bool {
337 if ! self.inner.visit_fn_output(retstyle, variadic, inner) { return false; }
341 fn visit_leave_fn(&mut self, purity: uint, proto: uint,
342 n_inputs: uint, retstyle: uint) -> bool {
343 if ! self.inner.visit_leave_fn(purity, proto, n_inputs, retstyle) {
349 fn visit_enter_enum(&mut self, n_variants: uint,
350 get_disr: unsafe extern fn(ptr: *Opaque) -> Disr,
351 sz: uint, align: uint)
354 if ! self.inner.visit_enter_enum(n_variants, get_disr, sz, align) {
360 fn visit_enter_enum_variant(&mut self, variant: uint,
363 name: &str) -> bool {
364 if ! self.inner.visit_enter_enum_variant(variant, disr_val,
371 fn visit_enum_variant_field(&mut self, i: uint, offset: uint, inner: *TyDesc) -> bool {
372 self.inner.push_ptr();
374 if ! self.inner.visit_enum_variant_field(i, offset, inner) { return false; }
375 self.inner.pop_ptr();
379 fn visit_leave_enum_variant(&mut self, variant: uint,
382 name: &str) -> bool {
383 if ! self.inner.visit_leave_enum_variant(variant, disr_val,
390 fn visit_leave_enum(&mut self, n_variants: uint,
391 get_disr: unsafe extern fn(ptr: *Opaque) -> Disr,
392 sz: uint, align: uint) -> bool {
393 if ! self.inner.visit_leave_enum(n_variants, get_disr, sz, align) {
400 fn visit_trait(&mut self, name: &str) -> bool {
401 self.align_to::<Box<TyVisitor>>();
402 if ! self.inner.visit_trait(name) { return false; }
403 self.bump_past::<Box<TyVisitor>>();
407 fn visit_param(&mut self, i: uint) -> bool {
408 if ! self.inner.visit_param(i) { return false; }
412 fn visit_self(&mut self) -> bool {
413 self.align_to::<&'static u8>();
414 if ! self.inner.visit_self() { return false; }
415 self.align_to::<&'static u8>();