hphp/runtime/base/member-val-inl.h

   1 /*
   2    +----------------------------------------------------------------------+
   3    | HipHop for PHP                                                       |
   4    +----------------------------------------------------------------------+
   5    | Copyright (c) 2010-present Facebook, Inc. (http://www.facebook.com)  |
   6    +----------------------------------------------------------------------+
   7    | This source file is subject to version 3.01 of the PHP license,      |
   8    | that is bundled with this package in the file LICENSE, and is        |
   9    | available through the world-wide-web at the following url:           |
  10    | http://www.php.net/license/3_01.txt                                  |
  11    | If you did not receive a copy of the PHP license and are unable to   |
  12    | obtain it through the world-wide-web, please send a note to          |
  13    | license@php.net so we can mail you a copy immediately.               |
  14    +----------------------------------------------------------------------+
  15 */
  16
  17 #include "hphp/runtime/base/header-kind.h"
  18 #include "hphp/runtime/base/typed-value.h"
  19
  20 namespace HPHP {
  21
  22 ///////////////////////////////////////////////////////////////////////////////
  23
  24 inline member_lval::member_lval()
  25   : m_base(nullptr)
  26   , m_ptr(nullptr)
  27 {}
  28
  29 inline member_lval::member_lval(HeapObject* base, member_lval::ptr_u ptr)
  30   : m_base(base)
  31   , m_ptr(ptr)
  32 {}
  33
  34 inline member_lval::member_lval(HeapObject* base, TypedValue* elem)
  35   : m_base(base)
  36   , m_ptr(elem)
  37 {}
  38
  39 inline member_lval member_lval::raw(TypedValue* tv) {
  40   return member_lval { nullptr, tv };
  41 }
  42
  43 inline HeapObject* member_lval::base() const {
  44   return m_base;
  45 }
  46
  47 inline ArrayData* member_lval::arr_base() const {
  48   assertx(isArrayKind(m_base->kind()));
  49   return m_arr;
  50 }
  51
  52 inline member_lval::operator bool() const {
  53   return !!m_ptr;
  54 }
  55
  56 inline bool member_lval::has_ref() const {
  57   return !!m_ptr;
  58 }
  59
  60 inline Value& member_lval::val() const {
  61   return *m_ptr.val;
  62 }
  63
  64 inline DataType& member_lval::type() const {
  65   return m_ptr.tv->m_type;
  66 }
  67
  68 inline TypedValue* member_lval::tv_ptr() const {
  69   return m_ptr.tv;
  70 }
  71
  72 inline TypedValue member_lval::tv() const {
  73   return *m_ptr.tv;
  74 }
  75
  76 inline member_lval::ptr_u member_lval::elem() const {
  77   return m_ptr;
  78 }
  79
  80 ///////////////////////////////////////////////////////////////////////////////
  81
  82 ALWAYS_INLINE DataType& type(member_lval lval) { return lval.type(); }
  83 ALWAYS_INLINE Value& val(member_lval lval) { return lval.val(); }
  84 ALWAYS_INLINE TypedValue as_tv(member_lval lval) { return lval.tv(); }
  85
  86 ///////////////////////////////////////////////////////////////////////////////
  87
  88 inline member_rval::member_rval()
  89   : m_base(nullptr)
  90   , m_ptr(nullptr)
  91 {}
  92
  93 inline member_rval::member_rval(const HeapObject* base,
  94                                 member_rval::ptr_u ptr)
  95   : m_base(base)
  96   , m_ptr(ptr)
  97 {}
  98
  99 inline member_rval::member_rval(const HeapObject* base,
 100                                 const TypedValue* elem)
 101   : m_base(base)
 102   , m_ptr(elem)
 103 {}
 104
 105 inline bool member_rval::operator==(member_rval o) const {
 106   return m_base == o.m_base &&
 107          m_ptr.tv == o.m_ptr.tv;
 108 }
 109
 110 inline const HeapObject* member_rval::base() const {
 111   return m_base;
 112 }
 113
 114 inline member_rval::operator bool() const {
 115   return !!m_ptr;
 116 }
 117
 118 inline bool member_rval::has_val() const {
 119   return !!m_ptr;
 120 }
 121
 122 inline Value member_rval::val() const {
 123   return *m_ptr.val;
 124 }
 125
 126 inline DataType member_rval::type() const {
 127   return m_ptr.tv->m_type;
 128 }
 129
 130 inline const TypedValue* member_rval::tv_ptr() const {
 131   return m_ptr.tv;
 132 }
 133
 134 inline TypedValue member_rval::tv() const {
 135   return *m_ptr.tv;
 136 }
 137
 138 inline member_rval::ptr_u member_rval::elem() const {
 139   return m_ptr;
 140 }
 141
 142 inline member_rval member_rval::dummy() {
 143   return member_rval { nullptr, &immutable_uninit_base };
 144 }
 145
 146 inline bool member_rval::is_dummy() const {
 147   return *this == dummy();
 148 }
 149
 150 ///////////////////////////////////////////////////////////////////////////////
 151
 152 }