src/libdebug/reflect.rs

   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.
   4 //
   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.
  10
  11 /*!
  12
  13 Runtime type reflection
  14
  15 */
  16
  17 #![allow(missing_doc)]
  18
  19 use std::intrinsics::{Disr, Opaque, TyDesc, TyVisitor};
  20 use std::mem;
  21 use std::gc::Gc;
  22
  23 /**
  24  * Trait for visitor that wishes to reflect on data.
  25  *
  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.
  29  */
  30 pub trait MovePtr {
  31     fn move_ptr(&mut self, adjustment: |*const u8| -> *const u8);
  32     fn push_ptr(&mut self);
  33     fn pop_ptr(&mut self);
  34 }
  35
  36 /// Helper function for alignment calculation.
  37 #[inline]
  38 pub fn align(size: uint, align: uint) -> uint {
  39     ((size + align) - 1u) & !(align - 1u)
  40 }
  41
  42 /// Adaptor to wrap around visitors implementing MovePtr.
  43 pub struct MovePtrAdaptor<V> {
  44     inner: V
  45 }
  46
  47 impl<V:TyVisitor + MovePtr> MovePtrAdaptor<V> {
  48     pub fn new(v: V) -> MovePtrAdaptor<V> {
  49         MovePtrAdaptor { inner: v }
  50     }
  51
  52     #[inline]
  53     pub fn bump(&mut self, sz: uint) {
  54         self.inner.move_ptr(|p| ((p as uint) + sz) as *const u8)
  55     }
  56
  57     #[inline]
  58     pub fn align(&mut self, a: uint) {
  59         self.inner.move_ptr(|p| align(p as uint, a) as *const u8)
  60     }
  61
  62     #[inline]
  63     pub fn align_to<T>(&mut self) {
  64         self.align(mem::min_align_of::<T>());
  65     }
  66
  67     #[inline]
  68     pub fn bump_past<T>(&mut self) {
  69         self.bump(mem::size_of::<T>());
  70     }
  71
  72     pub fn unwrap(self) -> V { self.inner }
  73 }
  74
  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::<()>();
  81         true
  82     }
  83
  84     fn visit_nil(&mut self) -> bool {
  85         self.align_to::<()>();
  86         if ! self.inner.visit_nil() { return false; }
  87         self.bump_past::<()>();
  88         true
  89     }
  90
  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>();
  95         true
  96     }
  97
  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>();
 102         true
 103     }
 104
 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>();
 109         true
 110     }
 111
 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>();
 116         true
 117     }
 118
 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>();
 123         true
 124     }
 125
 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>();
 130         true
 131     }
 132
 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>();
 137         true
 138     }
 139
 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>();
 144         true
 145     }
 146
 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>();
 151         true
 152     }
 153
 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>();
 158         true
 159     }
 160
 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>();
 165         true
 166     }
 167
 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>();
 172         true
 173     }
 174
 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>();
 179         true
 180     }
 181
 182     fn visit_char(&mut self) -> bool {
 183         self.align_to::<char>();
 184         if ! self.inner.visit_char() { return false; }
 185         self.bump_past::<char>();
 186         true
 187     }
 188
 189     fn visit_estr_slice(&mut self) -> bool {
 190         self.align_to::<&'static str>();
 191         if ! self.inner.visit_estr_slice() { return false; }
 192         self.bump_past::<&'static str>();
 193         true
 194     }
 195
 196     fn visit_estr_fixed(&mut self, n: uint,
 197                         sz: uint,
 198                         align: uint) -> bool {
 199         self.align(align);
 200         if ! self.inner.visit_estr_fixed(n, sz, align) { return false; }
 201         self.bump(sz);
 202         true
 203     }
 204
 205     fn visit_box(&mut self, mtbl: uint, inner: *const TyDesc) -> bool {
 206         self.align_to::<Gc<u8>>();
 207         if ! self.inner.visit_box(mtbl, inner) { return false; }
 208         self.bump_past::<Gc<u8>>();
 209         true
 210     }
 211
 212     fn visit_uniq(&mut self, mtbl: uint, inner: *const TyDesc) -> bool {
 213         self.align_to::<Box<u8>>();
 214         if ! self.inner.visit_uniq(mtbl, inner) { return false; }
 215         self.bump_past::<Box<u8>>();
 216         true
 217     }
 218
 219     fn visit_ptr(&mut self, mtbl: uint, inner: *const TyDesc) -> bool {
 220         self.align_to::<*const u8>();
 221         if ! self.inner.visit_ptr(mtbl, inner) { return false; }
 222         self.bump_past::<*const u8>();
 223         true
 224     }
 225
 226     fn visit_rptr(&mut self, mtbl: uint, inner: *const TyDesc) -> bool {
 227         self.align_to::<&'static u8>();
 228         if ! self.inner.visit_rptr(mtbl, inner) { return false; }
 229         self.bump_past::<&'static u8>();
 230         true
 231     }
 232
 233     fn visit_evec_slice(&mut self, mtbl: uint, inner: *const TyDesc) -> bool {
 234         self.align_to::<&'static [u8]>();
 235         if ! self.inner.visit_evec_slice(mtbl, inner) { return false; }
 236         self.bump_past::<&'static [u8]>();
 237         true
 238     }
 239
 240     fn visit_evec_fixed(&mut self, n: uint, sz: uint, align: uint,
 241                         mtbl: uint, inner: *const TyDesc) -> bool {
 242         self.align(align);
 243         if ! self.inner.visit_evec_fixed(n, sz, align, mtbl, inner) {
 244             return false;
 245         }
 246         self.bump(sz);
 247         true
 248     }
 249
 250     fn visit_enter_rec(&mut self, n_fields: uint, sz: uint, align: uint) -> bool {
 251         self.align(align);
 252         if ! self.inner.visit_enter_rec(n_fields, sz, align) { return false; }
 253         true
 254     }
 255
 256     fn visit_rec_field(&mut self, i: uint, name: &str,
 257                        mtbl: uint, inner: *const TyDesc) -> bool {
 258         unsafe { self.align((*inner).align); }
 259         if ! self.inner.visit_rec_field(i, name, mtbl, inner) {
 260             return false;
 261         }
 262         unsafe { self.bump((*inner).size); }
 263         true
 264     }
 265
 266     fn visit_leave_rec(&mut self, n_fields: uint, sz: uint, align: uint) -> bool {
 267         if ! self.inner.visit_leave_rec(n_fields, sz, align) { return false; }
 268         true
 269     }
 270
 271     fn visit_enter_class(&mut self, name: &str, named_fields: bool, n_fields: uint, sz: uint,
 272                          align: uint) -> bool {
 273         self.align(align);
 274         if ! self.inner.visit_enter_class(name, named_fields, n_fields, sz, align) {
 275             return false;
 276         }
 277         true
 278     }
 279
 280     fn visit_class_field(&mut self, i: uint, name: &str, named: bool, mtbl: uint,
 281                          inner: *const TyDesc) -> bool {
 282         unsafe { self.align((*inner).align); }
 283         if ! self.inner.visit_class_field(i, name, named, mtbl, inner) {
 284             return false;
 285         }
 286         unsafe { self.bump((*inner).size); }
 287         true
 288     }
 289
 290     fn visit_leave_class(&mut self, name: &str, named_fields: bool, n_fields: uint, sz: uint,
 291                          align: uint) -> bool {
 292         if ! self.inner.visit_leave_class(name, named_fields, n_fields, sz, align) {
 293             return false;
 294         }
 295         true
 296     }
 297
 298     fn visit_enter_tup(&mut self, n_fields: uint, sz: uint, align: uint) -> bool {
 299         self.align(align);
 300         if ! self.inner.visit_enter_tup(n_fields, sz, align) { return false; }
 301         true
 302     }
 303
 304     fn visit_tup_field(&mut self, i: uint, inner: *const TyDesc) -> bool {
 305         unsafe { self.align((*inner).align); }
 306         if ! self.inner.visit_tup_field(i, inner) { return false; }
 307         unsafe { self.bump((*inner).size); }
 308         true
 309     }
 310
 311     fn visit_leave_tup(&mut self, n_fields: uint, sz: uint, align: uint) -> bool {
 312         if ! self.inner.visit_leave_tup(n_fields, sz, align) { return false; }
 313         true
 314     }
 315
 316     fn visit_enter_fn(&mut self, purity: uint, proto: uint,
 317                       n_inputs: uint, retstyle: uint) -> bool {
 318         if ! self.inner.visit_enter_fn(purity, proto, n_inputs, retstyle) {
 319             return false
 320         }
 321         true
 322     }
 323
 324     fn visit_fn_input(&mut self, i: uint, mode: uint,
 325                       inner: *const TyDesc) -> bool {
 326         if ! self.inner.visit_fn_input(i, mode, inner) { return false; }
 327         true
 328     }
 329
 330     fn visit_fn_output(&mut self, retstyle: uint, variadic: bool,
 331                        inner: *const TyDesc) -> bool {
 332         if ! self.inner.visit_fn_output(retstyle, variadic, inner) { return false; }
 333         true
 334     }
 335
 336     fn visit_leave_fn(&mut self, purity: uint, proto: uint,
 337                       n_inputs: uint, retstyle: uint) -> bool {
 338         if ! self.inner.visit_leave_fn(purity, proto, n_inputs, retstyle) {
 339             return false;
 340         }
 341         true
 342     }
 343
 344     fn visit_enter_enum(&mut self, n_variants: uint,
 345                         get_disr: unsafe extern fn(ptr: *const Opaque) -> Disr,
 346                         sz: uint, align: uint)
 347                      -> bool {
 348         self.align(align);
 349         if ! self.inner.visit_enter_enum(n_variants, get_disr, sz, align) {
 350             return false;
 351         }
 352         true
 353     }
 354
 355     fn visit_enter_enum_variant(&mut self, variant: uint,
 356                                 disr_val: Disr,
 357                                 n_fields: uint,
 358                                 name: &str) -> bool {
 359         if ! self.inner.visit_enter_enum_variant(variant, disr_val,
 360                                                  n_fields, name) {
 361             return false;
 362         }
 363         true
 364     }
 365
 366     fn visit_enum_variant_field(&mut self, i: uint, offset: uint,
 367                                 inner: *const TyDesc) -> bool {
 368         self.inner.push_ptr();
 369         self.bump(offset);
 370         if ! self.inner.visit_enum_variant_field(i, offset, inner) { return false; }
 371         self.inner.pop_ptr();
 372         true
 373     }
 374
 375     fn visit_leave_enum_variant(&mut self, variant: uint,
 376                                 disr_val: Disr,
 377                                 n_fields: uint,
 378                                 name: &str) -> bool {
 379         if ! self.inner.visit_leave_enum_variant(variant, disr_val,
 380                                                  n_fields, name) {
 381             return false;
 382         }
 383         true
 384     }
 385
 386     fn visit_leave_enum(&mut self, n_variants: uint,
 387                         get_disr: unsafe extern fn(ptr: *const Opaque) -> Disr,
 388                         sz: uint, align: uint) -> bool {
 389         if ! self.inner.visit_leave_enum(n_variants, get_disr, sz, align) {
 390             return false;
 391         }
 392         self.bump(sz);
 393         true
 394     }
 395
 396     fn visit_trait(&mut self, name: &str) -> bool {
 397         self.align_to::<Box<TyVisitor>>();
 398         if ! self.inner.visit_trait(name) { return false; }
 399         self.bump_past::<Box<TyVisitor>>();
 400         true
 401     }
 402
 403     fn visit_param(&mut self, i: uint) -> bool {
 404         if ! self.inner.visit_param(i) { return false; }
 405         true
 406     }
 407
 408     fn visit_self(&mut self) -> bool {
 409         self.align_to::<&'static u8>();
 410         if ! self.inner.visit_self() { return false; }
 411         self.align_to::<&'static u8>();
 412         true
 413     }
 414 }